ruby_event_store 0.18.2 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbe2a5460bf30467128c5abc45d81cbd9898b44f
-  data.tar.gz: 4c8e7701c16e6e7d08173b22a20799a8d82bf57d
+  metadata.gz: cf38d679db05a58d03f5cf03128e1515a44ae1e1
+  data.tar.gz: ffabae418e7ec0fb99fe6b546790a155d2a1c361
 SHA512:
-  metadata.gz: c268df5cf9ca40e57dbb76c954c7c161383df97fa50d5d895c4e3afeccd7a0fcb60718fd423f454a16b866b59f73a50040e07c41ec34a9adace72b653a7c3f89
-  data.tar.gz: c6a36bc896db65bcc54dabaf5621d694b14795dd3f61a6c42717676728363645e3e9568410ba5be4248d561f371e78285a76a7d27f0d49a2c99ebc21fca3a6e1
+  metadata.gz: 7ab222cbac66327aa236df8dc5c8f5b789854559d59a2d731914e031f1874f861ce9743b51a4d6c2a5f0351458f83b6fa0c6bbce16f887de69d600d8ee70a406
+  data.tar.gz: 0b89629ee2da94623d4bb04998e0e686e424d94a1a05f306e168b1d0afb51d19ffd16ccb72d989249821bf0688a991237e99ce41d3d2746cba2cc664ea8a9455

data/Makefile

@@ -10,8 +10,7 @@ test: ## Run tests
 
 mutate: test  ## Run mutation tests
 	@echo "Running mutation tests - only 100% free mutation will be accepted"
-	@bundle exec mutant --include lib --require ruby_event_store --use rspec "RubyEventStore*" \
-		--ignore-subject "RubyEventStore.const_missing"
+	@bundle exec mutant --include lib --require ruby_event_store --use rspec "RubyEventStore*" --ignore-subject "RubyEventStore.const_missing" --ignore-subject "RubyEventStore::InMemoryRepository#append_with_synchronize" --ignore-subject "RubyEventStore::InMemoryRepository#normalize_to_array" --ignore-subject "RubyEventStore::Client#normalize_to_array"
 
 build:
 	@gem build -V ruby_event_store.gemspec

data/lib/ruby_event_store/client.rb

@@ -12,16 +12,22 @@ module RubyEventStore
       @clock          = clock
     end
 
-    def publish_event(event, stream_name: GLOBAL_STREAM, expected_version: :any)
-      append_to_stream(event, stream_name: stream_name, expected_version: expected_version)
-      event_broker.notify_subscribers(event)
+    def publish_events(events, stream_name: GLOBAL_STREAM, expected_version: :any)
+      append_to_stream(events, stream_name: stream_name, expected_version: expected_version)
+      events.each do |ev|
+        event_broker.notify_subscribers(ev)
+      end
       :ok
     end
 
-    def append_to_stream(event, stream_name: GLOBAL_STREAM, expected_version: :any)
-      validate_expected_version(stream_name, expected_version)
-      enriched_event = enrich_event_metadata(event)
-      repository.create(enriched_event, stream_name)
+    def publish_event(event, stream_name: GLOBAL_STREAM, expected_version: :any)
+      publish_events([event], stream_name: stream_name, expected_version: expected_version)
+    end
+
+    def append_to_stream(events, stream_name: GLOBAL_STREAM, expected_version: :any)
+      events = normalize_to_array(events)
+      events.each{|event| enrich_event_metadata(event) }
+      repository.append_to_stream(events, stream_name, expected_version)
       :ok
     end
 
@@ -64,13 +70,13 @@ module RubyEventStore
     end
 
     def subscribe(subscriber, event_types, &proc)
-      event_broker.add_subscriber(subscriber_or_proxy(subscriber), event_types).tap do |unsub|
+      event_broker.add_subscriber(subscriber, event_types).tap do |unsub|
         handle_subscribe(unsub, &proc)
       end
     end
 
     def subscribe_to_all_events(subscriber, &proc)
-      event_broker.add_global_subscriber(subscriber_or_proxy(subscriber)).tap do |unsub|
+      event_broker.add_global_subscriber(subscriber).tap do |unsub|
         handle_subscribe(unsub, &proc)
       end
     end
@@ -78,8 +84,8 @@ module RubyEventStore
     private
     attr_reader :repository, :page_size, :event_broker, :metadata_proc, :clock
 
