event_sourcery 0.14.0 → 0.15.0

data/lib/event_sourcery/event_processing/event_stream_processor_registry.rb

@@ -5,22 +5,38 @@ module EventSourcery
         @processors = []
       end
 
+      # Register the class of the Event Stream Processor.
+      #
+      # @param klass [Class] the class to register
       def register(klass)
         @processors << klass
       end
 
+      # Find a registered processor by its name.
+      #
+      # @param processor_name [String] name of the processor you're looking for
+      #
+      # @return [ESProcess, nil] the found processor object or nil
       def find(processor_name)
         @processors.find do |processor|
           processor.processor_name == processor_name
         end
       end
 
+      # Find a registered processor by its type.
+      #
+      # @param constant [String] name of the constant the processor has included
+      #
+      # @return [ESProcess, nil] the found processor object or nil
       def by_type(constant)
         @processors.select do |processor|
           processor.included_modules.include?(constant)
         end
       end
 
+      # Returns an array of all the registered processors.
+      #
+      # @return [Array] of all the processors that are registered
       def all
         @processors
       end

data/lib/event_sourcery/event_store/poll_waiter.rb

@@ -1,10 +1,20 @@
 module EventSourcery
   module EventStore
+
+    # This class provides a basic poll waiter implementation that calls the provided block and sleeps for the specified interval, to be used by a {Subscription}.
     class PollWaiter
+      #
+      # @param interval [Float] Optional. Will default to `0.5`
       def initialize(interval: 0.5)
         @interval = interval
       end
 
+      # Start polling. Call the provided block and sleep. Repeat until `:stop` is thrown (usually via a subscription master).
+      #
+      # @param block [Proc] code block to be called when polling
+      #
+      # @see SignalHandlingSubscriptionMaster
+      # @see Subscription
       def poll(&block)
         catch(:stop) do
           loop do

data/lib/event_sourcery/event_store/signal_handling_subscription_master.rb

@@ -1,11 +1,18 @@
 module EventSourcery
   module EventStore
+    # Manages shutdown signals and facilitate graceful shutdowns of subscriptions.
+    #
+    # @see Subscription
     class SignalHandlingSubscriptionMaster
       def initialize
         @shutdown_requested = false
         setup_graceful_shutdown
       end
 
+      # If a shutdown has been requested through a `TERM` or `INT` signal, this will throw a `:stop`
+      # (generally) causing a Subscription to stop listening for events.
+      #
+      # @see Subscription#start
       def shutdown_if_requested
         throw :stop if @shutdown_requested
       end

data/lib/event_sourcery/event_store/subscription.rb

@@ -1,6 +1,17 @@
 module EventSourcery
   module EventStore
+
+    # This allows Event Stream Processors (ESPs) to subscribe to an event store, and be notified when new events are
+    # added.
     class Subscription
+      #
+      # @param event_store Event store to source events from
+      # @param poll_waiter Poll waiter instance used (such as {EventStore::PollWaiter}) for polling the event store
+      # @param from_event_id [Integer] Start reading events from this event ID
+      # @param event_types [Array] Optional. If specified, only subscribe to given event types.
+      # @param on_new_events [Proc] Code block to be executed when new events are received
+      # @param subscription_master A subscription master instance (such as {EventStore::SignalHandlingSubscriptionMaster}) which orchestrates a graceful shutdown of the subscription, if one is requested.
+      # @param events_table_name [Symbol] Optional. Defaults to `:events`
       def initialize(event_store:,
                      poll_waiter:,
                      from_event_id:,
@@ -17,6 +28,10 @@ module EventSourcery
         @current_event_id = from_event_id - 1
       end
 
+      # Start listening for new events. This method will continue to listen for new events until a shutdown is requested
+      # through the subscription_master provided.
+      #
+      # @see EventStore::SignalHandlingSubscriptionMaster
       def start
         catch(:stop) do
           @poll_waiter.poll do

data/lib/event_sourcery/memory/config.rb

@@ -0,0 +1,36 @@
+module EventSourcery
+  module Memory
+    class Config
+      attr_accessor :event_tracker,
+                    :event_store,
+                    :event_source,
+                    :event_sink
+
+      def initialize
+        @event_tracker = Memory::Tracker.new
+      end
+
+      def event_store
+        @event_store ||= EventStore.new
+      end
+
+      def event_source
+        @event_source ||= ::EventSourcery::EventStore::EventSource.new(event_store)
+      end
+
+      def event_sink
+        @event_sink ||= ::EventSourcery::EventStore::EventSink.new(event_store)
+      end
+
+    end
+
+    def self.configure
+      yield config
+    end
+
+    def self.config
+      @config ||= Config.new
+    end
+
+  end
+end

data/lib/event_sourcery/memory/event_store.rb

@@ -1,13 +1,26 @@
 module EventSourcery
   module Memory
+    # In-memory event store.
+    #
+    # Note: This is not persisted and is generally used for testing.
     class EventStore
       include EventSourcery::EventStore::EachByRange
 
+      #
+      # @param events [Array] Optional. Collection of events
+      # @param event_builder Optional. Event builder instance. Will default to {Config#event_builder}
       def initialize(events = [], event_builder: EventSourcery.config.event_builder)
         @events = events
         @event_builder = event_builder
+        @listeners = []
       end
 
+      # Store given events to the in-memory store
+      #
+      # @param event_or_events Event(s) to be stored
+      # @param expected_version [Optional] Expected version for the aggregate. This is the version the caller of this method expect the aggregate to be in. If it's different from the expected version a {EventSourcery::ConcurrencyError} will be raised. Defaults to nil.
+      # @raise EventSourcery::ConcurrencyError
+      # @return Boolean
       def sink(event_or_events, expected_version: nil)
         events = Array(event_or_events)
         ensure_one_aggregate(events)
@@ -30,9 +43,17 @@ module EventSourcery
           )
         end
 
