private void LiveConsume() { Receive <DataResponse>(c => { for (var i = 0; i < c.Data.Count; i++) { var msgData = c.Data.ElementAt(i); var msg = msgData["__message_id__"].ToString().Trim('(', ')').Split(',').Select(int.Parse).ToArray(); var messageId = MessageIdUtils.GetOffset(new MessageId(msg[0], msg[1], msg[2])); var eventMessage = new EventEnvelope(msgData, messageId, _topicName.ToString()); _buffer.Post(eventMessage); _currentOffset = messageId; } _buffer.Post(new EventStats(new StatsResponse(c.StatementStats))); }); Receive <StatsResponse>(s => { var stats = new EventStats(s); _buffer.Post(stats); }); Receive <ErrorResponse>(s => { var error = new EventError(s); _buffer.Post(error); }); _queryCancelable = _scheduler.ScheduleOnceCancelable(TimeSpan.FromSeconds(60), Query); }
private void OnReadEvent(EventMetadata m, TEvent e) { EventEnvelope <TEvent> envelope = new EventEnvelope <TEvent>(e, m); _logger.Information("Received event {eventName} from SignalR hub.", envelope.Event.GetType().Name); _uiEventBus.GetEvent <EventEnvelope <TEvent> >().Publish(envelope); }
public async static void OnOrderSendCommandPizza( [ServiceBusTrigger("events", "pizza")] EventEnvelope <OrderCreated> envelope, TextWriter log) { try { var repository = Container.Resolve <IRepository <QueryingOrder, Guid> >(); var e = envelope.Event as OrderCreated; var order = repository.GetById(e.EventId); var pizzas = order.PizzasToDo(); if (pizzas.Any()) { var append = Container.Resolve <IDataSourceAppend <PizzaToDoDTO> >(); await append.AppendAsync(pizzas); var client = Container.Resolve <ITotem>(); await client.NewPizzasToPrepareAsync(e.EventId); } } catch (Exception ex) { // log... } }
private Task On(RawEvent rawEvent, Position?position, DateTime eventCreationTime) { var @event = _deserializer.Deserialize(rawEvent); _log.Debug("Projecting event {event}", rawEvent.Body.ToString()); try { // return Measure(() =>// Should be moved to a messenger decorator // { var envelopedEvent = new EventEnvelope( new MessageChainInfo(@event.Id.ToString() , @event.Metadata.CorrelationId , @event.Metadata.CausationId) , @event.Body); _messenger.Dispatch(envelopedEvent); return(_checkpointStore.StoreCheckpoint(position)); // }, rawEvent.EventType // , eventCreationTime // , _subscriptionName); } catch (Exception exception) { _log.Error(exception , "Error occured when projecting the event {event} from {subscriptionName}" , @event , _subscriptionName); throw; } }
private void Consume() { Receive<DataResponse>(c => { for (var i = 0; i < c.Data.Count; i++) { var msgData = c.Data.ElementAt(i); var msg = msgData["__message_id__"].ToString().Trim('(', ')').Split(',').Select(int.Parse).ToArray(); var messageId = MessageIdUtils.GetOffset(new MessageId(msg[0], msg[1], msg[2])); if (messageId <= _toMessageId) { var eventMessage = new EventEnvelope(msgData, messageId, _topicName.ToString()); _buffer.Post(eventMessage); _currentOffset = messageId; } else Self.GracefulStop(TimeSpan.FromSeconds(5)); } _buffer.Post(new EventStats(new StatsResponse(c.StatementStats))); }); Receive<StatsResponse>(s => { var stats = new EventStats(s); _buffer.Post(stats); }); Receive<ErrorResponse>(s => { var error = new EventError(s); _buffer.Post(error); }); Receive<ReceiveTimeout>(t => { Self.GracefulStop(TimeSpan.FromSeconds(5)); }); //to track last sequence id for lagging player Context.SetReceiveTimeout(TimeSpan.FromSeconds(30)); }
/// <inheritdoc/> public IEnumerable <EventAndEnvelope> GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId) { var eventSourceIdentifier = _applicationResourceIdentifierConverter.AsString(eventSource); var eventPath = GetPathFor(eventSourceIdentifier, eventSourceId); var files = _files.GetFilesIn(eventPath).OrderBy(f => f); var eventFiles = files.Where(f => f.EndsWith(".event")).ToArray(); var envelopeFiles = files.Where(f => f.EndsWith(".envelope")).ToArray(); if (eventFiles.Length != envelopeFiles.Length) { throw new Exception($"There is a problem with event files for {eventSourceIdentifier} with Id {eventSourceId}"); } var events = new List <EventAndEnvelope>(); for (var eventIndex = 0; eventIndex < eventFiles.Length; eventIndex++) { var envelopeFile = envelopeFiles[eventIndex]; var eventFile = eventFiles[eventIndex]; var envelopeAsJson = _files.ReadString(Path.GetDirectoryName(envelopeFile), Path.GetFileName(envelopeFile)); var eventAsJson = _files.ReadString(Path.GetDirectoryName(eventFile), Path.GetFileName(eventFile)); var envelopeValues = _serializer.GetKeyValuesFromJson(envelopeAsJson); var _correllationId = Guid.Parse((string)envelopeValues["CorrelationId"]); var _eventId = Guid.Parse((string)envelopeValues["EventId"]); var _sequenceNumber = (long)envelopeValues["SequenceNumber"]; var _sequenceNumberForEventType = (long)envelopeValues["SequenceNumberForEventType"]; var _generation = (long)envelopeValues["Generation"]; var _event = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["Event"]); var _eventSourceId = Guid.Parse((string)envelopeValues["EventSourceId"]); var _eventSource = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["EventSource"]); var _eventSourceVersion = EventSourceVersion.FromCombined(double.Parse(envelopeValues["Version"].ToString())); var _causedBy = (string)envelopeValues["CausedBy"]; var _occurred = (DateTime)envelopeValues["Occurred"]; var envelope = new EventEnvelope( _correllationId, _eventId, _sequenceNumber, _sequenceNumberForEventType, (int)_generation, _event, _eventSourceId, _eventSource, _eventSourceVersion, _causedBy, _occurred ); var eventType = _applicationResourceResolver.Resolve(envelope.Event); var @event = Activator.CreateInstance(eventType, eventSourceId) as IEvent; _serializer.FromJson(@event, eventAsJson); events.Add(new EventAndEnvelope(envelope, @event)); } return(events); }
void On(EventEnvelope <AddedEmailToDomain> e) { if (!state.Domains.ContainsKey(e.StreamId)) { state.Domains.Add(e.StreamId, 0); } state.Domains[e.StreamId]++; }
public void On(EventEnvelope <TestSuiteFinishedEvent> evnt) { var rc = evnt.Session.Load <ReleaseCandidate>(evnt.Payload.BuildId); var testCases = evnt.Payload.TestOutputs.Select(x => new TestCase(x.Name, x.Result)); rc.TestSuites.Add(new TestSuite(evnt.Payload.SuiteType, evnt.Payload.Result, testCases)); }
CommittedEvent ToCommittedEvent(CommitSequenceNumber commitSequenceNumber, EventEnvelope @event) { var eventType = _artifactTypeMap.GetTypeFor(@event.Metadata.Artifact); var eventInstance = _objectFactory.Build(eventType, @event.Event) as IEvent; var committedEventVersion = new CommittedEventVersion(commitSequenceNumber, @event.Metadata.VersionedEventSource.Version.Commit, @event.Metadata.VersionedEventSource.Version.Sequence); return(new CommittedEvent(committedEventVersion, @event.Metadata, eventInstance)); }
public static IEvent ToEvent(this global::CosmoStore.EventRead <JToken, long> eventRead, Func <string, Type> typeResolver) => typeResolver(eventRead.Name) .Pipe(t => ((EventRecord)eventRead.Data.ToObject(t)) .Pipe(e => EventEnvelope.Create(eventRead.Id.ToString(), e)) .Tap(e => e.Meta = eventRead.Metadata.Value.ToObject <Dictionary <string, string> >()) .Tap(e => e.Meta.AddStoreMetaData(new EventStoreMetaData { EventPosition = eventRead.Version, EventVersion = eventRead.Version })));
public Task Append(EventMetadata m, IEvent e) { var eventEnvelope = new EventEnvelope(e, m); _rootStream.Enqueue(eventEnvelope); _publisher.Publish(eventEnvelope); return(Task.CompletedTask); }
private void GivenTheCurrentEventWillTakeAWhileToBeHandled() { _eventHandler.Block(); while (_eventBeingHandleAtTimeOfSutdownd == null) { _eventBeingHandleAtTimeOfSutdownd = _eventHandler.CurrentEvent; } }
private Event ConvertEventEnvelopeToEvent(EventEnvelope envelope) { return(new Event( id: envelope.Id, occurred: envelope.Occurred, type: envelope.EventType, payload: envelope.Payload )); }
Task Receive(Message message, CancellationToken token) { var dynamicEventsAndEnvelopes = new List <dynamic>(); var json = System.Text.Encoding.UTF8.GetString(message.Body); _serializer.FromJson(dynamicEventsAndEnvelopes, json); var eventsAndEnvelopes = new List <EventAndEnvelope>(); foreach (var dynamicEventAndEnvelope in dynamicEventsAndEnvelopes) { var env = dynamicEventAndEnvelope.Envelope; var correlationId = (TransactionCorrelationId)Guid.Parse(env.CorrelationId.ToString()); var eventId = (EventId)Guid.Parse(env.EventId.ToString()); var sequenceNumber = (EventSequenceNumber)long.Parse(env.SequenceNumber.ToString()); var sequenceNumberForEventType = (EventSequenceNumber)long.Parse(env.SequenceNumberForEventType.ToString()); var generation = (EventGeneration)long.Parse(env.Generation.ToString()); var @event = _applicationResourceIdentifierConverter.FromString(env.Event.ToString()); var eventSourceId = (EventSourceId)Guid.Parse(env.EventSourceId.ToString()); var eventSource = _applicationResourceIdentifierConverter.FromString(env.EventSource.ToString()); var version = (EventSourceVersion)EventSourceVersion.FromCombined(double.Parse(env.Version.ToString())); var causedBy = (CausedBy)env.CausedBy.ToString(); var occurred = DateTimeOffset.Parse(env.Occurred.ToString()); var envelope = new EventEnvelope( correlationId, eventId, sequenceNumber, sequenceNumberForEventType, generation, @event, eventSourceId, eventSource, version, causedBy, occurred ); var eventType = _applicationResourceResolver.Resolve(@event); var eventInstance = Activator.CreateInstance(eventType, new object[] { eventSourceId }) as IEvent; var e = dynamicEventAndEnvelope.Event.ToString(); _serializer.FromJson(eventInstance, e); eventsAndEnvelopes.Add(new EventAndEnvelope(envelope, eventInstance)); } var stream = new CommittedEventStream(eventsAndEnvelopes.First().Envelope.EventSourceId, eventsAndEnvelopes); Received(stream); _queueClient.CompleteAsync(message.SystemProperties.LockToken); return(Task.CompletedTask); }
public void CanSerializeToBson() { var version = new EventVersion(3, 2, 1); var aggregateId = Guid.Parse("512fe943-c9bd-49c3-8116-20c186c755af"); var correlationId = Guid.Parse("4fabd791-ef41-4d6b-9579-fcd9189d492b"); var envelope = new EventEnvelope(correlationId, aggregateId, version, new FakeEvent("My Event")); var bson = WriteBson(envelope); Validate(bson, "7AAAAAVhABAAAAAEQ+kvUb3Jw0mBFiDBhsdVrwN2ABoAAAAQdgADAAAAEGMAAgAAABBpAAEAAAAAA2UAlwAAAAIkdHlwZQBwAAAAVGVzdC5TcGFyay5TZXJpYWxpemF0aW9uLkNvbnZlcnRlcnMuVXNpbmdFdmVudEVudmVsb3BlQ29udmVydGVyLkZha2VFdmVudCwgU3BhcmsuU2VyaWFsaXphdGlvbi5OZXd0b25zb2Z0LlRlc3RzAAJQcm9wZXJ0eQAJAAAATXkgRXZlbnQAAAVjABAAAAAEkderT0Hva02VefzZGJ1JKwA="); }
public void GetStronglyTypedContentTest() { TestEvent testEvent = new TestEvent("some event"); EventEnvelope envelope = new EventEnvelope("Test", type => testEvent); TestEvent content = envelope.GetContent <TestEvent>(); content.Should().NotBeNull(); content.ShouldBeEquivalentTo(testEvent); }
private void AddItem <T>(EventEnvelope <T> evnt, string message, HistoryItemType type = HistoryItemType.Success) where T : class { Items.Add(new HistoryItem() { Date = FormatDate(evnt.OccurenceDateUtc), Message = message, Type = type }); }
private void WhenAnEventIsAddedToTheEventStream() { var @event = new EventEnvelope( _dataFixture.Create <long>(), new SomeEvent()); _eventStream.Enqueue(@event); _eventsAddedToStream.Add(@event); }
private Task OnEventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent @event) { _logger.LogInformation("Received event on subscription {@subscriptionName}: {@event}", subscription.SubscriptionName, @event); // TODO: what should we do if this fails? var evelynEvent = _eventMapper.MapEvent(@event); var eventEnvelope = new EventEnvelope(@event.OriginalEventNumber, evelynEvent); _eventStream.Enqueue(eventEnvelope); return(Task.CompletedTask); }
public Task AppendPartition(Guid key, EventMetadata m, IEvent e) { var queue = _partitionStreams.GetOrAdd(key, (x) => new ConcurrentQueue <EventEnvelope>()); var eventEnvelope = new EventEnvelope(e, m); queue.Enqueue(eventEnvelope); _publisher.Publish(eventEnvelope, key); return(Task.CompletedTask); }
public void On(EventEnvelope <StageFailedEvent> evnt) { var candidate = evnt.Session.QueryOver <ReleaseCandidate>() .Where(x => x.PipelineId == evnt.Payload.StageId.PipelineId) .List() .Single(); var project = GetLatestProjectVersion(evnt.Session, candidate.ProjectName); project.StageFailed(evnt.Payload.StageId.StageId, candidate, evnt.OccurenceDateUtc); }
async private Task<ICommandHandler> Handle(OrderCreated e) { var envelope = new EventEnvelope<OrderCreated> { Timestamp = DateTime.UtcNow , Event = e , Username = "******" }; return await ((ICommandHandler)this).Handle(envelope); }
public void CanTolerateTransientExceptions() { var execution = 0; var e = new FakeEvent(); var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { if (++execution == 1) { throw new ConcurrencyException(); } }, () => new Object()); var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e); var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope); HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler }); Processor.Process(message); }
public static EventEnvelope FromEnvelope(EventEnvelope eventEnvelope) { var domainEvent = FromCommittedEvent(eventEnvelope.Event); var newEventEnvelope = new EventEnvelope( eventEnvelope.Offset, eventEnvelope.PersistenceId, eventEnvelope.SequenceNr, domainEvent); return(newEventEnvelope); }
private static EventEnvelope Map(ResolvedEvent resolvedEvent) { var bytesAsString = Encoding.UTF8.GetString(resolvedEvent.Event.Data); var a = JsonConvert.DeserializeObject(bytesAsString) as IEvent; var jsonMetadata = Encoding.UTF8.GetString(resolvedEvent.Event.Metadata); var metadata = JsonConvert.DeserializeObject <EventMetadata>(jsonMetadata); var typeName = Type.GetType(metadata.Type); var @event = (IEvent)JsonConvert.DeserializeObject(bytesAsString, typeName); var envelope = new EventEnvelope(@event, metadata); return(envelope); }
public async Task HandleEvent(EventEnvelope eventEnvelope, CancellationToken stoppingToken) { try { bool initialEvent = false; var storeKey = Projections.EventHandlerState.Projection.StoreKey(typeof(TEventStream)); Projections.EventHandlerState.Projection state; try { state = await _eventHandlerStateStore.Get(storeKey).ConfigureAwait(false); if (eventEnvelope.StreamPosition <= state.Audit.StreamPosition) { _logger.LogInformation("Ignoring event with stream position {@eventStreamPosition} because we have already processed to {@currentStreamPosition}", eventEnvelope.StreamPosition, state.Audit.StreamPosition); return; } } catch (ProjectionNotFoundException) { _logger.LogInformation("No state found"); initialEvent = true; } if (_projectionBuildersByEventType.TryGetValue(eventEnvelope.Event.GetType(), out var projectionBuilders)) { var tasks = new Task[projectionBuilders.Count]; for (var index = 0; index < projectionBuilders.Count; index++) { tasks[index] = projectionBuilders[index](eventEnvelope.StreamPosition, eventEnvelope.Event, stoppingToken); } await Task.WhenAll(tasks); } var eventAudit = EventAudit.Create(DateTime.UtcNow, Constants.SystemUser, eventEnvelope.Event.Version, eventEnvelope.StreamPosition); state = Projections.EventHandlerState.Projection.Create(eventAudit); if (initialEvent) { await _eventHandlerStateStore.Create(storeKey, state).ConfigureAwait(false); } else { await _eventHandlerStateStore.Update(storeKey, state).ConfigureAwait(false); } } catch (Exception ex) { _logger.LogWarning("Failed to build projection for {@event}. Exception: {@exception}", eventEnvelope.Event, ex); throw; } }
public void On(EventEnvelope <ReleaseCandidateDeploymentFailedEvent> evnt) { var rc = evnt.Session.Load <ReleaseCandidate>(evnt.Payload.BuildId); rc.Deployments.Add(new Deployment() { Date = evnt.OccurenceDateUtc, UniqueId = evnt.Payload.UniqueDeploymentId, Environment = evnt.Payload.Environment, Success = false }); }
public IActionResult PostAsync(EventEnvelope envelope) { if (config.EventSink) { // Authorization in this controller is entirely static, as this is the only mode Docker Registry supports if (!string.IsNullOrEmpty(config.EventAuthorization)) { if (!Request.Headers.ContainsKey("Authorization") || Request.Headers["Authorization"] != config.EventAuthorization) { return(Unauthorized()); } } if (envelope != null) { foreach (var e in envelope.Events) { switch (e.Action.ToLowerInvariant()) { case "push": if (LocalDockerClient.SupportedManifestTypes.Contains(e.Target.MediaType)) { if (config.Documents?.Count > 0) { RequestIndex(e); } if (config.Vulnerabilities) { RequestScan(e); } } break; default: logger.LogInformation($"Ignoring event {e.Id} - {e.Action} {e.Target?.MediaType} {e.Target?.Digest}"); break; } } return(Ok()); } else { return(BadRequest()); } } else { return(StatusCode(503, "Event sink service is not enabled")); } }
public void GetDynamicContentFromJsonTest() { TestEvent testEvent = new TestEvent("some event"); string json = JsonConvert.SerializeObject(testEvent); EventEnvelope envelope = new EventEnvelope("Test", type => this.FromJson(type, json)); dynamic content = envelope.GetContent(); ((DateTime)content.EventDate).ShouldBeEquivalentTo(testEvent.EventDate); Assert.AreEqual(testEvent.EventId, Guid.Parse(content.EventId)); ((string)content.Name).ShouldBeEquivalentTo(testEvent.Name); ((string)content.Value).ShouldBeEquivalentTo(testEvent.Value); }
async private Task <ICommandHandler> Handle(OrderCreated e) { var envelope = new EventEnvelope <OrderCreated> { Timestamp = DateTime.UtcNow , Event = e , Username = "******" }; return(await((ICommandHandler)this).Handle(envelope)); }
public void WillTimeoutEventuallyIfCannotExecuteHandler() { var e = new FakeEvent(); var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { throw new ConcurrencyException(); }, () => new Object()); var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e); var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope); SystemTime.ClearOverride(); HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler }); Assert.Throws <TimeoutException>(() => Processor.Process(message)); }
public void Handle( IUntypedActorContext actorContext, IActorRef repository, TProjectionContext projectionContext, IActorRef manager, EventEnvelope eventEnvelope) { var projector = FindOrCreate(eventEnvelope.PersistenceId, actorContext); projector.Tell(new ProjectEvent <TProjectionContext> { Context = projectionContext, Event = eventEnvelope }); actorContext.GetLogger().Info("{0} - {1} - {2}", eventEnvelope.Event.GetType(), eventEnvelope.PersistenceId, eventEnvelope.SequenceNr); }
public void RetrieveEventHandlersBasedOnEventType() { var e = new FakeEvent(); var eventHandler1 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object()); var eventHandler2 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object()); var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e); var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope); HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler1, eventHandler2 }); Processor.Process(message); Assert.True(eventHandler1.Handled); Assert.True(eventHandler2.Handled); }
private async Task<ICommandHandler> Handle(EventEnvelope<OrderCreated> e) { // Create the queue if it does not exist already string connectionString = CloudConfigurationManager.GetSetting("EventsServiceBus"); try { var client = TopicClient.CreateFromConnectionString(connectionString, "Events"); await client.SendAsync(new BrokeredMessage(e)); } catch (Exception ex) { throw ex; } return this; }
public void CanSerializeToJson() { var version = new EventVersion(3, 2, 1); var aggregateId = Guid.Parse("512fe943-c9bd-49c3-8116-20c186c755af"); var correlationId = Guid.Parse("4fabd791-ef41-4d6b-9579-fcd9189d492b"); var envelope = new EventEnvelope(correlationId, aggregateId, version, new FakeEvent("My Event")); var json = WriteJson(envelope); Validate(json, @" { ""a"": ""512fe943-c9bd-49c3-8116-20c186c755af"", ""v"": { ""v"": 3, ""c"": 2, ""i"": 1 }, ""e"": { ""$type"": ""Test.Spark.Serialization.Converters.UsingEventEnvelopeConverter.FakeEvent, Spark.Serialization.Newtonsoft.Tests"", ""Property"": ""My Event"" }, ""c"": ""4fabd791-ef41-4d6b-9579-fcd9189d492b"" }"); }
public void CanSerializeToBson() { var version = new EventVersion(3, 2, 1); var aggregateId = Guid.Parse("512fe943-c9bd-49c3-8116-20c186c755af"); var correlationId = Guid.Parse("4fabd791-ef41-4d6b-9579-fcd9189d492b"); var envelope = new EventEnvelope(correlationId, aggregateId, version, new FakeEvent("My Event")); var bson = WriteBson(envelope); Validate(bson, "7AAAAAVhABAAAAAEQ+kvUb3Jw0mBFiDBhsdVrwN2ABoAAAAQdgADAAAAEGMAAgAAABBpAAEAAAAAA2UAlwAAAAIkdHlwZQBwAAAAVGVzdC5TcGFyay5TZXJpYWxpemF0aW9uLkNvbnZlcnRlcnMuVXNpbmdFdmVudEVudmVsb3BlQ29udmVydGVyLkZha2VFdmVudCwgU3BhcmsuU2VyaWFsaXphdGlvbi5OZXd0b25zb2Z0LlRlc3RzAAJQcm9wZXJ0eQAJAAAATXkgRXZlbnQAAAVjABAAAAAEkderT0Hva02VefzZGJ1JKwA="); }
public void WillTimeoutEventuallyIfCannotExecuteHandler() { var e = new FakeEvent(); var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { throw new ConcurrencyException(); }, () => new Object()); var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e); var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope); SystemTime.ClearOverride(); HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler }); Assert.Throws<TimeoutException>(() => Processor.Process(message)); }
void On(EventEnvelope<InventoryItemRenamed> e) => items[e.Stream].Name = e.Event.NewName;
void On(EventEnvelope<InventoryItemDeactivated> e) => items[e.Stream].Active = false;
void On(EventEnvelope<InventoryItemCheckedOut> e) => items[e.Stream].Total -= e.Event.Quantity;
void On(EventEnvelope<InventoryItemCreated> e) => items[e.Stream] = new InventoryItemDetails(e.Event.Name, 0, true);