-    def subscriber_or_proxy(subscriber)
-      subscriber.instance_of?(Class) ? event_broker.proxy_for(subscriber) : subscriber
+    def normalize_to_array(events)
+      return *events
     end
 
     def enrich_event_metadata(event)
@@ -87,14 +93,15 @@ module RubyEventStore
       metadata[:timestamp] ||= clock.()
       metadata.merge!(metadata_proc.call || {}) if metadata_proc
 
-      event.class.new(event_id: event.event_id, metadata: metadata, data: event.data)
+      # event.class.new(event_id: event.event_id, metadata: metadata, data: event.data)
     end
 
-    def handle_subscribe(unsub)
-      if block_given?
-        yield
+    def handle_subscribe(unsub, &proc)
+      begin
+        proc.call
+      ensure
         unsub.()
-      end
+      end if proc
     end
 
     class Page
@@ -113,22 +120,5 @@ module RubyEventStore
       attr_reader :start, :count
     end
 
-    def validate_expected_version(stream_name, expected_version)
-      raise InvalidExpectedVersion if expected_version.nil?
-      case expected_version
-      when :any
-        return
-      when :none
-        return if last_stream_event_id(stream_name).nil?
-      else
-        return if last_stream_event_id(stream_name).eql?(expected_version)
-      end
-      raise WrongExpectedEventVersion
-    end
-
-    def last_stream_event_id(stream_name)
-      last = repository.last_stream_event(stream_name)
-      last.event_id if last
-    end
   end
 end

data/lib/ruby_event_store/errors.rb

@@ -6,10 +6,11 @@ module RubyEventStore
   SubscriberNotExist         = Class.new(StandardError)
   InvalidPageStart           = Class.new(ArgumentError)
   InvalidPageSize            = Class.new(ArgumentError)
+  EventDuplicatedInStream    = Class.new(StandardError)
 
   class InvalidHandler < StandardError
-    def initialize(subscriber_klass)
-      super("#call method not found in #{subscriber_klass} subscriber. Are you sure it is a valid subscriber?")
+    def initialize(object)
+      super("#call method not found in #{object.inspect} subscriber. Are you sure it is a valid subscriber?")
     end
   end
 end

data/lib/ruby_event_store/event.rb

@@ -27,6 +27,17 @@ module RubyEventStore
         other_event.data.eql?(data)
     end
 
+    BIG_VALUE = 0b111111100100000010010010110011101011000101010101001100100110000
+
+    # We don't use metadata because == does not use metadata
+    def hash
+      [
+        self.class,
+        event_id,
+        data
+      ].hash ^ BIG_VALUE
+    end
+
     alias_method :eql?, :==
   end
-end
+end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -1,24 +1,34 @@
 require 'ostruct'
+require 'thread'
 
 module RubyEventStore
   class InMemoryRepository
     def initialize
       @all = Array.new
       @streams = Hash.new
+      @mutex = Mutex.new
     end
 
-    def create(event, stream_name)
+    def append_to_stream(events, stream_name, expected_version)
+      raise InvalidExpectedVersion if !expected_version.equal?(:any) && stream_name.eql?(GLOBAL_STREAM)
+      events = normalize_to_array(events)
       stream = read_stream_events_forward(stream_name)
-      all.push(event)
-      stream.push(event)
-      streams[stream_name] = stream
-      event
+      expected_version = case expected_version
+        when :none
+          -1
+        when :auto, :any
+          stream.size - 1
+        when Integer
+          expected_version
+        else
+          raise InvalidExpectedVersion
+      end
+      append_with_synchronize(events, expected_version, stream, stream_name)
+      self
     end
 
     def delete_stream(stream_name)
-      removed = read_stream_events_forward(stream_name).map(&:event_id)
       streams.delete(stream_name)
-      all.delete_if{|ev| removed.include?(ev.event_id)}
     end
 
     def has_event?(event_id)
@@ -58,6 +68,34 @@ module RubyEventStore
     private
     attr_accessor :streams, :all
 
