euston-eventstore 1.0.0

data/spec/event_store/optimistic_event_stream_spec.rb

@@ -0,0 +1,318 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Euston::EventStore do
+  let(:uuid) { Uuid }
+  let(:default_stream_revision) { 1 }
+  let(:default_commit_sequence) { 1 }
+  let(:stream_id) { uuid.generate }
+  let(:persistence) { double('persistence') }
+  let(:stream) { Euston::EventStore::OptimisticEventStream.new(:stream_id => stream_id, :persistence => persistence) }
+
+  after { stream_id = uuid.generate }
+
+  def build_commit_stub(stream_id, revision, sequence, length)
+    Euston::EventStore::Commit.new( :stream_id => stream_id,
+                                    :stream_revision => revision,
+                                    :commit_sequence => sequence,
+                                    :events => length.times.map{ Euston::EventStore::EventMessage.new })
+  end
+
+  describe 'optimistic event stream' do
+    context 'when constructing a new stream' do
+      let(:min_revision) { 2 }
+      let(:max_revision) { 7 }
+      let(:commit_length) { 2 }
+      let(:committed) { [
+          build_commit_stub(stream_id, 2, 1, commit_length),
+          build_commit_stub(stream_id, 4, 2, commit_length),
+          build_commit_stub(stream_id, 6, 3, commit_length),
+          build_commit_stub(stream_id, 8, 3, commit_length)
+      ] }
+
+      before do
+        persistence.stub(:get_from).with(stream_id, min_revision, max_revision) { committed }
+        @stream = Euston::EventStore::OptimisticEventStream.new(:stream_id => stream_id,
+                                                                :persistence => persistence,
+                                                                :min_revision => min_revision,
+                                                                :max_revision => max_revision)
+      end
+
+      it 'has the correct stream identifier' do
+        @stream.stream_id.should == stream_id
+      end
+
+      it 'has the correct head stream revision' do
+        @stream.stream_revision.should == max_revision
+      end
+
+      it 'has the correct head commit sequence' do
+        @stream.commit_sequence.should == committed.last.commit_sequence
+      end
+
+      it 'does not include the event below the minimum revision indicated' do
+        @stream.committed_events.first.should == committed.first.events.last
+      end
+
+      it 'does not include events above the maximum revision indicated' do
+        @stream.committed_events.last.should == committed.last.events.first
+      end
+
+      it 'has all of the committed events up to the stream revision specified' do
+        @stream.committed_events.length.should == max_revision - min_revision + 1
+      end
+    end
+
+    context 'when constructing the head event revision is less than the max desired revision' do
+      let(:commit_length) { 2 }
+      let(:committed) { [
+          build_commit_stub(stream_id, 2, 1, commit_length),
+          build_commit_stub(stream_id, 4, 2, commit_length),
+          build_commit_stub(stream_id, 6, 3, commit_length),
+          build_commit_stub(stream_id, 8, 3, commit_length)
+      ] }
+
+      before do
+        persistence.stub(:get_from).with(stream_id, 0, Euston::EventStore::FIXNUM_MAX) { committed }
+        @stream = Euston::EventStore::OptimisticEventStream.new(:stream_id => stream_id,
+                                                                :persistence => persistence,
+                                                                :min_revision => 0,
+                                                                :max_revision => Euston::EventStore::FIXNUM_MAX)
+      end
+
+      it 'sets the stream revision to the revision of the most recent event' do
+        @stream.stream_revision.should == committed.last.stream_revision
+      end
+    end
+
+    context 'when adding a null event message' do
+      before do
+        stream << nil
+      end
+
+      it 'is ignored' do
+        stream.uncommitted_events.should be_empty
+      end
+    end
+
+    context 'when adding an unpopulated event message' do
+      before do
+        stream << Euston::EventStore::EventMessage.new(nil)
+      end
+
+      it 'is ignored' do
+        stream.uncommitted_events.should be_empty
+      end
+    end
+
+    context 'when adding a fully populated event message' do
+      before do
+        stream << Euston::EventStore::EventMessage.new('populated')
+      end
+
+      it 'adds the event to the set of uncommitted events' do
+        stream.uncommitted_events.should have(1).items
+      end
+    end
+
+    context 'when adding multiple populated event messages' do
+      before do
+        stream << Euston::EventStore::EventMessage.new('populated')
+        stream << Euston::EventStore::EventMessage.new('also populated')
+      end
+
+      it 'adds all the events provided to the set of uncommitted events' do
+        stream.uncommitted_events.should have(2).items
+      end
+    end
+
+    context 'when adding a simple object as an event message' do
+      let(:my_event) { 'some event data' }
+
+      before do
+        stream << Euston::EventStore::EventMessage.new(my_event)
+      end
+
+      it 'adds the uncommitted event to the set of uncommitted events' do
+        stream.uncommitted_events.should have(1).items
+      end
+
+      it 'wraps the uncommitted event in an EventMessage object' do
+        stream.uncommitted_events.first.body.should == my_event
+      end
+    end
+
+    context 'when clearing any uncommitted changes' do
+      before do
+        stream << Euston::EventStore::EventMessage.new('')
+        stream.clear_changes
+      end
+
+      it 'clears all uncommitted events' do
+        stream.uncommitted_events.should be_empty
+      end
+    end
+
+    context 'when committing an empty changeset' do
+      before do
+        persistence.stub(:commit) { @persisted = true }
+        stream.commit_changes uuid.generate
+      end
+
+      it 'does not call the underlying infrastructure' do
+        @persisted.should be_nil
+      end
+
+      it 'does not increment the current stream revision' do
+        stream.stream_revision.should == 0
+      end
+
+      it 'does not increment the current commit sequence' do
+        stream.commit_sequence.should == 0
+      end
+    end
+
+    context 'when committing any uncommitted changes' do
+      let(:commit_id) { uuid.generate }
+      let(:uncommitted) { Euston::EventStore::EventMessage.new '' }
+      let(:headers) { { :key => :value } }
+
+      before do
+        persistence.stub(:commit) { |c| @constructed = c }
+        stream << uncommitted
+        headers.each { |key, value| stream.uncommitted_headers[key] = value }
+        stream.commit_changes commit_id
+      end
+
+      it 'provides a commit to the underlying infrastructure' do
+        @constructed.should_not be_nil
+      end
+
+      it 'builds the commit with the correct stream identifier' do
+        @constructed.stream_id.should == stream_id
+      end
+
+      it 'builds the commit with the correct stream revision' do
+        @constructed.stream_revision.should == default_stream_revision
+      end
+
+      it 'builds the commit with the correct commit identifier' do
+        @constructed.commit_id.should == commit_id
+      end
+
+      it 'builds the commit with an incremented commit sequence' do
+        @constructed.commit_sequence.should == default_commit_sequence
+      end
+
+      it 'builds the commit with the correct commit stamp' do
+        ((Time.now - @constructed.commit_timestamp) < 0.05).should be_true
+      end
+
+      it 'builds the commit with the headers provided' do
+        @constructed.headers.each do |key, value|
+          headers[key].should == value
+        end
+        @constructed.headers.keys.length.should == headers.keys.length
+      end
+
+    	it 'builds the commit containing all uncommitted events' do
+    		@constructed.events.should have(1).items
+  		end
+
+    	it 'builds the commit using the event messages provided' do
+    		@constructed.events.first.should == uncommitted
+  		end
+
+    	it 'updates the stream revision' do
+    		stream.stream_revision.should == @constructed.stream_revision
+  		end
+
+    	it 'updates the commit sequence' do
+    		stream.commit_sequence.should == @constructed.commit_sequence
+  		end
+
+    	it 'adds the uncommitted events to the committed events' do
+    		stream.committed_events.last.should == uncommitted
+  		end
+
+    	it 'clears the uncommitted events' do
+    		stream.uncommitted_events.should have(0).items
+  		end
+
+    	it 'clears the uncommitted headers' do
+    		stream.uncommitted_headers.should have(0).items
+  		end
+    end
+
+    context 'when committing with an identifier that was previously read' do
+    	let(:committed) { [ build_commit_stub(stream_id, 1, 1, 1) ] }
+      let(:duplicate_commit_id) { committed.first.commit_id }
+
+      before do
+        persistence.stub(:get_from).with(stream_id, 0, Euston::EventStore::FIXNUM_MAX) { committed }
+
+        @stream = Euston::EventStore::OptimisticEventStream.new(:stream_id => stream_id,
+                                                                :persistence => persistence,
+                                                                :min_revision => 0,
+                                                                :max_revision => Euston::EventStore::FIXNUM_MAX)
+
+        begin
+          @stream.commit_changes duplicate_commit_id
+        rescue Exception => e
+          @thrown = e
+        end
+      end
+
+    	it 'throws a DuplicateCommitError' do
+    		@thrown.should be_a(Euston::EventStore::DuplicateCommitError)
+  		end
+    end
+
+    context 'when committing after another thread or process has moved the stream head' do
+      let(:stream_revision) { 1 }
+    	let(:committed) { [ build_commit_stub(stream_id, 1, 1, 1) ] }
+    	let(:uncommitted) { Euston::EventStore::EventMessage.new ''  }
+    	let(:discovered_on_commit) { [ build_commit_stub(stream_id, 3, 2, 2) ] }
+
+      before do
+        persistence.stub(:commit) { raise Euston::EventStore::ConcurrencyError.new }
+    		persistence.stub(:get_from).with(stream_id, stream_revision, Euston::EventStore::FIXNUM_MAX) { committed }
+    		persistence.stub(:get_from).with(stream_id, stream_revision + 1, Euston::EventStore::FIXNUM_MAX) do
+    		  @queried_for_new_commits = true
+          discovered_on_commit
+        end
+
+    		@stream = Euston::EventStore::OptimisticEventStream.new(:stream_id => stream_id,
+                                                                :persistence => persistence,
+                                                                :min_revision => stream_revision,
+                                                                :max_revision => Euston::EventStore::FIXNUM_MAX)
+    		@stream << uncommitted
+
+        begin
+          @stream.commit_changes uuid.generate
+        rescue Exception => e
+          @thrown = e
+        end
+      end
+
+    	it 'throws a ConcurrencyError' do
+    		@thrown.should be_a(Euston::EventStore::ConcurrencyError)
+  		end
+
+    	it 'queries the underlying storage to discover the new commits' do
+    		@queried_for_new_commits.should be_true
+  		end
+
+    	it 'updates the stream revision accordingly' do
+    		@stream.stream_revision.should == discovered_on_commit.first.stream_revision
+  		end
+
+    	it 'updates the commit sequence accordingly' do
+    		@stream.commit_sequence.should == discovered_on_commit.first.commit_sequence
+  		end
+
+    	it 'add the newly discovered committed events to the set of committed events accordingly' do
+    		@stream.committed_events.should have(discovered_on_commit.first.events.length + 1).items
+  		end
+    end
+  end
+end

data/spec/event_store/persistence/mongodb_spec.rb

@@ -0,0 +1,301 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Euston::EventStore do
+  describe 'mongodb persistence' do
+    let(:uuid) { Uuid }
+    let(:database) { 'event_store_tests' }
+    let(:config) { Euston::EventStore::Persistence::Mongodb::Config }
+    let(:factory) { Euston::EventStore::Persistence::Mongodb::MongoPersistenceFactory }
+    let(:stream_id) { uuid.generate }
+
+    before do
+      config.instance.database = database
+
+      @persistence = factory.build
+      @persistence.init
+    end
+
+    context 'when a commit is successfully persisted' do
+      let(:now) { Time.now.utc + (60 * 60 * 24 * 7 * 52) }
+      let(:attempt) { new_attempt(:commit_timestamp => now) }
+
+      before do
+        @persistence.commit attempt
+
+        sleep 0.25
+
+        @persisted = @persistence.get_from(:stream_id => stream_id,
+                                           :min_revision => 0,
+                                           :max_revision => Euston::EventStore::FIXNUM_MAX).first
+      end
+
+      it('correctly persists the stream identifier') { @persisted.stream_id.should == attempt.stream_id }
+      it('correctly persists the stream revision') { @persisted.stream_revision.should == attempt.stream_revision }
+      it('correctly persists the commit identifier') { @persisted.commit_id.should == attempt.commit_id }
+      it('correctly persists the commit sequence') { @persisted.commit_sequence.should == attempt.commit_sequence }
+
+		  # persistence engines have varying levels of precision with respect to time.
+		  it('correctly persists the commit timestamp') { (@persisted.commit_timestamp - now.to_f).should be <= 1 }
+
+      it('correctly persists the headers') { @persisted.headers.should have(attempt.headers.length).items }
+      it('correctly persists the events') { @persisted.events.should have(attempt.events.length).items }
+      it('makes the commit available to be read from the stream') {
+        @persistence.get_from(:stream_id => stream_id,
+                              :min_revision => 0,
+                              :max_revision => Euston::EventStore::FIXNUM_MAX).first.commit_id.should == attempt.commit_id }
+
+      it('adds the commit to the set of undispatched commits') {
+			  @persistence.get_undispatched_commits.detect { |x| x.commit_id == attempt.commit_id }.should_not be_nil }
+
+      it('causes the stream to be found in the list of streams to snapshot') {
+        @persistence.get_streams_to_snapshot(1).detect { |x| x.stream_id == stream_id }.should_not be_nil }
+    end
+
+    context 'when reading from a given revision' do
+      let(:load_from_commit_containing_revision) { 3 }
+      let(:up_to_commit_containing_revision) { 5 }
+      let(:oldest) { new_attempt }
+      let(:oldest2) { next_attempt(oldest) }
+      let(:oldest3) { next_attempt(oldest2) }
+      let(:newest) { next_attempt(oldest3) }
+
+      before do
+        @persistence.commit oldest
+        @persistence.commit oldest2
+        @persistence.commit oldest3
+        @persistence.commit newest
+
+        @committed = @persistence.get_from(:stream_id => stream_id,
+                                           :min_revision => load_from_commit_containing_revision,
+                                           :max_revision => up_to_commit_containing_revision).to_a
+
+      end
+
+      it('starts from the commit which contains the minimum stream revision specified') { @committed.first.commit_id.should == oldest2.commit_id }
+      it('reads up to the commit which contains the maximum stream revision specified') { @committed.last.commit_id.should == oldest3.commit_id }
+    end
+
+    context 'when committing a stream with the same revision' do
+      let(:persistence1) { factory.build }
+      let(:persistence2) { factory.build }
+      let(:attempt1) { new_attempt }
+      let(:attempt2) { new_attempt }
+
+      before do
+        persistence1.init
+        persistence2.init
+
+        persistence1.commit attempt1
+
+        begin
+          persistence2.commit attempt2
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('raises a ConcurrencyError') { @caught.should be_an(Euston::EventStore::ConcurrencyError) }
+    end
+
+    context 'when committing a stream with the same sequence' do
+      let(:persistence1) { factory.build }
+      let(:persistence2) { factory.build }
+      let(:attempt1) { new_attempt }
+      let(:attempt2) { new_attempt }
+
+      before do
+        persistence1.init
+        persistence2.init
+
+        persistence1.commit attempt1
+
+        begin
+          persistence2.commit attempt2
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('raises a ConcurrencyError') { @caught.should be_an(Euston::EventStore::ConcurrencyError) }
+    end
+
+    context 'when attempting to overwrite a committed sequence' do
+      let(:successful_attempt) { new_attempt }
+      let(:failed_attempt) { new_attempt }
+
+      before do
+        @persistence.commit successful_attempt
+
+        begin
+          @persistence.commit failed_attempt
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('raises a ConcurrencyError') { @caught.should be_an(Euston::EventStore::ConcurrencyError) }
+    end
+
+    context 'when attempting to persist a commit twice' do
+      let(:attempt) { new_attempt }
+
+      before do
+        @persistence.commit attempt
+
+        begin
+          @persistence.commit attempt
+        rescue Exception => e
+          @caught = e
+        end
+      end
+
+      it('raises a DuplicateCommitError') { @caught.should be_an(Euston::EventStore::DuplicateCommitError) }
+    end
+
+    context 'when a commit has been marked as dispatched' do
+      let(:attempt) { new_attempt }
+
+      before do
+        @persistence.commit attempt
+        @persistence.mark_commit_as_dispatched attempt
+      end
+
+      it('is no longer found in the set of undispatched commits') {
+        @persistence.get_undispatched_commits.detect { |c| c.commit_id == attempt.commit_id }.should be_nil }
+    end
+
+    context 'when saving a snapshot' do
+      let(:snapshot) { Euston::EventStore::Snapshot.new stream_id, 1, { :key => :value } }
+
+      before do
+        @persistence.commit new_attempt
+
+        sleep 0.25
+
+        @added = @persistence.add_snapshot snapshot
+      end
+
+      it('indicates the snapshot was added') { @added.should be_true }
+      it('is able to retrieve the snapshot') { @persistence.get_snapshot(stream_id, snapshot.stream_revision).should_not be_nil }
+    end
+
+    context 'when retrieving a snapshot' do
+      let(:too_far_back) { Euston::EventStore::Snapshot.new stream_id, 1, {} }
+      let(:correct) { Euston::EventStore::Snapshot.new stream_id, 3, { 'key' => 'value' } }
+      let(:too_far_forward) { Euston::EventStore::Snapshot.new stream_id, 5, {} }
+      let(:commit1) { new_attempt }
+      let(:commit2) { next_attempt commit1 }
+      let(:commit3) { next_attempt commit2 }
+
+      before do
+        @persistence.commit commit1
+        @persistence.commit commit2
+        @persistence.commit commit3
+
+        sleep 0.25
+
+        @persistence.add_snapshot too_far_back
+        @persistence.add_snapshot correct
+        @persistence.add_snapshot too_far_forward
+
+        @snapshot = @persistence.get_snapshot stream_id, too_far_forward.stream_revision - 1
+      end
+
+      it('loads the most recent prior snapshot') { @snapshot.stream_revision.should == correct.stream_revision }
+      it('has the correct snapshot payload') { @snapshot.payload.should == correct.payload }
+    end
+
+    context 'when a snapshot has been added to the most recent commit of a stream' do
+      let(:oldest) { new_attempt }
+      let(:oldest2) { next_attempt oldest }
+      let(:newest) { next_attempt oldest2 }
+      let(:snapshot) { Euston::EventStore::Snapshot.new stream_id, newest.stream_revision, { :key => :value } }
+
+      before do
+        @persistence.commit oldest
+        @persistence.commit oldest2
+        @persistence.commit newest
+
+        sleep 0.25
+
+        @persistence.add_snapshot snapshot
+      end
+
+      it('no longer finds the stream in the set of streams to be snapshot') {
+        @persistence.get_streams_to_snapshot(1).detect { |x| x.stream_id == stream_id }.should be_nil }
+    end
+
+# Timing issues with this one?
+#
+#    context 'when adding a commit after a snapshot' do
+#      let(:within_threshold) { 2 }
+#      let(:over_threshold) { 3 }
+#      let(:snapshot_data) { { :key => :value } }
+#      let(:oldest) { new_attempt }
+#      let(:oldest2) { next_attempt oldest }
+#      let(:newest) { next_attempt oldest2 }
+
+#      before do
+#        @persistence.commit oldest
+#        @persistence.commit oldest2
+
+#        sleep 0.25
+
+#        @persistence.add_snapshot Euston::EventStore::Snapshot.new(stream_id, oldest2.stream_revision, snapshot_data)
+#        @persistence.commit newest
+#      end
+
+#      it 'finds the stream in the set of streams to be snapshot when within the threshold' do
+#        @persistence.get_streams_to_snapshot(within_threshold).detect { |x| x.stream_id == stream_id }.should_not be_nil
+#      end
+
+#      it 'does not find the stream in the set of stream to be snapshot when over the threshold' do
+#        @persistence.get_streams_to_snapshot(over_threshold).detect { |x| x.stream_id == stream_id }.should be_nil
+#      end
+#    end
+
+    context 'when reading all commits from a particular point in time' do
+      let(:now) { Time.now.utc + (60 * 60 * 24 * 7 * 52) }
+      let(:first) { new_attempt(:commit_timestamp => now + 1) }
+      let(:second) { next_attempt first }
+      let(:third) { next_attempt second }
+      let(:fourth) { next_attempt third }
+
+      before do
+        @persistence.commit first
+        @persistence.commit second
+        @persistence.commit third
+        @persistence.commit fourth
+
+        @committed = @persistence.get_from :timestamp => now
+      end
+
+      it('returns all commits on or after the point in time specified') { @committed.should have(4).items }
+    end
+
+    def new_attempt(options = {})
+      defaults = { :stream_id => stream_id,
+                   :stream_revision => 2,
+                   :commit_id => uuid.generate,
+                   :commit_sequence => 1,
+                   :commit_timestamp => Time.now.utc,
+                   :headers => { 'A header' => 'A string value',
+                                 'Another header' => 2 },
+                   :events => [ Euston::EventStore::EventMessage.new(:some_property => 'test'),
+                                Euston::EventStore::EventMessage.new(:some_property => 'test2') ] }
+
+      Euston::EventStore::Commit.new(defaults.merge options)
+    end
+
+    def next_attempt(attempt)
+      Euston::EventStore::Commit.new(:stream_id => attempt.stream_id,
+                                     :stream_revision => attempt.stream_revision + 2,
+                                     :commit_id => uuid.generate,
+                                     :commit_sequence => attempt.commit_sequence + 1,
+                                     :commit_timestamp => attempt.commit_timestamp,
+                                     :headers => {},
+                                     :events => [ Euston::EventStore::EventMessage.new(:some_property => 'Another test'),
+                                                  Euston::EventStore::EventMessage.new(:some_property => 'Another test2') ])
+    end
+  end
+end