euston-eventstore 1.0.0

data/lib/euston-eventstore/persistence/mongodb/mongo_snapshot.rb

@@ -0,0 +1,32 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoSnapshot
+          extend ::ActiveSupport::Concern
+
+          class << self
+            def from_hash(hash)
+              return nil if hash.nil?
+
+              id = hash['_id']
+
+              Euston::EventStore::Snapshot.new id['stream_id'], id['stream_revision'], hash['payload']
+            end
+          end
+
+          def to_hash
+            {
+              :_id => { :stream_id => stream_id, :stream_revision => stream_revision },
+              :payload => payload.recursive_stringify_symbol_values!
+            }
+          end
+        end
+      end
+    end
+
+    class Snapshot
+      include Persistence::Mongodb::MongoSnapshot
+    end
+  end
+end

data/lib/euston-eventstore/persistence/mongodb/mongo_stream_head.rb

@@ -0,0 +1,29 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoStreamHead
+          extend ::ActiveSupport::Concern
+
+          class << self
+            def from_hash(hash)
+              Euston::EventStore::Persistence::StreamHead.new hash['_id'], hash['head_revision'], hash['snapshot_revision']
+            end
+          end
+
+          def to_hash
+            {
+              :stream_id => @stream_id,
+              :head_revision => @head_revision,
+              :snapshot_revision => @snapshot_revision
+            }
+          end
+        end
+      end
+
+      class StreamHead
+        include Mongodb::MongoStreamHead
+      end
+    end
+  end
+end

data/lib/euston-eventstore/persistence/stream_head.rb

@@ -0,0 +1,23 @@
+module Euston
+  module EventStore
+    module Persistence
+      # Indicates the most recent information representing the head of a given stream.
+      class StreamHead
+        def initialize(stream_id, head_revision, snapshot_revision)
+          @stream_id = stream_id
+          @head_revision = head_revision
+          @snapshot_revision = snapshot_revision
+        end
+
+        # Gets the value which uniquely identifies the stream where the last snapshot exceeds the allowed threshold.
+        attr_reader :stream_id
+
+        # Gets the value which indicates the revision, length, or number of events committed to the stream.
+        attr_reader :head_revision
+
+        # Gets the value which indicates the revision at which the last snapshot was taken.
+        attr_reader :snapshot_revision
+      end
+    end
+  end
+end

data/lib/euston-eventstore/snapshot.rb

@@ -0,0 +1,21 @@
+module Euston
+  module EventStore
+    # Represents a materialized view of a stream at specific revision.
+    class Snapshot
+      def initialize(stream_id, stream_revision, payload)
+        @stream_id = stream_id
+        @stream_revision = stream_revision
+        @payload = payload
+      end
+
+      # Gets the value which uniquely identifies the stream to which the snapshot applies.
+      attr_reader :stream_id
+
+      # Gets the position at which the snapshot applies.
+      attr_reader :stream_revision
+
+      # Gets the snapshot or materialized view of the stream at the revision indicated.
+      attr_reader :payload
+    end
+  end
+end

data/lib/euston-eventstore/version.rb

@@ -0,0 +1,5 @@
+module Euston
+  module EventStore
+    VERSION = "1.0.0"
+  end
+end

data/spec/event_store/dispatcher/asynchronous_dispatcher_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Euston::EventStore do
+  let(:uuid) { Uuid }
+
+  describe 'asynchronous dispatcher' do
+    context 'when instantiating the asynchronous dispatcher' do
+      let(:stream_id) { uuid.generate }
+      let(:commits) { [ new_commit(:stream_id => stream_id), new_commit(:stream_id => stream_id) ] }
+      let(:bus) { stub('bus').as_null_object }
+      let(:persistence) { stub('persistence').as_null_object }
+
+      before do
+        persistence.should_receive(:init).once
+        persistence.should_receive(:get_undispatched_commits).once { commits }
+        bus.should_receive(:publish).with(commits.first).once
+        bus.should_receive(:publish).with(commits.last).once
+
+        Euston::EventStore::Dispatcher::AsynchronousDispatcher.new bus, persistence
+        sleep 0.25
+      end
+
+      it('initializes the persistence engine') { persistence.rspec_verify }
+      it('gets the set of undispatched commits') { persistence.rspec_verify }
+      it('provides the commits to the published') { bus.rspec_verify }
+    end
+
+    context 'when asynchronously dispatching a commit' do
+      let(:commit) { new_commit }
+      let(:bus) { stub('bus').as_null_object }
+      let(:persistence) { stub('persistence').as_null_object }
+
+      before do
+        bus.should_receive(:publish).with(commit).once
+        persistence.should_receive(:mark_commit_as_dispatched).with(commit).once
+
+        @dispatcher = Euston::EventStore::Dispatcher::AsynchronousDispatcher.new bus, persistence
+        @dispatcher.dispatch commit
+        sleep 0.25
+      end
+
+      it('provides the commit to the message bus') { bus.rspec_verify }
+      it('marks the commit as dispatched') { persistence.rspec_verify }
+    end
+
+    context 'when an asynchronously dispatched commit throws an exception' do
+      let(:commit) { new_commit }
+      let(:persistence) { stub('persistence').as_null_object }
+
+      before do
+        persistence.stub(:get_undispatched_commits) { [] }
+
+        @dispatcher = Euston::EventStore::Dispatcher::AsynchronousDispatcher.new nil, persistence do |commit, exception|
+          @caught_commit = commit
+          @caught_exception = exception
+        end
+
+        @dispatcher.dispatch commit
+        sleep 0.25
+      end
+
+      it('provides the commit that caused the error') { @caught_commit.should be_an(Euston::EventStore::Commit) }
+      it('provides the exception') { @caught_exception.should be_an(Exception) }
+    end
+
+    def new_commit(options = {})
+      defaults = { :stream_id => uuid.generate,
+                   :stream_revision => 0,
+                   :commit_id => uuid.generate,
+                   :commit_sequence => 0 }
+
+      Euston::EventStore::Commit.new(defaults.merge options)
+    end
+  end
+end

data/spec/event_store/dispatcher/synchronous_dispatcher_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Euston::EventStore do
+  let(:uuid) { Uuid }
+
+  describe 'synchronous dispatcher' do
+    let(:bus) { stub('bus').as_null_object }
+    let(:persistence) { stub('persistence').as_null_object }
+
+    context 'when synchronously dispatching a commit' do
+      let(:commit) { new_commit }
+
+      before do
+        persistence.stub(:get_undispatched_commits) { [] }
+        persistence.should_receive(:mark_commit_as_dispatched).with(commit).once
+
+        @dispatched_commits = []
+
+        @dispatcher = Euston::EventStore::Dispatcher::SynchronousDispatcher.new(persistence) do |c|
+          @dispatched_commits << c
+        end
+
+        @dispatcher.dispatch commit
+      end
+
+      it('provides the commit to the message bus') { @dispatched_commits.should have(1).item }
+      it('marks the commit as dispatched') { persistence.rspec_verify }
+    end
+
+    def new_commit(options = {})
+      defaults = { :stream_id => uuid.generate,
+                   :stream_revision => 0,
+                   :commit_id => uuid.generate,
+                   :commit_sequence => 0 }
+
+      Euston::EventStore::Commit.new(defaults.merge options)
+    end
+  end
+end

data/spec/event_store/optimistic_event_store_spec.rb

@@ -0,0 +1,292 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Euston::EventStore do
+  let(:uuid) { Uuid }
+  let(:stream_id) { uuid.generate }
+  let(:persistence) { double('persistence').as_null_object }
+  let(:store) { Euston::EventStore::OptimisticEventStore.new persistence }
+
+  after { stream_id = uuid.generate }
+
+  describe 'optimistic event store' do
+    context 'when creating a stream' do
+      let(:stream) { store.create_stream stream_id }
+
+      it('returns a new stream') { stream.should_not be_nil }
+      it('returns a stream with the correct stream identifier') { stream.stream_id.should == stream_id }
+      it('returns a stream with a zero stream revision') { stream.stream_revision.should == 0 }
+      it('returns a stream with a zero commit sequence') { stream.commit_sequence.should == 0 }
+      it('returns a stream with no committed events') { stream.committed_events.should have(0).items }
+      it('returns a stream with no uncommitted events') { stream.uncommitted_events.should have(0).items }
+      it('returns a stream with no uncommitted headers') { stream.uncommitted_headers.should have(0).items }
+    end
+
+    context 'when opening an empty stream starting at revision zero' do
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => 0,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX }) { [] }
+
+        @stream = store.open_stream :stream_id => stream_id, :min_revision => 0, :max_revision => 0
+      end
+
+      it('returns a new stream') { @stream.should_not be_nil }
+      it('returns a stream with the correct stream identifier') { @stream.stream_id.should == stream_id }
+      it('returns a stream with a zero stream revision') { @stream.stream_revision.should == 0 }
+      it('returns a stream with a zero commit sequence') { @stream.commit_sequence.should == 0 }
+      it('returns a stream with no committed events') { @stream.committed_events.should have(0).items }
+      it('returns a stream with no uncommitted events') { @stream.uncommitted_events.should have(0).items }
+      it('returns a stream with no uncommitted headers') { @stream.uncommitted_headers.should have(0).items }
+    end
+
+    context 'when opening an empty stream starting above revision zero' do
+      let(:min_revision) { 1 }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => min_revision,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX }) { [] }
+
+        begin
+          store.open_stream :stream_id => stream_id,
+                            :min_revision => min_revision,
+                            :max_revision => Euston::EventStore::FIXNUM_MAX
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('throws a StreamNotFoundError') { @caught.should be_an(Euston::EventStore::StreamNotFoundError)  }
+    end
+
+    context 'when opening a populated stream' do
+      let(:min_revision) { 17 }
+      let(:max_revision) { 42 }
+      let(:committed) { [ commit(:stream_revision => min_revision,
+                                 :commit_sequence => 1) ] }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => min_revision,
+                                           :max_revision => max_revision }) { @invoked = true; committed }
+
+        @stream = store.open_stream :stream_id => stream_id,
+                                    :min_revision => min_revision,
+                                    :max_revision => max_revision
+      end
+
+      it('invokes the underlying infrastructure with the values provided') { @invoked.should be_true }
+      it('returns an event stream containing the correct stream identifier') { @stream.stream_id.should == stream_id }
+    end
+
+    context 'when opening a populated stream' do
+      let(:min_revision) { 17 }
+      let(:max_revision) { 42 }
+      let(:committed) { [ commit(:stream_revision => min_revision) ] }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => min_revision,
+                                           :max_revision => max_revision }) { @invoked = true; committed }
+
+        @stream = store.open_stream :stream_id => stream_id,
+                                    :min_revision => min_revision,
+                                    :max_revision => max_revision
+      end
+
+      it('invokes the underlying infrastructure with the values provided') { @invoked.should be_true }
+      it('returns an event stream containing the correct stream identifier') { @stream.stream_id.should == stream_id }
+    end
+
+    context 'when opening a populated stream from a snapshot' do
+      let(:min_revision) { 42 }
+      let(:max_revision) { Euston::EventStore::FIXNUM_MAX }
+      let(:snapshot) { Euston::EventStore::Snapshot.new stream_id, min_revision, 'snapshot' }
+      let(:committed) { [ commit(:stream_revision => min_revision, :commit_sequence => 0) ] }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => min_revision,
+                                           :max_revision => max_revision }) { @invoked = true; committed }
+
+        store.open_stream :snapshot => snapshot,
+                          :max_revision => max_revision
+      end
+
+      it('invokes the underlying infrastructure with the values provided') { @invoked.should be_true }
+    end
+
+    context 'when opening a stream from a snapshot that is at the revision of the stream head' do
+      let(:head_stream_revision) { 42 }
+      let(:head_commit_sequence) { 15 }
+      let(:snapshot) { Euston::EventStore::Snapshot.new stream_id, head_stream_revision, 'snapshot' }
+      let(:committed) { Euston::EventStore::ArrayEnumerationCounter.new [ commit(:stream_revision => head_stream_revision,
+                                                                         :commit_sequence => head_commit_sequence) ] }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => head_stream_revision,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX }) { committed }
+
+        @stream = store.open_stream :snapshot => snapshot,
+                                    :max_revision => Euston::EventStore::FIXNUM_MAX
+      end
+
+      it('returns a stream with the correct stream identifier') { @stream.stream_id.should == stream_id }
+      it('returns a stream with the revision of the stream head') { @stream.stream_revision.should == head_stream_revision }
+      it('returns a stream with a commit sequence of the stream head') { @stream.commit_sequence.should == head_commit_sequence }
+      it('returns a stream with no committed events') { @stream.committed_events.should have(0).items }
+      it('returns a stream with no uncommitted events') { @stream.uncommitted_events.should have(0).items }
+      it('only enumerates the set of commits once') { committed.invocations.should == 1 }
+    end
+
+    context 'when reading from revision zero' do
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => 0,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX }) { @invoked = true; [] }
+
+        store.get_from stream_id, 0, Euston::EventStore::FIXNUM_MAX
+      end
+
+      it('passes a revision range to the persistence infrastructure') { @invoked.should be_true }
+    end
+
+    describe 'when reading up to revision zero' do
+      let(:committed) { [ commit ] }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => 0,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX }) { @invoked = true; committed }
+
+        store.open_stream :stream_id => stream_id,
+                          :min_revision => 0,
+                          :max_revision => 0
+      end
+
+      it('passes the maximum possible revision to the persistence infrastructure') { @invoked.should be_true }
+    end
+
+    context 'when reading from a snapshot up to revision zero' do
+      let(:snapshot) { Euston::EventStore::Snapshot.new stream_id, 1, 'snapshot' }
+      let(:committed) { [ commit ] }
+
+      before do
+        persistence.stub(:get_from).with({ :stream_id => stream_id,
+                                           :min_revision => snapshot.stream_revision,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX }) { @invoked = true; committed }
+
+        store.open_stream :snapshot => snapshot,
+                          :max_revision => 0
+      end
+
+      it('passes the maximum possible revision to the persistence infrastructure') { @invoked.should be_true }
+    end
+
+    context 'when committing a null attempt back to the stream' do
+      before do
+        begin
+          store.commit nil
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('throws an ArgumentError') { @caught.should be_an(ArgumentError) }
+    end
+
+    context 'when committing with an unidentified attempt back to the stream' do
+      let(:empty_identifier) { nil }
+      let(:unidentified) { commit(:commit_id => empty_identifier, :events => [] ) }
+
+      before do
+        begin
+          store.commit unidentified
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('throws an ArgumentError') { @caught.should be_an(ArgumentError) }
+    end
+
+    context 'when the number of commits is greater than the number of revisions' do
+      let(:stream_revision) { 1 }
+      let(:commit_sequence) { 2 }
+      let(:corrupt) { commit(:stream_revision => stream_revision, :commit_sequence => commit_sequence) }
+
+      before do
+        begin
+          store.commit corrupt
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('throws an ArgumentError') { @caught.should be_an(ArgumentError) }
+    end
+
+    context 'when committing with a non-positive commit sequence back to the stream' do
+      let(:stream_revision) { 1 }
+      let(:invalid_commit_sequence) { 0 }
+      let(:invalid_commit) { commit(:stream_revision => stream_revision, :commit_sequence => invalid_commit_sequence) }
+
+      before do
+        begin
+          store.commit invalid_commit
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('throw an ArgumentError') { @caught.should be_an(ArgumentError) }
+    end
+
+    context 'when committing with a non-positive stream revision back to the stream' do
+      let(:invalid_stream_revision) { 0 }
+      let(:commit_sequence) { 1 }
+      let(:invalid_commit) { commit(:stream_revision => invalid_stream_revision, :commit_sequence => commit_sequence) }
+
+      before do
+        begin
+          store.commit invalid_commit
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('throw an ArgumentError') { @caught.should be_an(ArgumentError) }
+    end
+
+    context 'when committing an empty attempt to a stream' do
+      let(:attempt_with_no_events) { commit }
+
+      before do
+        persistence.stub(:commit).with(attempt_with_no_events) { @invoked = true }
+      end
+
+      it('drops the commit provided') { @invoked.should be_nil }
+    end
+
+    context 'when committing with a valid and populated attempt to a stream' do
+      let(:populated_attempt) { commit }
+
+      before do
+        persistence.stub(:commit).with(populated_attempt) { @commit_invoked = true }
+
+        store.commit populated_attempt
+      end
+
+      it('provides the commit attempt to the configured persistence mechanism') { @commit_invoked.should be_true }
+    end
+  end
+
+  def commit(options = {})
+    defaults = { :stream_id => stream_id,
+                 :commit_id => uuid.generate,
+                 :events => [ Euston::EventStore::EventMessage.new ]}
+
+    Euston::EventStore::Commit.new(defaults.merge options)
+  end
+end