+    def normalize_to_array(events)
+      return *events
+    end
+
+    def append_with_synchronize(events, expected_version, stream, stream_name)
+      # expected_version :auto assumes external lock is used
+      # which makes reading stream before writing safe.
+      #
+      # To emulate potential concurrency issues of :auto strategy without
+      # such external lock we use Thread.pass to make race
+      # conditions more likely. And we only use mutex.synchronize for writing
+      # not for the whole read+write algorithm.
+      Thread.pass
+      @mutex.synchronize do
+        append(events, expected_version, stream, stream_name)
+      end
+    end
+
+    def append(events, expected_version, stream, stream_name)
+      raise WrongExpectedEventVersion unless (stream.size - 1).equal?(expected_version)
+      events.each do |event|
+        all.push(event)
+        raise EventDuplicatedInStream if stream.any?{|ev| ev.event_id.eql?(event.event_id) }
+        stream.push(event)
+      end
+      streams[stream_name] = stream
+    end
+
     def read_batch(source, start_event_id, count)
       return source[0..count-1] if start_event_id.equal?(:head)
       start_index = index_of(source, start_event_id)

data/lib/ruby_event_store/pub_sub/broker.rb

@@ -27,16 +27,12 @@ module RubyEventStore
         end
       end
 
-      def proxy_for(klass)
-        dispatcher.proxy_for(klass)
-      end
-
       private
       attr_reader :subscribers, :dispatcher
 
       def verify_subscriber(subscriber)
         raise SubscriberNotExist if subscriber.nil?
-        raise InvalidHandler.new(subscriber.class) unless subscriber.respond_to?(:call)
+        dispatcher.verify(subscriber)
       end
 
       def subscribe(subscriber, event_types)

data/lib/ruby_event_store/pub_sub/dispatcher.rb

@@ -1,14 +1,25 @@
 module RubyEventStore
   module PubSub
+
     class Dispatcher
       def call(subscriber, event)
+        subscriber = subscriber.new if Class === subscriber
         subscriber.call(event)
       end
 
-      def proxy_for(klass)
-        raise InvalidHandler.new(klass) unless klass.method_defined?(:call)
-        ->(e) { klass.new.call(e) }
+      def verify(subscriber)
+        subscriber = klassify(subscriber)
+        subscriber.respond_to?(:call) or raise InvalidHandler.new(subscriber)
+      end
+
+      private
+
+      def klassify(subscriber)
+        Class === subscriber ? subscriber.new : subscriber
+      rescue ArgumentError
+        raise InvalidHandler.new(subscriber)
       end
     end
+
   end
 end

data/lib/ruby_event_store/spec/dispatcher_lint.rb

@@ -1,30 +1,34 @@
 RSpec.shared_examples :dispatcher do |dispatcher|
-  specify "calls subscribed handler" do
-    handler = double(:handler)
+  specify "calls subscribed instance" do
+    handler = HandlerClass.new
     event   = instance_double(::RubyEventStore::Event)
 
     expect(handler).to receive(:call).with(event)
     dispatcher.(handler, event)
   end
 
-  specify "returns callable proxy" do
+  specify "calls subscribed class" do
     event   = instance_double(::RubyEventStore::Event)
 
-    handler = dispatcher.proxy_for(HandlerClass)
-    expect(handler).to receive(:call).with(event).and_call_original
-    dispatcher.(handler, event)
-    expect(HandlerClass.received).to eq(event)
+    expect(HandlerClass).to receive(:new).and_return( h = HandlerClass.new )
+    expect(h).to receive(:call).with(event)
+    dispatcher.(HandlerClass, event)
   end
 
-  specify "fails to build proxy when no call method defined on class" do
-    message = "#call method not found " +
-      "in String subscriber." +
-      " Are you sure it is a valid subscriber?"
-
-    expect { dispatcher.proxy_for(String) }.to raise_error(::RubyEventStore::InvalidHandler, message)
+  specify "allows callable classes and instances" do
+    expect do
+      dispatcher.verify(HandlerClass)
+    end.not_to raise_error
+    expect do
+      dispatcher.verify(HandlerClass.new)
+    end.not_to raise_error
+    expect do
+      dispatcher.verify(Proc.new{ "yo" })
+    end.not_to raise_error
   end
 
   private
+
   class HandlerClass
     @@received = nil
     def self.received

data/lib/ruby_event_store/spec/event_broker_lint.rb

@@ -23,6 +23,9 @@ RSpec.shared_examples :event_broker do |broker_class|
       @dispatched = []
     end
 
+    def verify(_subscriber)
+    end
+
     def call(subscriber, event)
       @dispatched << {subscriber: subscriber, event: event}
     end
@@ -58,19 +61,17 @@ RSpec.shared_examples :event_broker do |broker_class|
   end
 
   it 'raises error when no valid method on handler' do