+        project_events(events)
+
         true
       end
 
+      # Retrieve a subset of events
+      #
+      # @param id Starting from event ID
+      # @param event_types [Array] Optional. If supplied, only retrieve events of given type(s).
+      # @param limit [Integer] Optional. Number of events to retrieve (starting from the given event ID).
+      # @return Array
       def get_next_from(id, event_types: nil, limit: 1000)
         events = if event_types.nil?
           @events
@@ -43,6 +64,10 @@ module EventSourcery
         events.select { |event| event.id >= id }.first(limit)
       end
 
+      # Retrieve the latest event ID
+      #
+      # @param event_types [Array] Optional. If supplied, only retrieve events of given type(s).
+      # @return Integer
       def latest_event_id(event_types: nil)
         events = if event_types.nil?
           @events
@@ -53,24 +78,58 @@ module EventSourcery
         events.empty? ? 0 : events.last.id
       end
 
+      # Get all events for the given aggregate
+      #
+      # @param id [String] Aggregate ID (UUID as String)
+      # @return Array
       def get_events_for_aggregate_id(id)
         stringified_id = id.to_str
         @events.select { |event| event.aggregate_id == stringified_id }
       end
 
+      # Next version for the aggregate
+      #
+      # @param aggregate_id [String] Aggregate ID (UUID as String)
+      # @return Integer
       def next_version(aggregate_id)
         version_for(aggregate_id) + 1
       end
 
+      # Current version for the aggregate
+      #
+      # @param aggregate_id [String] Aggregate ID (UUID as String)
+      # @return Integer
       def version_for(aggregate_id)
         get_events_for_aggregate_id(aggregate_id).count
       end
 
+      # Ensure all events have the same aggregate
+      #
+      # @param events [Array] Collection of events
+      # @raise AtomicWriteToMultipleAggregatesNotSupported
       def ensure_one_aggregate(events)
         unless events.map(&:aggregate_id).uniq.one?
           raise AtomicWriteToMultipleAggregatesNotSupported
         end
       end
+
+      # Adds a listener or listeners to the memory store.
+      # the #process(event) method will execute whenever an event is emitted
+      #
+      # @param listener A single listener or an array of listeners
+      def add_listeners(listeners)
+        @listeners.concat(Array(listeners))
+      end
+
+      private
+
+      def project_events(events)
+        events.each do |event|
+          @listeners.each do |listener|
+            listener.process(event)
+          end
+        end
+      end
     end
   end
 end

data/lib/event_sourcery/memory/projector.rb

@@ -0,0 +1,25 @@
+module EventSourcery
+  module Memory
+    module Projector
+
+      def self.included(base)
+        base.include(EventSourcery::EventProcessing::EventStreamProcessor)
+        base.include(InstanceMethods)
+        base.class_eval do
+          alias_method :project, :process
+          class << self
+            alias_method :project, :process
+            alias_method :projects_events, :processes_events
+            alias_method :projector_name, :processor_name
+          end
+        end
+      end
+
+      module InstanceMethods
+        def initialize(tracker: EventSourcery::Memory.config.event_tracker)
+          @tracker = tracker
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/memory/tracker.rb

