public void UseConventionsRegistersProperTopics(string messageText)
{
// Arrange
var testContext = new TestBusContext();
var hostBuilder = new MicroserviceHostBuilder().WithBusContext(testContext);
// Act
hostBuilder.UseConventions();
hostBuilder.CreateHost().Start();
// Assert
var message = new DummyEvent("IrrelevantTopic")
{
DummyText = messageText
};
new EventPublisher(testContext).Publish(message);
Thread.Sleep(WaitTime);
Assert.IsNull(EventListenerDummy.HandlesResult);
Assert.IsNull(EventListenerDummy2.HandlesResult);
Assert.AreEqual(message, EventListenerDummy3.HandlesResult);
}
public async Task run_event_broadcasting_scenario(int hostsCount)
{
var message = new DummyEvent(Guid.NewGuid(), Guid.NewGuid());
var tokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(20));
var expectedHosts = Enumerable.Range(1, hostsCount)
.Select(i => $"host_{i}")
.ToDictionary(h => h, h => 2);
Action <IMessageContext <DummyEvent> > onMessage = async ctx =>
{
if (expectedHosts.ContainsKey(ctx.SystemInfo.ClientGroup))
{
expectedHosts[ctx.SystemInfo.ClientGroup]--;
if (expectedHosts[ctx.SystemInfo.ClientGroup] < 1)
{
expectedHosts.Remove(ctx.SystemInfo.ClientGroup);
}
}
if (!expectedHosts.Any())
{
tokenSource.Cancel();
}
};
var createHostTasks = Enumerable.Range(1, hostsCount)
.Select(async i =>
{
var host = await SetupHostAsync(onMessage, i);
await host.StartAsync(tokenSource.Token);
return(host);
}).ToArray();
await Task.WhenAll(createHostTasks);
var producerHost = createHostTasks.First().Result;
using var scope = producerHost.Services.CreateScope();
var bus = scope.ServiceProvider.GetRequiredService <IMessageBus>();
await bus.PublishAsync(message, tokenSource.Token);
while (!tokenSource.IsCancellationRequested)
{
await Task.Delay(100);
}
foreach (var t in createHostTasks)
{
try
{
t.Result.Dispose();
}
catch {}
}
expectedHosts.Should().BeEmpty();
}
public void RegisterNewMockedEvent_SetsUpGetEvent_NoParam()
{
_ = _eventAggregator.RegisterNewMockedEvent <DummyEvent>();
DummyEvent @event = _eventAggregator.Object.GetEvent <DummyEvent>();
Assert.NotNull(@event);
}
public void Handle(DummyEvent dummyEvent)
{
_logger.LogInformation("Handling event");
_databaseService.InsertMessageData(new MessageDataDto
{
MessageText = dummyEvent.Text
});
_logger.LogInformation("Event handled successfully");
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
var body = Encoding.UTF8.GetString(message.Body);
_logger.LogInformation($"Received message: Body:{body}");
var @event = new DummyEvent {
Text = body
};
_dummyEventHandler.Handle(@event);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
public async Task PtyMessageHandler_Handle_ReturnsUnknownMessageEventForAnUnknownMessage()
{
// Given
var message = new DummyEvent();
// When
var handler = new PtyMessageHandler(MockEngine.Object, MockConfig.Object, MockLogger.Object);
var result = await handler.Handle(message);
// Then
var response = Assert.IsType <UnknownMessageEvent>(result);
Assert.Equal(nameof(DummyEvent), response.Name);
}
public void DeliverThemToSubscribers()
{
var id = 1;
var dummyEvent = new DummyEvent(id: id);
var bus = new Bus();
var aHandler = Substitute.For <IHandleMessagesOf <DummyEvent> >();
var anotherHandler = Substitute.For <IHandleMessagesOf <DummyEvent> >();
bus.RegisterHandlers(aHandler, anotherHandler);
bus.Publish(dummyEvent);
aHandler.Received().Handle(Arg.Is <DummyEvent>(@event => @event.Id == id));
anotherHandler.Received().Handle(Arg.Is <DummyEvent>(@event => @event.Id == id));
}
public async Task PtyMessageHandler_Handle_WritesALogMessageWhenGivenAnUnknownMessage()
{
// Given
var message = new DummyEvent();
// When
var handler = new PtyMessageHandler(MockEngine.Object, MockConfig.Object, MockLogger.Object);
var result = await handler.Handle(message);
// Then
MockLogger.Verify(
logger => logger.LogWarning("UnknownMessage {messageName}", nameof(DummyEvent)),
Times.Once
);
}
public void HandlesSavesDeliveredMessage()
{
// Arrange
var repoMock = new Mock <IAuditLogItemRepository>();
var listener = new AuditEventLoggingListener(repoMock.Object, new NullLoggerFactory());
var dummyEvent = new DummyEvent("test.event");
string jsonEvent = JsonConvert.SerializeObject(dummyEvent);
// Act
listener.Handle(jsonEvent);
// Assert
repoMock.Verify(e => e.Save(It.IsAny <AuditLogItem>()));
}
public async Task PublishAsyncTest()
{
var domainEvent = new DummyEvent {
Name = "John Doe"
};
var serializedEvent = new ReadOnlyMemory <byte>(new byte[] { 1, 1, 1 });
// Setup mocks
_serializer.Setup(s => s.SerializeAsync(It.IsAny <MessageMetadata <DummyEvent> >(), default))
.Returns(Task.FromResult(serializedEvent));
_transport.Setup(t => t.SendMessageAsync <DummyEvent>(serializedEvent)).Returns(Task.CompletedTask);
// Execute tests
await _bus.PublishAsync(domainEvent);
_transport.Verify();
}
public DefaultMessageReceiverTests()
{
_options = new Mock <IOptions <ServicebusConfiguration> >();
_logger = new Mock <ILogger <DefaultMessageReceiver> >();
_services = new ServiceCollection();
_serializer = new Mock <IDomainEventSerializer>();
_handler = new Mock <IDomainEventHandler <DummyEvent> >();
_serializedDomainEvent = new ReadOnlyMemory <byte>(new byte[] { 1, 1, 1 });
_domainEvent = new DummyEvent {
Name = "Hello world"
};
_services.AddTransient(p => _handler.Object);
_options.Setup(o => o.Value).Returns(new ServicebusConfiguration
{
ServiceName = ServiceName
});
}
public void WhenPublishingEvent_WithMultipleSubscribers_InvokesSubscribers()
{
var subscribers = Enumerable.Range(1, 3).Select(i => new DummySubscriber()).ToArray();
foreach (var subscriber in subscribers)
{
_target.Subscribe <DummyEvent>(subscriber.Handle);
}
var publishedEvent = new DummyEvent();
_target.Publish(publishedEvent);
foreach (var subscriber in subscribers)
{
Assert.That(subscriber.HandledEvents, Is.EquivalentTo(new[] { publishedEvent }));
}
}
public void EventIsProperlyReceived(string data)
{
// Arrange
AuditLogContext dbContext = new AuditLogContext(_options);
TestBusContext testBusContext = new TestBusContext();
using var hostBuilder = new MicroserviceHostBuilder()
.WithBusContext(testBusContext)
.RegisterDependencies(services =>
{
services.AddSingleton(dbContext);
services.AddTransient <IAuditLogItemRepository, AuditLogItemRepository>();
})
.AddEventListener <IAuditLogItemRepository>()
.AddEventListener <AuditEventLoggingListener>();
using var host = hostBuilder.CreateHost();
host.Start();
DummyEvent evt = new DummyEvent("test.queue")
{
Text = data
};
IEventPublisher eventPublisher = new EventPublisher(testBusContext);
// Act
eventPublisher.Publish(evt);
Thread.Sleep(1500);
// Assert
AuditLogItem[] resultData = dbContext.AuditLogItems.ToArray();
Assert.AreEqual(1, resultData.Length);
string expectedData = JsonConvert.SerializeObject(evt);
var firstItem = resultData.First();
Assert.AreEqual(expectedData, firstItem.Data);
Assert.AreEqual(evt.Id.ToString(), firstItem.Id);
Assert.AreEqual(new DateTime(evt.Timestamp).ToFileTimeUtc(), firstItem.TimeStamp);
}
private void describe_Start()
{
context["when event has been added to EventStore"] = () =>
{
before = () =>
{
var someEvent = new DummyEvent();
var eventData = _serializer.ToEventData(someEvent);
_connection.AppendToStreamAsync("dummy", ExpectedVersion.Any, eventData).Wait();
_subscription = _sut.Start(_connection);
};
after = () => _subscription?.Stop();
it["eventually calls event handler"] =
() => Eventually.IsTrue(() => _eventHandler.WasCalledWithDummyEvent);
};
}
public void Init(ProgressBar bar, string category, string value, string param, int repeat, Label label, DummyEvent onUpdate = null)
{
this.repeat = repeat;
this.label = label;
this.bar = bar;
OnUpdate = onUpdate;
this.value = 0;
perfCounter = new PerformanceCounter(category, value, param);
backgroundWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
backgroundWorker.DoWork += BackgroundWorker_DoWork;
backgroundWorker.ProgressChanged += BackgroundWorker_ProgressChanged;
backgroundWorker.RunWorkerAsync();
}
public async Task run_event_broadcasting_scenario()
{
var hostBuilder = CreateHostBuilder();
var message = new DummyEvent(Guid.NewGuid(), Guid.NewGuid());
var tokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(1));
var callsCount = 0;
var expectedCount = 2;
Action <DummyEvent> onMessage = msg =>
{
callsCount++;
if (callsCount >= expectedCount)
{
tokenSource.Cancel();
}
};
hostBuilder.ConfigureServices((ctx, services) =>
{
services.AddSingleton(onMessage);
});
var host = hostBuilder.Build();
await host.SetupInfrastructureAsync();
using var scope = host.Services.CreateScope();
var bus = scope.ServiceProvider.GetRequiredService <IMessageBus>();
await Task.WhenAll(new[]
{
host.RunAsync(token: tokenSource.Token),
bus.PublishAsync(message, tokenSource.Token)
});
callsCount.Should().Be(expectedCount);
}
private void Handler(DummyEvent e)
{
throw new Exception();
}
public void Handle(DummyEvent dummyEvent)
{
// Neither should this code be reached
}
internal int When(DummyEvent @event) => throw new Detected();
public DummyEvent Handle(DummyEvent ev1)
{
return(new DummyEvent("test"));
}
public void Handle(DummyEvent @event)
{
// Nothing
}
public void Handles(DummyEvent dummyEvent) => HandlesResult = dummyEvent;
internal void When(DummyEvent @event, int other) => throw new NotSupportedException($"{@event} + {other}.");
public void WhenRaisingAnEventItShouldBeUniquelyIdentifiedWhenSending()
{
var transport1 = Substitute.For<EventTransport>();
var transport2 = Substitute.For<EventTransport>();
var subject = new EventDistributor(null, null, new[] { transport1, transport2 }, () => new DateTime(2012, 11, 10, 09, 08, 07));
var actual = new DummyEvent();
subject.Raise(actual);
transport1.Received().Send(Arg.Is<UniqueEvent<DummyEvent>>(_ => _.Identity != Guid.Empty));
transport1.Received().Send(Arg.Is<UniqueEvent<DummyEvent>>(_ => _.Event == actual));
}
public void Handle(DummyEvent ev1, DummyEvent ev2)
{
}
