public void WhenICreateAnEventItIsCreated()
{
var expectedEventId = Guid.NewGuid();
var expectedContextId = Guid.NewGuid();
var expectedEventData = Guid.NewGuid().ToString();
var expectedEventType = Substitute.For <IEventType>();
var expectedEventDateTime = DateTime.Now;
var expectedEffectiveDateTime = DateTime.Now.AddDays(-2);
var eventData = Substitute.For <IEventData>();
_guidProvider.Create().Returns(expectedEventId);
_dateTimeProvider.GetUtc().Returns(expectedEventDateTime);
_eventDataSerializationService.Serialize(eventData).Returns(expectedEventData);
_eventTypeService.Get <IEventData>().Returns(expectedEventType);
var result = _target.Create(expectedContextId, eventData, expectedEffectiveDateTime);
Assert.Equal(expectedEventId, result.EventId);
Assert.Equal(expectedContextId, result.ContextId);
Assert.Equal(expectedEventDateTime, result.CreatedDateTime);
Assert.Equal(expectedEffectiveDateTime, result.EffectiveDateTime);
Assert.Same(expectedEventType, result.EventType);
Assert.Equal(expectedEventData, result.EventData);
Assert.False(result.Undone);
}
public void CreateEvent_CallEventFactory(
[Frozen] IEventFactory eventFactory,
CreateEventCommand message,
Event @event,
CreateEventCommandHandler createEventCommandHandler)
{
//Information
A.CallTo(() => eventFactory.Create(message.Event)).Returns(@event);
//Act
createEventCommandHandler.ExecuteAsync(message);
//Test
A.CallTo(() => eventFactory.Create(message.Event)).MustHaveHappened();
}
protected void Apply <TEvent>(Action <TEvent> action)
{
var @event = _eventFactory.Create(action);
Raise(@event);
_events.Add(@event);
}
public Event Adapt(EventDataModel dataModel)
{
var eventRegistrations = dataModel.Registrations.Select(
f => _eventRegistrationFactory.Create(f.IndividualId, f.EmailId, f.Id))
.ToList();
return(_eventFactory.Create(dataModel.EventName, eventRegistrations, dataModel.Id));
}
public IEnumerable <IEvent> Execute(Guid contextId, SetNameCommand command)
{
var setNameEventData = new SetNameEventData {
Name = command.Name
};
var @event = _eventFactory.Create(contextId, setNameEventData);
return(new[] { @event });
}
public IEnumerable <IEvent> Execute(Guid contextId, SetDateOfBirth2Command command)
{
var setNameEventData = new SetDateOfBirthEventDataV2 {
DateOfBirth = command.DateOfBirth, HourOfBirth = 10
};
var @event = _eventFactory.Create(contextId, setNameEventData);
return(new[] { @event });
}
public Task ExecuteAsync(CreateEventCommand message)
{
var @event = _eventFactory.Create(message.Event);
_eventRepository.Add(@event);
_createRouteCommandHandler.ExecuteAsync(new CreateRouteCommand(message.Route));
return(Task.CompletedTask);
}
public override async Task <ModelEvent> MapToModel(SnapshotEvent snapshotEvent, SnapshotContext snapshotContext)
{
var modelEvent = _eventFactory.Create(snapshotEvent.Template);
MapSnapshotPropertiesToModel(snapshotEvent, modelEvent);
await UpdateParametersFromSnapshot(snapshotEvent, modelEvent, snapshotContext, snapshotEvent.Template);
return(modelEvent);
}
public IEnumerable <IEvent> Execute(Guid contextId, AddPremiumCommand command)
{
yield return(_eventFactory.Create(contextId,
new AddPremiumData(
command.PremiumId,
command.PremiumSpread.ToDictionary(
t => t.Key,
t => new AddPremiumData.PremiumSpreadData {
Id = t.Value.Id, Amount = t.Value.Amount
}))));
}
public void WhenTheHandlerExecutes(IEventFactory eventFactory, ApplyUnitAllocationCommand applyUnitAllocationCommand)
{
var expectedEvent = Substitute.For <IEvent>();
var target = new ApplyUnitAllocationHandler(eventFactory);
var contextId = Guid.NewGuid();
eventFactory.Create(contextId, Arg.Is <UnitsAllocatedData>(data =>
data.FundId == applyUnitAllocationCommand.FundId &&
data.OfferPrice == applyUnitAllocationCommand.OfferPrice)).Returns(expectedEvent);
var result = target.Execute(contextId, applyUnitAllocationCommand);
Assert.Contains(expectedEvent, result);
}
public void WhenTheHandlerExecutes(IEventFactory eventFactory, PremiumReceivedCommand createNewPolicyCommand)
{
var expectedEvent = Substitute.For <IEvent>();
var target = new PremiumReceivedHandler(eventFactory);
var contextId = Guid.NewGuid();
eventFactory.Create(contextId, Arg.Is <PremiumReceivedData>(data =>
data.PremiumId == createNewPolicyCommand.PremiumId &&
data.DateTimeReceived == createNewPolicyCommand.DateTimeReceived)).Returns(expectedEvent);
var result = target.Execute(contextId, createNewPolicyCommand);
Assert.Contains(expectedEvent, result);
}
public void WhenTheHandlerExecutes(IEventFactory eventFactory, CreateNewPolicyCommand createNewPolicyCommand)
{
var expectedEvent = Substitute.For <IEvent>();
var target = new CreateNewPolicyHandler(eventFactory);
var contextId = Guid.NewGuid();
eventFactory.Create(contextId, Arg.Is <PolicyCreationData>(data =>
data.CustomerId == createNewPolicyCommand.CustomerId &&
data.PolicyNumber == createNewPolicyCommand.PolicyNumber)).Returns(expectedEvent);
var result = target.Execute(contextId, createNewPolicyCommand);
Assert.Contains(expectedEvent, result);
}
public void WhenTheHandlerExecutes(IEventFactory eventFactory, AddPremiumCommand addPremiumCommand)
{
var expectedEvent = Substitute.For <IEvent>();
var target = new AddPremiumCommandHandler(eventFactory);
var contextId = Guid.NewGuid();
eventFactory.Create(contextId, Arg.Is <AddPremiumData>(data =>
data.PremiumId == addPremiumCommand.PremiumId &&
ExceptionHelpers.ExecuteSuccessfully(() => ValidateAddPremium(addPremiumCommand, data)))).Returns(expectedEvent);
var result = target.Execute(contextId, addPremiumCommand);
Assert.Contains(expectedEvent, result);
}
public void WhenTheHandlerExecutes(IEventFactory eventFactory, ApplyManagementChargeCommand applyManagementChargeCommand)
{
var expectedEvent = Substitute.For <IEvent>();
var target = new ApplyManagementChargeHandler(eventFactory);
var contextId = Guid.NewGuid();
eventFactory.Create(contextId, Arg.Is <ManagementChargeAppliedData>(data =>
data.FundId == applyManagementChargeCommand.FundId &&
data.ChargeFactor == applyManagementChargeCommand.ChargeFactor)).Returns(expectedEvent);
var result = target.Execute(contextId, applyManagementChargeCommand);
Assert.Contains(expectedEvent, result);
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
if (objectType.IsInterface)
{
var mappedType = _eventMapper.GetMappedTypeFor(objectType);
var objectContract = base.CreateObjectContract(mappedType);
objectContract.DefaultCreator = () => _eventFactory.Create(mappedType);
return(objectContract);
}
return(base.CreateObjectContract(objectType));
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
var mappedType = _eventMapper.GetMappedTypeFor(objectType);
if (mappedType == null)
{
return(base.CreateObjectContract(objectType));
}
var jsonObjectContract = base.CreateObjectContract(mappedType);
jsonObjectContract.DefaultCreator = () => _eventFactory.Create(mappedType);
return(jsonObjectContract);
}
public List <Event> Mapper(DbDataReader source)
{
var events = new List <Event>();
while (source.Read())
{
var id = source.GetGuid(0);
var version = source.GetInt16(1);
var timeStamp = source.GetInt64(2);
var contentType = source.GetString(4);
var json = source.GetString(3);
var @event = _eventFactory.Create(id, version, timeStamp, json, contentType);
events.Add(@event);
}
return(events);
}
public async Task <IActionResult> SaveEventAsync([FromBody] EventDto dto)
{
var eventRegistrations = dto.Registrations?.Select(
f => _eventRegistrationFactory.Create(f.IndividualId, f.EmailId, f.Id))
.ToList();
var newEvent = _eventFactory.Create(
dto.EventName,
eventRegistrations);
var returnedEvent = await _eventRepository.SaveAsync(newEvent);
var result = _mapper.Map <EventDto>(returnedEvent);
return(Ok(result));
}
public void WhenTheHandlerExecutes(IEventFactory eventFactory, AdjustFundInstanceUnitsCommand adjustFundInstanceUnitsCommand)
{
var expectedEvent = Substitute.For <IEvent>();
var target = new AdjustFundInstanceUnitsHandler(eventFactory);
var contextId = Guid.NewGuid();
eventFactory.Create(contextId, Arg.Is <FundInstanceUnitAdjustmentData>(data =>
data.FundId == adjustFundInstanceUnitsCommand.FundId &&
data.InstanceId == adjustFundInstanceUnitsCommand.FundInstanceId &&
data.UnitAdjustment == adjustFundInstanceUnitsCommand.UnitAdjustment &&
data.Reason == adjustFundInstanceUnitsCommand.Reason)).Returns(expectedEvent);
var result = target.Execute(contextId, adjustFundInstanceUnitsCommand);
Assert.Contains(expectedEvent, result);
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
var mappedTypeFor = objectType;
_mapper.Initialize(objectType);
mappedTypeFor = _mapper.GetMappedTypeFor(objectType);
if (mappedTypeFor == null)
{
return(base.CreateObjectContract(objectType));
}
var objectContract = base.CreateObjectContract(objectType);
objectContract.DefaultCreator = () => _factory.Create(objectType);
return(objectContract);
}
public void CreateEvent_SendICommandHandlerWithCreateRouteCommand(
[Frozen] ICommandHandler <CreateRouteCommand> createRouteCommandHandler,
[Frozen] IEventRepository eventRepository,
[Frozen] IEventFactory eventFactory,
CreateEventCommand message,
Event @event,
CreateEventCommandHandler createEventCommandHandler)
{
//Information
A.CallTo(() => eventFactory.Create(message.Event)).Returns(@event);
A.CallTo(() => eventRepository.Add(@event));
//Act
createEventCommandHandler.ExecuteAsync(message);
//Test
A.CallTo(() => createRouteCommandHandler.ExecuteAsync(A <CreateRouteCommand> .Ignored))
.MustHaveHappened();
}
private void templateChanged(TemplateChangedEventArgs e)
{
_macroCommand.Clear();
Event = _eventFactory.Create(e.Template);
eventSettingsPresenter.EditEvent(Event);
}
public Task <TResponse> Query <TQuery, TResponse>(Action <TQuery> query, IContainer container) where TQuery : IQuery <TResponse>
{
var result = _eventFactory.Create(query);
return(Query <TQuery, TResponse>(result, container));
}
public IEnumerable <IEvent> Execute(Guid contextId, PremiumReceivedCommand command)
{
yield return(_eventFactory.Create(contextId, new PremiumReceivedData(
command.PremiumId, command.DateTimeReceived)));
}
public IEnumerable <IEvent> Execute(Guid contextId, ApplyManagementChargeCommand command)
{
yield return(_eventFactory.Create(contextId, new ManagementChargeAppliedData(
command.FundId, command.ChargeFactor)));
}
public IEnumerable <IEvent> Execute(Guid contextId, AdjustFundInstanceUnitsCommand command)
{
yield return(_eventFactory.Create(contextId,
new FundInstanceUnitAdjustmentData(command.FundId, command.FundInstanceId, command.UnitAdjustment, command.Reason)));
}
public IEnumerable <IEvent> Execute(Guid contextId, CreateNewPolicyCommand command)
{
yield return(_eventFactory.Create(contextId,
new PolicyCreationData(command.CustomerId, command.PolicyNumber)));
}
public IEnumerable <IEvent> Execute(Guid contextId, ApplyUnitAllocationCommand command)
{
yield return(_eventFactory.Create(contextId, new UnitsAllocatedData(
command.FundId, command.OfferPrice)));
}
protected void Apply <TEvent>(Action <TEvent> action)
{
_events.Add(_eventFactory.Create(action));
}
private bool TryGetEvent(byte[] data, out IEvent evnt)
{
evnt = _eventFactory.Create(data);
return(null != evnt);
}