@@ -1,24 +1,43 @@
 module EventSourcery
   module Memory
+    # Being able to know where you're at when reading an event stream
+    # is important. In here are mechanisms to do so.
     class Tracker
+      # Tracking where you're in an event stream at via an in memory hash.
+      # Note: This is not persisted and is generally used for testing.
       def initialize
         @state = Hash.new(0)
       end
 
+      # Register a new processor to track or
+      # reset an existing tracker's last processed event id.
+      # Will start from 0.
+      #
+      # @param processor_name [String] the name of the processor to track
       def setup(processor_name)
         @state[processor_name.to_s] = 0
       end
 
+      # Update the given processor name to the given event id number.
+      #
+      # @param processor_name [String] the name of the processor to update
+      # @param event_id [Int] the number of the event to update
       def processed_event(processor_name, event_id)
         @state[processor_name.to_s] = event_id
       end
 
       alias :reset_last_processed_event_id :setup
 
+      # Find the last processed event id for a given processor name.
+      #
+      # @return [Int] the last event id that the given processor has processed
       def last_processed_event_id(processor_name)
         @state[processor_name.to_s]
       end
 
+      # Returns an array of all the processors that are being tracked.
+      #
+      # @return [Array] an array of names of the tracked processors
       def tracked_processors
         @state.keys
       end

data/lib/event_sourcery/repository.rb

@@ -1,20 +1,48 @@
 module EventSourcery
+  # This class provides a set of methods to help load and save aggregate instances.
+  #
+  # Refer to {https://github.com/envato/event_sourcery_todo_app/blob/31e200f4a2a65be5d847a66a20e23a334d43086b/app/commands/todo/amend.rb#L26 EventSourceryTodoApp}
+  # for a more complete example.
+  # @example
+  #  repository = EventSourcery::Repository.new(
+  #    event_source: EventSourceryTodoApp.event_source,
+  #    event_sink: EventSourceryTodoApp.event_sink,
+  #  )
+  #
+  #  aggregate = repository.load(Aggregates::Todo, command.aggregate_id)
+  #  aggregate.amend(command.payload)
+  #  repository.save(aggregate)
   class Repository
+    # Create a new instance of the repository and load an aggregate instance
+    #
+    # @param aggregate_class Aggregate type
+    # @param aggregate_id [Integer] ID of the aggregate instance to be loaded
+    # @param event_source event source to be used for loading the events for the aggregate
+    # @param event_sink event sink to be used for saving any new events for the aggregate
     def self.load(aggregate_class, aggregate_id, event_source:, event_sink:)
       new(event_source: event_source, event_sink: event_sink)
         .load(aggregate_class, aggregate_id)
     end
 
+    # @param event_source event source to be used for loading the events for the aggregate
+    # @param event_sink event sink to be used for saving any new events for the aggregate
     def initialize(event_source:, event_sink:)
       @event_source = event_source
       @event_sink = event_sink
     end
 
+    # Load an aggregate instance
+    #
+    # @param aggregate_class Aggregate type
+    # @param aggregate_id [Integer] ID of the aggregate instance to be loaded
     def load(aggregate_class, aggregate_id)
       events = event_source.get_events_for_aggregate_id(aggregate_id)
       aggregate_class.new(aggregate_id, events)
     end
 
+    # Save any new events/changes in the provided aggregate to the event sink
+    #
+    # @param aggregate An aggregate instance to be saved
     def save(aggregate)
       new_events = aggregate.changes
       if new_events.any?

data/lib/event_sourcery/rspec/event_store_shared_examples.rb

@@ -1,25 +1,18 @@
 RSpec.shared_examples 'an event store' do
-  let(:aggregate_id) { SecureRandom.uuid }
+  TestEvent2 = Class.new(EventSourcery::Event)
+  UserSignedUp = Class.new(EventSourcery::Event)
+  ItemRejected = Class.new(EventSourcery::Event)
+  Type1 = Class.new(EventSourcery::Event)
+  Type2 = Class.new(EventSourcery::Event)
+  BillingDetailsProvided = Class.new(EventSourcery::Event)
 