-    message = "#call method not found " +
-              "in InvalidTestHandler subscriber." +
-              " Are you sure it is a valid subscriber?"
     subscriber = InvalidTestHandler.new
-    expect { broker.add_subscriber(subscriber, [Test1DomainEvent]) }.to raise_error(RubyEventStore::InvalidHandler, message)
+    expect do
+      broker.add_subscriber(subscriber, [Test1DomainEvent])
+    end.to raise_error(RubyEventStore::InvalidHandler)
   end
 
   it 'raises error when no valid method on global handler' do
-    message = "#call method not found " +
-              "in InvalidTestHandler subscriber." +
-              " Are you sure it is a valid subscriber?"
     subscriber = InvalidTestHandler.new
-    expect { broker.add_global_subscriber(subscriber) }.to raise_error(RubyEventStore::InvalidHandler, message)
+    expect do
+      broker.add_global_subscriber(subscriber)
+    end.to raise_error(RubyEventStore::InvalidHandler)
   end
 
   it 'returns lambda as an output of global subscribe methods' do
@@ -121,19 +122,6 @@ RSpec.shared_examples :event_broker do |broker_class|
     expect(dispatcher.dispatched).to eq([{subscriber: handler, event: event1}])
   end
 
-  it "returns callable proxy" do
-    proxy = broker.proxy_for(TestHandler)
-    expect(proxy.respond_to?(:call)).to be_truthy
-  end
-
-  specify "fails to build proxy when no call method defined on class" do
-    message = "#call method not found " +
-      "in InvalidTestHandler subscriber." +
-      " Are you sure it is a valid subscriber?"
-
-    expect { broker.proxy_for(InvalidTestHandler) }.to raise_error(::RubyEventStore::InvalidHandler, message)
-  end
-
   private
   class HandlerClass
     @@received = nil

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -6,15 +6,249 @@ RSpec.shared_examples :event_repository do |repository_class|
     expect(repository.read_all_streams_forward(:head, 1)).to be_empty
   end
 
-  it 'what you get is what you gave' do
-    created = repository.create(event = TestDomainEvent.new, 'stream')
-    expect(created.object_id).to eq event.object_id
+  specify 'publish fail if expected version is nil' do
+    expect do
+      repository.append_to_stream(event = TestDomainEvent.new, 'stream', nil)
+    end.to raise_error(RubyEventStore::InvalidExpectedVersion)
   end
 
