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); }