-  def new_event(aggregate_id: SecureRandom.uuid, type: 'test_event', body: {},
-                id: nil, version: 1, created_at: nil, uuid: SecureRandom.uuid,
-                correlation_id: SecureRandom.uuid, causation_id: SecureRandom.uuid)
-    EventSourcery::Event.new(id: id,
-                             aggregate_id: aggregate_id,
-                             type: type,
-                             body: body,
-                             version: version,
-                             created_at: created_at,
-                             uuid: uuid,
-                             correlation_id: correlation_id,
-                             causation_id: causation_id)
-  end
+  let(:aggregate_id) { SecureRandom.uuid }
 
   describe '#sink' do
     it 'assigns auto incrementing event IDs' do
-      event_store.sink(new_event)
-      event_store.sink(new_event)
-      event_store.sink(new_event)
+      event_store.sink(ItemAdded.new(aggregate_id: SecureRandom.uuid))
+      event_store.sink(ItemAdded.new(aggregate_id: SecureRandom.uuid))
+      event_store.sink(ItemAdded.new(aggregate_id: SecureRandom.uuid))
       events = event_store.get_next_from(1)
       expect(events.count).to eq 3
       expect(events.map(&:id)).to eq [1, 2, 3]
@@ -27,40 +20,40 @@ RSpec.shared_examples 'an event store' do
 
     it 'assigns UUIDs' do
       uuid = SecureRandom.uuid
-      event_store.sink(new_event(uuid: uuid))
+      event_store.sink(ItemAdded.new(aggregate_id: SecureRandom.uuid, uuid: uuid))
       event = event_store.get_next_from(1).first
       expect(event.uuid).to eq uuid
     end
 
     it 'returns true' do
-      expect(event_store.sink(new_event)).to eq true
+      expect(event_store.sink(ItemAdded.new(aggregate_id: SecureRandom.uuid))).to eq true
     end
 
     it 'serializes the event body' do
       time = Time.now
-      event = new_event(body: { 'time' => time })
+      event = ItemAdded.new(aggregate_id: SecureRandom.uuid, body: { 'time' => time })
       expect(event_store.sink(event)).to eq true
       expect(event_store.get_next_from(1, limit: 1).first.body).to eq('time' => time.iso8601)
     end
 
     it 'saves the causation_id' do
       causation_id = SecureRandom.uuid
-      event = new_event(causation_id: causation_id)
+      event = ItemAdded.new(aggregate_id: SecureRandom.uuid, causation_id: causation_id)
       event_store.sink(event)
       expect(event_store.get_next_from(1, limit: 1).first.causation_id).to eq(causation_id)
     end
 
     it 'saves the correlation_id' do
       correlation_id = SecureRandom.uuid
-      event = new_event(correlation_id: correlation_id)
+      event = ItemAdded.new(aggregate_id: SecureRandom.uuid, correlation_id: correlation_id)
       event_store.sink(event)
       expect(event_store.get_next_from(1, limit: 1).first.correlation_id).to eq(correlation_id)
     end
 
     it 'writes multiple events' do
-      event_store.sink([new_event(aggregate_id: aggregate_id, body: {e: 1}),
-                        new_event(aggregate_id: aggregate_id, body: {e: 2}),
-                        new_event(aggregate_id: aggregate_id, body: {e: 3})])
+      event_store.sink([ItemAdded.new(aggregate_id: aggregate_id, body: {e: 1}),
+                        ItemAdded.new(aggregate_id: aggregate_id, body: {e: 2}),
+                        ItemAdded.new(aggregate_id: aggregate_id, body: {e: 3})])
       events = event_store.get_next_from(1)
       expect(events.count).to eq 3
       expect(events.map(&:id)).to eq [1, 2, 3]
@@ -69,11 +62,11 @@ RSpec.shared_examples 'an event store' do
     end
 
     it 'sets the correct aggregates version' do
-      event_store.sink([new_event(aggregate_id: aggregate_id, body: {e: 1}),
-                        new_event(aggregate_id: aggregate_id, body: {e: 2})])
+      event_store.sink([ItemAdded.new(aggregate_id: aggregate_id, body: {e: 1}),
+                        ItemAdded.new(aggregate_id: aggregate_id, body: {e: 2})])
       # this will throw a unique constrain error if the aggregate version was not set correctly ^
-      event_store.sink([new_event(aggregate_id: aggregate_id, body: {e: 1}),
-                        new_event(aggregate_id: aggregate_id, body: {e: 2})])
+      event_store.sink([ItemAdded.new(aggregate_id: aggregate_id, body: {e: 1}),
+                        ItemAdded.new(aggregate_id: aggregate_id, body: {e: 2})])
       events = event_store.get_next_from(1)
       expect(events.count).to eq 4
       expect(events.map(&:id)).to eq [1, 2, 3, 4]