-  it 'created event is stored in given stream' do
+  specify 'append_to_stream returns self' do
+    repository.
+      append_to_stream(event = TestDomainEvent.new, 'stream', -1).
+      append_to_stream(event = TestDomainEvent.new, 'stream', 0)
+  end
+
+  specify 'adds initial event to a new stream' do
+    repository.append_to_stream(event = TestDomainEvent.new, 'stream', :none)
+    expect(repository.read_all_streams_forward(:head, 1).first).to eq(event)
+    expect(repository.read_stream_events_forward('stream').first).to eq(event)
+    expect(repository.read_stream_events_forward('other_stream')).to be_empty
+  end
+
+  specify 'adds multiple initial events to a new stream' do
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :none)
+    expect(repository.read_all_streams_forward(:head, 2)).to eq([event0, event1])
+    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1])
+  end
+
+  specify 'correct expected version on second write' do
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :none)
+    repository.append_to_stream([
+      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', 1)
+    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
+    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+  end
+
+  specify 'incorrect expected version on second write' do
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :none)
+    expect do
+      repository.append_to_stream([
+        event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+        event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      ], 'stream', 0)
+    end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
+
+    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1])
+    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1])
+  end
+
+  specify ':none on first and subsequent write' do
+    repository.append_to_stream([
+      eventA = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :none)
+    expect do
+      repository.append_to_stream([
+        eventB = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      ], 'stream', :none)
+    end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
+    expect(repository.read_all_streams_forward(:head, 1)).to eq([eventA])
+    expect(repository.read_stream_events_forward('stream')).to eq([eventA])
+  end
+
+  specify ':any allows stream with best-effort order and no guarantee' do
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :any)
+    repository.append_to_stream([
+      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :any)
+    expect(repository.read_all_streams_forward(:head, 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
+    expect(repository.read_stream_events_forward('stream').to_set).to eq(Set.new([event0, event1, event2, event3]))
+  end
+
+  specify ':auto queries for last position in given stream' do
+    skip unless test_expected_version_auto
+    repository.append_to_stream([
+      eventA = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      eventB = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      eventC = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'another', :auto)
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :auto)
+    repository.append_to_stream([
+      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', 1)
+  end
+
+  specify ':auto starts from 0' do
+    skip unless test_expected_version_auto
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :auto)
+    expect do
+      repository.append_to_stream([
+        event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      ], 'stream', -1)
+    end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
+  end
+
+  specify ':auto queries for last position and follows in incremental way' do
+    skip unless test_expected_version_auto
+    # It is expected that there is higher level lock
+    # So this query is safe from race conditions
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :auto)
+    repository.append_to_stream([
+      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :auto)
+    expect(repository.read_all_streams_forward(:head, 4)).to eq([
+      event0, event1,
+      event2, event3
+    ])
+    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+  end
+
+  specify ':auto is compatible with manual expectation' do
+    skip unless test_expected_version_auto
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :auto)
+    repository.append_to_stream([
+      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', 1)
+    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
+    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+  end
+
+  specify 'manual is compatible with auto expectation' do
+    skip unless test_expected_version_auto
+    repository.append_to_stream([
+      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :none)
+    repository.append_to_stream([
+      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :auto)
+    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
+    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+  end
+
+  specify 'unlimited concurrency for :any - everything should succeed' do
+    skip unless test_race_conditions_any
+    verify_conncurency_assumptions
+    begin
+      concurrency_level = 4
+
+      fail_occurred = false
+      wait_for_it  = true
+
+      threads = concurrency_level.times.map do |i|
+        Thread.new do
+          true while wait_for_it
+          begin
+            100.times do |j|
+              eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
+              repository.append_to_stream([
+                TestDomainEvent.new(event_id: eid),
+              ], 'stream', :any)
+            end
+          rescue RubyEventStore::WrongExpectedEventVersion
+            fail_occurred = true
+          end
+        end
+      end
+      wait_for_it = false
+      threads.each(&:join)
+      expect(fail_occurred).to eq(false)
+      expect(repository.read_stream_events_forward('stream').size).to eq(400)
+      events_in_stream = repository.read_stream_events_forward('stream')
+      expect(events_in_stream.size).to eq(400)
+      events0 = events_in_stream.select do |ev|
+        ev.event_id.start_with?("0-")
+      end
+      expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
+    ensure
+      cleanup_concurrency_test
+    end
+  end
+
+  specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered' do
+    skip unless test_expected_version_auto
+    skip unless test_race_conditions_auto
+    verify_conncurency_assumptions
+    begin
+      concurrency_level = 4
+
+      fail_occurred = 0
+      wait_for_it  = true
+
+      threads = concurrency_level.times.map do |i|
+        Thread.new do
+          true while wait_for_it
+          100.times do |j|
+            begin
+              eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
+              repository.append_to_stream([
+                TestDomainEvent.new(event_id: eid),
+              ], 'stream', :auto)
+              sleep(rand(concurrency_level) / 1000.0)
+            rescue RubyEventStore::WrongExpectedEventVersion
+              fail_occurred +=1
+            end
+          end
+        end
+      end
+      wait_for_it = false
+      threads.each(&:join)
+      expect(fail_occurred).to be > 0
+      events_in_stream = repository.read_stream_events_forward('stream')
+      expect(events_in_stream.size).to be < 400
+      expect(events_in_stream.size).to be >= 100
+      events0 = events_in_stream.select do |ev|
+        ev.event_id.start_with?("0-")
+      end
+      expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
+      additional_limited_concurrency_for_auto_check
+    ensure
+      cleanup_concurrency_test
+    end
+  end
+
+  it 'appended event is stored in given stream' do
     expected_event = TestDomainEvent.new(data: {})
-    created = repository.create(expected_event, 'stream')
-    expect(created).to eq(expected_event)
+    repository.append_to_stream(expected_event, 'stream', :any)
     expect(repository.read_all_streams_forward(:head, 1).first).to eq(expected_event)
     expect(repository.read_stream_events_forward('stream').first).to eq(expected_event)
     expect(repository.read_stream_events_forward('other_stream')).to be_empty
@@ -22,92 +256,180 @@ RSpec.shared_examples :event_repository do |repository_class|
 
   it 'data attributes are retrieved' do
     event = TestDomainEvent.new(data: { order_id: 3 })
-    repository.create(event, 'stream')
+    repository.append_to_stream(event, 'stream', :any)
     retrieved_event = repository.read_all_streams_forward(:head, 1).first
     expect(retrieved_event.data[:order_id]).to eq(3)
   end
 
   it 'metadata attributes are retrieved' do
     event = TestDomainEvent.new(metadata: { request_id: 3 })
-    repository.create(event, 'stream')
+    repository.append_to_stream(event, 'stream', :any)
     retrieved_event = repository.read_all_streams_forward(:head, 1).first
     expect(retrieved_event.metadata[:request_id]).to eq(3)
   end
 
   it 'does not have deleted streams' do
-    repository.create(TestDomainEvent.new, 'stream')
-    repository.create(TestDomainEvent.new, 'other_stream')
-
-    expect(repository.read_stream_events_forward('stream').count).to eq 1
-    expect(repository.read_stream_events_forward('other_stream').count).to eq 1
-    expect(repository.read_all_streams_forward(:head, 10).count).to eq 2
+    repository.append_to_stream(e1 = TestDomainEvent.new, 'stream', -1)
+    repository.append_to_stream(e2 = TestDomainEvent.new, 'other_stream', -1)
 
     repository.delete_stream('stream')
     expect(repository.read_stream_events_forward('stream')).to be_empty
-    expect(repository.read_stream_events_forward('other_stream').count).to eq 1
-    expect(repository.read_all_streams_forward(:head, 10).count).to eq 1
+    expect(repository.read_stream_events_forward('other_stream')).to eq([e2])
+    expect(repository.read_all_streams_forward(:head, 10)).to eq([e1,e2])
   end
 
   it 'has or has not domain event' do
-    repository.create(TestDomainEvent.new(event_id: 'just an id'), 'stream')
+    just_an_id = 'd5c134c2-db65-4e87-b6ea-d196f8f1a292'
+    repository.append_to_stream(TestDomainEvent.new(event_id: just_an_id), 'stream', -1)
 
-    expect(repository.has_event?('just an id')).to be_truthy
+    expect(repository.has_event?(just_an_id)).to be_truthy
+    expect(repository.has_event?(just_an_id.clone)).to be_truthy
     expect(repository.has_event?('any other id')).to be_falsey
   end
 
   it 'knows last event in stream' do
-    repository.create(TestDomainEvent.new(event_id: 'event 1'), 'stream')
-    repository.create(TestDomainEvent.new(event_id: 'event 2'), 'stream')
+    repository.append_to_stream(TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000001'), 'stream', -1)
+    repository.append_to_stream(TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000002'), 'stream', 0)
 
-    expect(repository.last_stream_event('stream')).to eq(TestDomainEvent.new(event_id: 'event 2'))
+    expect(repository.last_stream_event('stream')).to eq(TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000002'))
     expect(repository.last_stream_event('other_stream')).to be_nil
   end
 
   it 'reads batch of events from stream forward & backward' do
-    event_ids = (1..10).to_a.map(&:to_s)
-    repository.create(TestDomainEvent.new(event_id: '21'), 'other_stream')
-    event_ids.each do |id|
-      repository.create(TestDomainEvent.new(event_id: id), 'stream')
+    event_ids = ["96c920b1-cdd0-40f4-907c-861b9fff7d02", "56404f79-0ba0-4aa0-8524-dc3436368ca0", "6a54dd21-f9d8-4857-a195-f5588d9e406c", "0e50a9cd-f981-4e39-93d5-697fc7285b98", "d85589bc-b993-41d4-812f-fc631d9185d5", "96bdacda-77dd-4d7d-973d-cbdaa5842855", "94688199-e6b7-4180-bf8e-825b6808e6cc", "68fab040-741e-4bc2-9cca-5b8855b0ca19", "ab60114c-011d-4d58-ab31-7ba65d99975e", "868cac42-3d19-4b39-84e8-cd32d65c2445"]
+    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
+    repository.append_to_stream(TestDomainEvent.new, 'other_stream', -1)
+    events.each.with_index do |event, index|
+      repository.append_to_stream(event, 'stream', index - 1)
     end
-    repository.create(TestDomainEvent.new(event_id: '22'), 'other_stream')
+    repository.append_to_stream(TestDomainEvent.new, 'other_stream', 0)
 
-    expect(repository.read_events_forward('stream', :head, 3)).to eq ['1','2','3'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_events_forward('stream', :head, 100)).to eq event_ids.map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_events_forward('stream', '5', 4)).to eq ['6','7','8','9'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_events_forward('stream', '5', 100)).to eq ['6','7','8','9','10'].map{|x| TestDomainEvent.new(event_id: x)}
+    expect(repository.read_events_forward('stream', :head, 3)).to eq(events.first(3))
+    expect(repository.read_events_forward('stream', :head, 100)).to eq(events)
+    expect(repository.read_events_forward('stream', events[4].event_id, 4)).to eq(events[5..8])
+    expect(repository.read_events_forward('stream', events[4].event_id, 100)).to eq(events[5..9])
 
-    expect(repository.read_events_backward('stream', :head, 3)).to eq ['10','9','8'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_events_backward('stream', :head, 100)).to eq event_ids.reverse.map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_events_backward('stream', '5', 4)).to eq ['4','3','2','1'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_events_backward('stream', '5', 100)).to eq ['4','3','2','1'].map{|x| TestDomainEvent.new(event_id: x)}
+    expect(repository.read_events_backward('stream', :head, 3)).to eq(events.last(3).reverse)
+    expect(repository.read_events_backward('stream', :head, 100)).to eq(events.reverse)
+    expect(repository.read_events_backward('stream', events[4].event_id, 4)).to eq(events.first(4).reverse)
+    expect(repository.read_events_backward('stream', events[4].event_id, 100)).to eq(events.first(4).reverse)
   end
 
 
   it 'reads all stream events forward & backward' do
-    repository.create(TestDomainEvent.new(event_id: '1'), 'stream')
-    repository.create(TestDomainEvent.new(event_id: '2'), 'other_stream')
-    repository.create(TestDomainEvent.new(event_id: '3'), 'stream')
-    repository.create(TestDomainEvent.new(event_id: '4'), 'other_stream')
-    repository.create(TestDomainEvent.new(event_id: '5'), 'other_stream')
+    s1 = 'stream'
+    s2 = 'other_stream'
+    repository.append_to_stream(a = TestDomainEvent.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, -1)
+    repository.append_to_stream(b = TestDomainEvent.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s2, -1)
+    repository.append_to_stream(c = TestDomainEvent.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, 0)
+    repository.append_to_stream(d = TestDomainEvent.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s2, 0)
+    repository.append_to_stream(e = TestDomainEvent.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s2, 1)
 
-    expect(repository.read_stream_events_forward('stream')).to eq ['1','3'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_stream_events_backward('stream')).to eq ['3','1'].map{|x| TestDomainEvent.new(event_id: x)}
+    expect(repository.read_stream_events_forward(s1)).to eq [a,c]
+    expect(repository.read_stream_events_backward(s1)).to eq [c,a]
   end
 
   it 'reads batch of events from all streams forward & backward' do
-    event_ids = (1..10).to_a.map(&:to_s)
-    event_ids.each do |id|
-      repository.create(TestDomainEvent.new(event_id: id), SecureRandom.uuid)
+    event_ids = ["96c920b1-cdd0-40f4-907c-861b9fff7d02", "56404f79-0ba0-4aa0-8524-dc3436368ca0", "6a54dd21-f9d8-4857-a195-f5588d9e406c", "0e50a9cd-f981-4e39-93d5-697fc7285b98", "d85589bc-b993-41d4-812f-fc631d9185d5", "96bdacda-77dd-4d7d-973d-cbdaa5842855", "94688199-e6b7-4180-bf8e-825b6808e6cc", "68fab040-741e-4bc2-9cca-5b8855b0ca19", "ab60114c-011d-4d58-ab31-7ba65d99975e", "868cac42-3d19-4b39-84e8-cd32d65c2445"]
+    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
+    events.each do |ev|
+      repository.append_to_stream(ev, SecureRandom.uuid, -1)
     end
 
-    expect(repository.read_all_streams_forward(:head, 3)).to eq ['1','2','3'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_all_streams_forward(:head, 100)).to eq event_ids.map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_all_streams_forward('5', 4)).to eq ['6','7','8','9'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_all_streams_forward('5', 100)).to eq ['6','7','8','9','10'].map{|x| TestDomainEvent.new(event_id: x)}
+    expect(repository.read_all_streams_forward(:head, 3)).to eq(events.first(3))
+    expect(repository.read_all_streams_forward(:head, 100)).to eq(events)
+    expect(repository.read_all_streams_forward(events[4].event_id, 4)).to eq(events[5..8])
+    expect(repository.read_all_streams_forward(events[4].event_id, 100)).to eq(events[5..9])
+
+    expect(repository.read_all_streams_backward(:head, 3)).to eq(events.last(3).reverse)
+    expect(repository.read_all_streams_backward(:head, 100)).to eq(events.reverse)
+    expect(repository.read_all_streams_backward(events[4].event_id, 4)).to eq(events.first(4).reverse)
+    expect(repository.read_all_streams_backward(events[4].event_id, 100)).to eq(events.first(4).reverse)
+  end
+
+  it 'reads events different uuid object but same content' do
+    event_ids = [
+      "96c920b1-cdd0-40f4-907c-861b9fff7d02",
+      "56404f79-0ba0-4aa0-8524-dc3436368ca0"
+    ]
+    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
+    repository.append_to_stream(events.first, 'stream', -1)
+    repository.append_to_stream(events.last,  'stream',  0)
+
+    expect(repository.read_all_streams_forward("96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
+    expect(repository.read_all_streams_backward("56404f79-0ba0-4aa0-8524-dc3436368ca0", 1)).to eq([events.first])
+
+    expect(repository.read_events_forward('stream', "96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
+    expect(repository.read_events_backward('stream', "56404f79-0ba0-4aa0-8524-dc3436368ca0", 1)).to eq([events.first])
+  end
+
+  it 'does not allow same event twice in a stream' do
+    repository.append_to_stream(
+      TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+      'stream',
+      -1
+    )
+    expect do
+      repository.append_to_stream(
+        TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        'stream',
+        0
+      )
+    end.to raise_error(RubyEventStore::EventDuplicatedInStream)
+  end
+
+  it 'allows appending to GLOBAL_STREAM explicitly' do
+    event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
+    repository.append_to_stream(event, "all", :any)
+
+    expect(repository.read_all_streams_forward(:head, 10)).to eq([event])
+  end
+
+  specify 'GLOBAL_STREAM is unordered, one cannot expect specific version number to work' do
+    expect {
+      event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
+      repository.append_to_stream(event, "all", 42)
+    }.to raise_error(RubyEventStore::InvalidExpectedVersion)
+  end
+
+  specify 'GLOBAL_STREAM is unordered, one cannot expect :none to work' do
+    expect {
+      event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
+      repository.append_to_stream(event, "all", :none)
+    }.to raise_error(RubyEventStore::InvalidExpectedVersion)
+  end
+
+  specify 'GLOBAL_STREAM is unordered, one cannot expect :auto to work' do
+    expect {
+      event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
+      repository.append_to_stream(event, "all", :auto)
+    }.to raise_error(RubyEventStore::InvalidExpectedVersion)
+  end
+
+  specify "only :none, :any, :auto and Integer allowed as expected_version" do
+    [Object.new, SecureRandom.uuid, :foo].each do |invalid_expected_version|
+      expect {
+        repository.append_to_stream(
+          TestDomainEvent.new(event_id: SecureRandom.uuid),
+          'some_stream',
+          invalid_expected_version
+        )
+      }.to raise_error(RubyEventStore::InvalidExpectedVersion)
+    end
+  end
+
+  specify "events not persisted if append failed" do
+    repository.append_to_stream([
+      TestDomainEvent.new(event_id: SecureRandom.uuid),
+    ], 'stream', :none)
 
-    expect(repository.read_all_streams_backward(:head, 3)).to eq ['10','9','8'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_all_streams_backward(:head, 100)).to eq event_ids.reverse.map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_all_streams_backward('5', 4)).to eq ['4','3','2','1'].map{|x| TestDomainEvent.new(event_id: x)}
-    expect(repository.read_all_streams_backward('5', 100)).to eq ['4','3','2','1'].map{|x| TestDomainEvent.new(event_id: x)}
+    expect do
+      repository.append_to_stream([
+        TestDomainEvent.new(
+          event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
+        ),
+      ], 'stream', :none)
+    end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
+    expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
   end
 end

data/lib/ruby_event_store/version.rb

@@ -1,3 +1,3 @@
 module RubyEventStore
-  VERSION = "0.18.2"
+  VERSION = "0.19.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 0.19.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-18 00:00:00.000000000 Z
+date: 2017-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler