euston-eventstore 1.0.2-java

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

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