@@ -81,41 +74,37 @@ RSpec.shared_examples 'an event store' do
 
     context 'with no existing aggregate stream' do
       it 'saves an event' do
-        event = new_event(aggregate_id: aggregate_id,
-                          type: :test_event_2,
-                          body: { 'my' => 'data' })
+        event = TestEvent2.new(aggregate_id: aggregate_id, body: { 'my' => 'data' })
         event_store.sink(event)
         events = event_store.get_next_from(1)
         expect(events.count).to eq 1
         expect(events.first.id).to eq 1
         expect(events.first.aggregate_id).to eq aggregate_id
-        expect(events.first.type).to eq 'test_event_2'
+        expect(events.first.type).to eq 'test_event2'
         expect(events.first.body).to eq({ 'my' => 'data' }) # should we symbolize keys when hydrating events?
       end
     end
 
     context 'with an existing aggregate stream' do
       before do
-        event_store.sink(new_event(aggregate_id: aggregate_id))
+        event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
       end
 
       it 'saves an event' do
-        event = new_event(aggregate_id: aggregate_id,
-                         type: :test_event_2,
-                         body: { 'my' => 'data' })
+        event = TestEvent2.new(aggregate_id: aggregate_id, body: { 'my' => 'data' })
         event_store.sink(event)
         events = event_store.get_next_from(1)
         expect(events.count).to eq 2
         expect(events.last.id).to eq 2
         expect(events.last.aggregate_id).to eq aggregate_id
-        expect(events.last.type).to eq :test_event_2.to_s # shouldn't you get back what you put in, a symbol?
+        expect(events.last.type).to eq :test_event2.to_s # shouldn't you get back what you put in, a symbol?
         expect(events.last.body).to eq({ 'my' => 'data' }) # should we symbolize keys when hydrating events?
       end
     end
 
     it 'correctly inserts created at times when inserting multiple events atomically' do
       time = Time.parse('2016-10-14T00:00:00.646191Z')
-      event_store.sink([new_event(aggregate_id: aggregate_id, created_at: nil), new_event(aggregate_id: aggregate_id, created_at: time)])
+      event_store.sink([ItemAdded.new(aggregate_id: aggregate_id, created_at: nil), ItemAdded.new(aggregate_id: aggregate_id, created_at: time)])
       created_ats = event_store.get_next_from(0).map(&:created_at)
       expect(created_ats.map(&:class)).to eq [Time, Time]
       expect(created_ats.last).to eq time
@@ -123,22 +112,22 @@ RSpec.shared_examples 'an event store' do
 
     it 'raises an error if the events given are for more than one aggregate' do
       expect {
-        event_store.sink([new_event(aggregate_id: aggregate_id), new_event(aggregate_id: SecureRandom.uuid)])
+        event_store.sink([ItemAdded.new(aggregate_id: aggregate_id), ItemAdded.new(aggregate_id: SecureRandom.uuid)])
       }.to raise_error(EventSourcery::AtomicWriteToMultipleAggregatesNotSupported)
     end
   end
 
   describe '#get_next_from' do
     it 'gets a subset of events' do
-      event_store.sink(new_event(aggregate_id: aggregate_id))
-      event_store.sink(new_event(aggregate_id: aggregate_id))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
       expect(event_store.get_next_from(1, limit: 1).map(&:id)).to eq [1]
       expect(event_store.get_next_from(2, limit: 1).map(&:id)).to eq [2]
       expect(event_store.get_next_from(1, limit: 2).map(&:id)).to eq [1, 2]
     end
 
     it 'returns the event as expected' do
-      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added', body: { 'my' => 'data' }))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id, body: { 'my' => 'data' }))
       event = event_store.get_next_from(1, limit: 1).first
       expect(event.aggregate_id).to eq aggregate_id
       expect(event.type).to eq 'item_added'
@@ -147,11 +136,11 @@ RSpec.shared_examples 'an event store' do
     end
 
     it 'filters by event type' do
-      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'user_signed_up'))
-      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added'))
-      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added'))
-      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_rejected'))
-      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'user_signed_up'))
+      event_store.sink(UserSignedUp.new(aggregate_id: aggregate_id))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
+      event_store.sink(ItemRejected.new(aggregate_id: aggregate_id))
+      event_store.sink(UserSignedUp.new(aggregate_id: aggregate_id))
       events = event_store.get_next_from(1, event_types: ['user_signed_up'])
       expect(events.count).to eq 2
       expect(events.map(&:id)).to eq [1, 5]
@@ -160,8 +149,8 @@ RSpec.shared_examples 'an event store' do
 
   describe '#latest_event_id' do
     it 'returns the latest event id' do
-      event_store.sink(new_event(aggregate_id: aggregate_id))
-      event_store.sink(new_event(aggregate_id: aggregate_id))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
+      event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
       expect(event_store.latest_event_id).to eq 2
     end
 
@@ -173,13 +162,13 @@ RSpec.shared_examples 'an event store' do
 
     context 'with event type filtering' do
       it 'gets the latest event ID for a set of event types' do
-        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'type_1'))
-        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'type_1'))
-        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'type_2'))
+        event_store.sink(Type1.new(aggregate_id: aggregate_id))
+        event_store.sink(Type1.new(aggregate_id: aggregate_id))
+        event_store.sink(Type2.new(aggregate_id: aggregate_id))
 
-        expect(event_store.latest_event_id(event_types: ['type_1'])).to eq 2
-        expect(event_store.latest_event_id(event_types: ['type_2'])).to eq 3
-        expect(event_store.latest_event_id(event_types: ['type_1', 'type_2'])).to eq 3
+        expect(event_store.latest_event_id(event_types: ['type1'])).to eq 2
+        expect(event_store.latest_event_id(event_types: ['type2'])).to eq 3
+        expect(event_store.latest_event_id(event_types: ['type1', 'type2'])).to eq 3
       end
     end
   end
@@ -187,9 +176,9 @@ RSpec.shared_examples 'an event store' do
   describe '#get_events_for_aggregate_id' do
     RSpec.shared_examples 'gets events for a specific aggregate id' do
       before do
-        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added', body: { 'my' => 'body' }))
-        event_store.sink(new_event(aggregate_id: double(to_str: aggregate_id)))
-        event_store.sink(new_event(aggregate_id: SecureRandom.uuid))
+        event_store.sink(ItemAdded.new(aggregate_id: aggregate_id, body: { 'my' => 'body' }))
+        event_store.sink(ItemAdded.new(aggregate_id: double(to_str: aggregate_id)))
+        event_store.sink(ItemAdded.new(aggregate_id: SecureRandom.uuid))
       end
 
       subject(:events) { event_store.get_events_for_aggregate_id(uuid) }
@@ -219,9 +208,7 @@ RSpec.shared_examples 'an event store' do
   describe '#each_by_range' do
     before do
       (1..21).each do |i|
-        event_store.sink(new_event(aggregate_id: aggregate_id,
-                                   type: 'item_added',
-                                   body: {}))
+        event_store.sink(ItemAdded.new(aggregate_id: aggregate_id, body: {}))
       end
     end
 
@@ -266,14 +253,14 @@ RSpec.shared_examples 'an event store' do
   end
 
   def save_event(expected_version: nil)
-    event_store.sink(new_event(aggregate_id: aggregate_id,
-                     type: :billing_details_provided,
-                     body: { my_event: 'data' }),
-                     expected_version: expected_version)
+    event_store.sink(
+      BillingDetailsProvided.new(aggregate_id: aggregate_id, body: { my_event: 'data' }),
+      expected_version: expected_version,
+    )
   end
 
   def add_event
-    event_store.sink(new_event(aggregate_id: aggregate_id))
+    event_store.sink(ItemAdded.new(aggregate_id: aggregate_id))
   end
 
   def last_event
@@ -335,17 +322,15 @@ RSpec.shared_examples 'an event store' do
 
     it 'allows overriding the created_at timestamp for events' do
       time = Time.parse('2016-10-14T00:00:00.646191Z')
-      event_store.sink(new_event(aggregate_id: aggregate_id,
-                                 type: :billing_details_provided,
-                                 body: { my_event: 'data' },
-                                 created_at: time))
+      event_store.sink(BillingDetailsProvided.new(aggregate_id: aggregate_id,
+                                                  body: { my_event: 'data' },
+                                                  created_at: time))
       expect(last_event.created_at).to eq time
     end
 
     it "sets a created_at time when one isn't provided in the event" do
-      event_store.sink(new_event(aggregate_id: aggregate_id,
-                                 type: :billing_details_provided,
-                                 body: { my_event: 'data' }))
+      event_store.sink(BillingDetailsProvided.new(aggregate_id: aggregate_id,
+                                                  body: { my_event: 'data' }))
       expect(last_event.created_at).to be_instance_of(Time)
     end
   end