protected override void When()
{
base.When();
_event = new MockDomainEvent();
_eventRepository.Record(_event);
}
public Task ExceptionsRecorded_ForEachEventHandler()
{
return(ContainerSetup.Arrange((TestTypeResolver config) => {
config.AddPlugin <MockAppHostPlugin>()
.AddPluginType <MockDomainEvent>()
.AddPluginType <MockErrorMessageConsumer>();
config.AddPlugin <MockCorePlugin>()
.UseMessagingPlugin();
})
.Test(async c =>
{
c.WithConfig <AutofacRegistrationConfig>(regConfig =>
{
regConfig.Build = builder =>
{
builder.RegisterType <NullEntityScriptingService>()
.As <IEntityScriptingService>()
.SingleInstance();
};
});
c.Build();
var srv = c.Services.Resolve <IMessagingService>();
var evt = new MockDomainEvent();
await srv.PublishAsync(evt);
},
(c, e) =>
{
e.Should().NotBeNull();
e.Should().BeOfType <PublisherException>();
}));
}
public Task OnEvent1Async(MockDomainEvent evt)
{
return(Task.Run(() =>
{
throw new InvalidOperationException(nameof(OnEvent1Async));
}));
}
public void MessageDeliveryRequiresAck_AndConsumerNoAck_RabbitNotifiedBasicReject()
{
var stateSetup = BrokerTest.SetupBrokerState();
var brokerSetup = BrokerTest.SetupMessageBroker();
var exchange = new MockExchange();
var msgConsumer = BrokerTest.SetupExclusiveConsumer();
var domainEvt = new MockDomainEvent();
// Setup of test DirectExchange instance that can be asserted.
exchange.InitializeSettings(stateSetup.BrokerState.BrokerSettings);
stateSetup.BrokerState.Exchanges = new[] { exchange };
// Initialize the broker.
brokerSetup.Initialize(stateSetup.BrokerState, msgConsumer);
// Provide a mock consumer that rejects the received message,
brokerSetup.MockMsgModule.Setup(m => m.InvokeDispatcherAsync(
It.IsAny <MessageDispatchInfo>(),
It.IsAny <IMessage>(),
It.IsAny <CancellationToken>()))
.Returns((MessageDispatchInfo di, IMessage m) => {
m.SetRejected();
return(Task.FromResult <object>(null));
});
// Simulate receiving of a message and verify that the RabbitMq
// client was called correctly.
brokerSetup.SimulateMessageReceived(domainEvt);
stateSetup.MockConnMgr.MockChannel.Verify(m => m.BasicReject(It.IsAny <ulong>(), It.IsAny <bool>()), Times.Once());
}
public Task OnEvent2Async(MockDomainEvent evt)
{
AddCalledHandler(nameof(OnEvent2Async));
return(Task.Run(() =>
{
}));
}
public void OnEventHandlerOne(MockDomainEvent domainEvent)
{
if (domainEvent == null)
{
throw new ArgumentNullException(nameof(domainEvent));
}
AddCalledHandler("OnEventHandlerOne");
}
public void PrivatePropertiesWithSettersSerialized()
{
var de = new MockDomainEvent("Tom", "Green");
var mgr = new SerializationManager();
var json = mgr.Serialize(de, ContentTypes.Json);
var de2 = mgr.Deserialize <MockDomainEvent>(ContentTypes.Json, json);
de2.FirstName.Should().Be(de.FirstName);
de2.LastName.Should().Be(de.LastName);
}
public void AddDomainEvent_SingleDomainEvent_ShouldNotBeEmpty()
{
// Arrange
var entity = new MockEntity();
var domainEvent = new MockDomainEvent();
// Act
entity.AddDomainEvent(domainEvent);
// Assert
entity.DomainEvents.Should().NotBeEmpty();
}
public void AggregateRootBase_AddEvent_EventAdded()
{
var mockAggregateRoot = new MockAggregateRoot();
var mockEvent = new MockDomainEvent();
int initialCount = mockAggregateRoot.Events.Count();
mockAggregateRoot.AddEvent(mockEvent);
int afterCount = mockAggregateRoot.Events.Count();
Assert.That(initialCount == 0 && afterCount == 1);
}
public void AggregateRootBase_ClearEvents_EventsCleared()
{
var mockAggregateRoot = new MockAggregateRoot();
var mockEvent = new MockDomainEvent();
mockAggregateRoot.AddEvent(mockEvent);
int initialCount = mockAggregateRoot.Events.Count();
mockAggregateRoot.ClearEvents();
int afterCount = mockAggregateRoot.Events.Count();
Assert.That(initialCount == 1 && afterCount == 0);
}
public void Event_AssociatedWith_Exchange()
{
var brokerSetup = BrokerTest.SetupMessageBroker();
var exchange = new MockExchange();
var stateSetup = BrokerTest.SetupBrokerState();
// Setup of test DirectExchange instance that can be asserted.
exchange.InitializeSettings(stateSetup.BrokerState.BrokerSettings);
stateSetup.BrokerState.Exchanges = new[] { exchange };
brokerSetup.Initialize(stateSetup.BrokerState);
var msg = new MockDomainEvent();
brokerSetup.Instance.IsExchangeMessage(msg).Should().BeTrue();
}
public void AttributedEntity_DynamicProperty_NotSerialized()
{
var de = new MockDomainEvent("Tom", "Green");
var mgr = new SerializationManager();
de.Attributes.Values.State = "PA";
var json = mgr.Serialize(de, ContentTypes.Json);
var jsonString = Encoding.UTF8.GetString(json);
jsonString.Should().NotContain("Attributes");
var de2 = mgr.Deserialize <MockDomainEvent>(ContentTypes.Json, json);
string state = de2.Attributes.Values.State;
state.Should().Be("PA");
}
public Task DomainEventAsyncHandlers_CanBeInvoked()
{
return(AsyncMessageConsumer.Test(
async c =>
{
c.WithConfig <MessagingConfig>();
c.Build();
var domainEventSrv = c.Services.Resolve <IMessagingService>();
var evt = new MockDomainEvent();
await domainEventSrv.PublishAsync(evt);
},
(IAppContainer c) =>
{
var consumer = c.Services.Resolve <MockAsyncMessageConsumer>();
consumer.ExecutedHandlers.Should().HaveCount(3);
consumer.ExecutedHandlers.Should().Contain("OnEvent1Async", "OnEvent2Async", "OnEvent3");
}
));
}
public Task DomainEventConsumer_HandlerInvoked()
{
return(ContainerFixture.TestAsync(async fixture =>
{
var testResult = await fixture.Arrange
.Container(c => c.WithHostConsumer())
.Act.OnServices(async s =>
{
var mockEvt = new MockDomainEvent();
await s.GetService <IMessagingService>()
.PublishAsync(mockEvt);
});
testResult.Assert.Services(s =>
{
var consumer = s.GetService <MockDomainEventConsumer>();
consumer.ExecutedHandlers.Should().Contain("OnEventHandlerOne");
});
}));
}
public Task DomainEventConsumer_HandlerInvoked()
{
return(DefaultSetup.EventConsumer.Test(
async c =>
{
c.Build();
var mockEvt = new MockDomainEvent();
await c.Services.Resolve <IMessagingService>()
.PublishAsync(mockEvt);
},
(IAppContainer c) =>
{
var consumer = c.Services.Resolve <IEnumerable <IMessageConsumer> >()
.OfType <MockDomainEventConsumer>()
.First();
consumer.ExecutedHandlers.Should().Contain("OnEventHandlerOne");
}));
}
public Task HandlerCalled_WhenMessagePassesDispathPredicate()
{
return(ScriptEventConsumer.Test(
async c => {
c.Build();
var mockEvt = new MockDomainEvent {
RuleTestValue = 7000
};
await c.Services.Resolve <IMessagingService>()
.PublishAsync(mockEvt);
},
(IAppContainer c) => {
var consumer = c.Services.Resolve <IEnumerable <IMessageConsumer> >()
.OfType <MockDomainEventConsumer>()
.First();
consumer.ExecutedHandlers.Should().Contain("OnEventPredicatePases");
}));
}
public Task DomainEventAsyncHandlers_CanBeInvoked()
{
return(ContainerFixture.TestAsync(async fixture =>
{
var testResult = await fixture.Arrange
.Container(c => c.WithHostAsyncConsumer())
.Act.OnServices(async s =>
{
var messagingSrv = s.GetService <IMessagingService>();
var evt = new MockDomainEvent();
await messagingSrv.PublishAsync(evt);
});
testResult.Assert.Services(s =>
{
var consumer = s.GetRequiredService <MockAsyncMessageConsumer>();
consumer.ExecutedHandlers.Should().HaveCount(3);
consumer.ExecutedHandlers.Should().Contain("OnEvent1Async", "OnEvent2Async", "OnEvent3");
});
}));
}
public void OnEventHandlerOne(MockDomainEvent domainEvent)
{
Check.NotNull(domainEvent, nameof(domainEvent));
AddCalledHandler("OnEventHandlerOne");
}
public void OnDomainEvent(MockDomainEvent domainEvt)
{
Assert.NotNull(domainEvt);
}
public void OnEvent3(MockDomainEvent evt)
{
AddCalledHandler(nameof(OnEvent3));
}
public void OnEventAnyRulePasses(MockDomainEvent evt)
{
AddCalledHandler(nameof(OnEventAnyRulePasses));
}
public void OnEventAllRulesPass(MockDomainEvent evt)
{
AddCalledHandler(nameof(OnEventAllRulesPass));
}
public void OnEventPredicatePases(MockDomainEvent evt)
{
AddCalledHandler(nameof(OnEventPredicatePases));
}
public void OnAdd(MockDomainEvent evt)
{
}
public void OnJoin(MockDomainEvent evt)
{
}
