ruby_event_store 2.0.0 → 2.3.0

data/lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb

@@ -3,7 +3,7 @@
 module RubyEventStore
   module Mappers
     class InMemoryEncryptionKeyRepository
-      DEFAULT_CIPHER = 'aes-256-gcm'.freeze
+      DEFAULT_CIPHER = "aes-256-gcm".freeze
 
       def initialize
         @keys = {}

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -20,10 +20,6 @@ module RubyEventStore
         end
       end
 
-      def serializer
-        mapper.serializer
-      end
-
       private
 
       attr_reader :instrumentation, :mapper

data/lib/ruby_event_store/mappers/json_mapper.rb

@@ -2,12 +2,14 @@
 
 module RubyEventStore
   module Mappers
-    class JSONMapper < PipelineMapper
+    class JSONMapper < Default
       def initialize(events_class_remapping: {})
-        super(Pipeline.new(
-          Transformation::EventClassRemapper.new(events_class_remapping),
-          Transformation::SymbolizeMetadataKeys.new,
-        ))
+        warn <<~EOW
+          Please replace RubyEventStore::Mappers::JSONMapper with RubyEventStore::Mappers::Default
+
+          They're now identical and the former will be removed in next major release.
+        EOW
+        super
       end
     end
   end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -3,13 +3,10 @@
 module RubyEventStore
   module Mappers
     class Pipeline
-      UNSET = Object.new.freeze
-
-      def initialize(*transformations_, transformations: UNSET, to_domain_event: Transformation::DomainEvent.new)
+      def initialize(*transformations, to_domain_event: Transformation::DomainEvent.new)
         @transformations = [
           to_domain_event,
-          deprecated_transformations(transformations),
-          transformations_,
+          transformations,
         ].flatten.freeze
       end
 
@@ -26,27 +23,6 @@ module RubyEventStore
       end
 
       attr_reader :transformations
-
-      private
-
-      def deprecated_transformations(transformations)
-        case transformations
-        when UNSET
-          []
-        else
-          warn <<~EOW
-            Passing transformations via keyword parameter is deprecated.
-            Please use positional arguments from now on.
-          
-            Was:
-              RubyEventStore::Mappers::Pipeline.new(transformations: transformations)
-          
-            Is now:
-              RubyEventStore::Mappers::Pipeline.new(*transformations)
-          EOW
-          transformations
-        end
-      end
     end
   end
 end

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -15,10 +15,6 @@ module RubyEventStore
         pipeline.load(record)
       end
 
-      def serializer
-        NULL
-      end
-
       private
       attr_reader :pipeline
     end

data/lib/ruby_event_store/mappers/transformation/domain_event.rb

@@ -5,9 +5,9 @@ module RubyEventStore
     module Transformation
       class DomainEvent
         def dump(domain_event)
-          metadata = domain_event.metadata.to_h
+          metadata  = domain_event.metadata.dup.to_h
           timestamp = metadata.delete(:timestamp)
-          valid_at = metadata.delete(:valid_at)
+          valid_at  = metadata.delete(:valid_at)
           Record.new(
             event_id:   domain_event.event_id,
             metadata:   metadata,
@@ -21,11 +21,21 @@ module RubyEventStore
         def load(record)
           Object.const_get(record.event_type).new(
             event_id: record.event_id,
+            data:     record.data,
             metadata: record.metadata.merge(
               timestamp: record.timestamp,
-              valid_at: record.valid_at,
+              valid_at:  record.valid_at,
             ),
+          )
+        rescue NameError
+          Event.new(
+            event_id: record.event_id,
             data:     record.data,
+            metadata: record.metadata.merge(
+              timestamp:  record.timestamp,
+              valid_at:   record.valid_at,
+              event_type: record.event_type,
+            ),
           )
         end
       end

data/lib/ruby_event_store/mappers/transformation/upcast.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class Upcast
+        class RecordUpcaster
+          def initialize(upcast_map)
+            @upcast_map = upcast_map
+          end
+
+          def call(record)
+            identity   = lambda { |r| r }
+            new_record = @upcast_map.fetch(record.event_type, identity)[record]
+            if new_record.equal?(record)
+              record
+            else
+              call(new_record)
+            end
+          end
+        end
+
+        def initialize(upcast_map)
+          @record_upcaster = RecordUpcaster.new(upcast_map)
+        end
+
+        def dump(record)
+          record
+        end
+
+        def load(record)
+          @record_upcaster.call(record)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/metadata.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'time'
-require 'forwardable'
+require "date"
+require "time"
+require "forwardable"
 
 module RubyEventStore
   class Metadata

data/lib/ruby_event_store/projection.rb

@@ -72,14 +72,14 @@ module RubyEventStore
     end
 
     def reduce_from_streams(event_store, start, count)
-      raise ArgumentError.new('Start must be an array with event ids') unless valid_starting_point?(start)
+      raise ArgumentError.new("Start must be an array with event ids") unless valid_starting_point?(start)
       streams.zip(start_events(start)).reduce(initial_state) do |state, (stream_name, start_event_id)|
         read_scope(event_store, stream_name, count, start_event_id).reduce(state, &method(:transition))
       end
     end
 
     def reduce_from_all_streams(event_store, start, count)
-      raise ArgumentError.new('Start must be valid event id') unless valid_starting_point?(start)
+      raise ArgumentError.new("Start must be valid event id") unless valid_starting_point?(start)
       read_scope(event_store, nil, count, start).reduce(initial_state, &method(:transition))
     end
 

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -1,5 +1,5 @@
 RSpec.shared_examples :broker do |broker_klass|
-  let(:event) { instance_double(::RubyEventStore::Event, event_type: 'EventType') }
+  let(:event) { instance_double(::RubyEventStore::Event, event_type: "EventType") }
   let(:record) { instance_double(::RubyEventStore::Record)  }
   let(:handler) { HandlerClass.new }
   let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
@@ -7,38 +7,38 @@ RSpec.shared_examples :broker do |broker_klass|
   let(:broker) { broker_klass.new(subscriptions: subscriptions, dispatcher: dispatcher) }
 
   specify "no dispatch when no subscriptions" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([])
     expect(dispatcher).not_to receive(:call)
     broker.call(event, record)
   end
 
   specify "calls subscription" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([handler])
     expect(dispatcher).to receive(:call).with(handler, event, record)
     broker.call(event, record)
   end
 
   specify "calls subscribed class" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([HandlerClass])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([HandlerClass])
     expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
     broker.call(event, record)
   end
 
   specify "calls all subscriptions" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler, HandlerClass])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([handler, HandlerClass])
     expect(dispatcher).to receive(:call).with(handler, event, record)
     expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
     broker.call(event, record)
   end
 
-  specify 'raise error when no subscriber' do
+  specify "raise error when no subscriber" do
     expect { broker.add_subscription(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist, "subscriber must be first argument or block")
     expect { broker.add_global_subscription(nil)}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
     expect { broker.add_thread_subscription(nil, []).call}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
     expect { broker.add_thread_global_subscription(nil).call}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
   end
 
-  specify 'raise error when wrong subscriber' do
+  specify "raise error when wrong subscriber" do
     allow(dispatcher).to receive(:verify).and_return(false)
     expect do
       broker.add_subscription(HandlerClass, [])
@@ -56,8 +56,8 @@ RSpec.shared_examples :broker do |broker_klass|
 
   specify "verify and add - local subscriptions" do
     expect(dispatcher).to receive(:verify).with(handler).and_return(true)
-    expect(subscriptions).to receive(:add_subscription).with(handler, ['EventType'])
-    broker.add_subscription(handler, ['EventType'])
+    expect(subscriptions).to receive(:add_subscription).with(handler, ["EventType"])
+    broker.add_subscription(handler, ["EventType"])
   end
 
   specify "verify and add - global subscriptions" do
@@ -68,8 +68,8 @@ RSpec.shared_examples :broker do |broker_klass|
 
   specify "verify and add - thread local subscriptions" do
     expect(dispatcher).to receive(:verify).with(handler).and_return(true)
-    expect(subscriptions).to receive(:add_thread_subscription).with(handler, ['EventType'])
-    broker.add_thread_subscription(handler, ['EventType'])
+    expect(subscriptions).to receive(:add_thread_subscription).with(handler, ["EventType"])
+    broker.add_thread_subscription(handler, ["EventType"])
   end
 
   specify "verify and add - thread global subscriptions" do

data/lib/ruby_event_store/spec/event_lint.rb

@@ -1,36 +1,36 @@
 RSpec.shared_examples :event do |event_class, data, metadata|
-  it 'allows initialization' do
+  it "allows initialization" do
     expect {
       event_class.new(event_id: Object.new, data: data || Object.new, metadata: metadata || {})
     }.not_to raise_error
   end
 
-  it 'provides event_id as string' do
+  it "provides event_id as string" do
     event = event_class.new
     expect(event.event_id).to be_an_instance_of(String)
-    expect(event.event_id).not_to eq ''
+    expect(event.event_id).not_to eq ""
     expect(event.event_id).not_to eq nil
   end
 
-  it 'provides message_id as string' do
+  it "provides message_id as string" do
     event = event_class.new
     expect(event.message_id).to be_an_instance_of(String)
   end
 
-  it 'message_id is the same as event_id' do
+  it "message_id is the same as event_id" do
     event = event_class.new
     expect(event.event_id).to eq event.message_id
   end
 
-  it 'exposes given event_id to string' do
+  it "exposes given event_id to string" do
     event = event_class.new(event_id: 1234567890)
-    expect(event.event_id).to eq '1234567890'
+    expect(event.event_id).to eq "1234567890"
   end
 
-  it 'provides event type as string' do
+  it "provides event type as string" do
     event = event_class.new
     expect(event.event_type).to be_an_instance_of(String)
-    expect(event.event_type).not_to eq ''
+    expect(event.event_type).not_to eq ""
     expect(event.event_type).not_to eq nil
   end
 

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -5,7 +5,7 @@ module RubyEventStore
       event_id:   SecureRandom.uuid,
       data:       {},
       metadata:   {},
-      event_type: 'SRecordTestEvent',
+      event_type: "SRecordTestEvent",
       timestamp:  Time.new.utc,
       valid_at:   nil
     )
@@ -26,50 +26,17 @@ module RubyEventStore
   Type2 = Class.new(RubyEventStore::Event)
   # @private
   Type3 = Class.new(RubyEventStore::Event)
-
-  # @private
-  class EventRepositoryHelper
-    def supports_concurrent_auto?
-      true
-    end
-
-    def supports_concurrent_any?
-      true
-    end
-
-    def supports_binary?
-      true
-    end
-
-    def supports_upsert?
-      true
-    end
-
-    def has_connection_pooling?
-      false
-    end
-
-    def connection_pool_size
-    end
-
-    def cleanup_concurrency_test
-    end
-
-    def rescuable_concurrency_test_errors
-      []
-    end
-  end
 end
 
 module RubyEventStore
-  ::RSpec.shared_examples :event_repository do
-    let(:helper)        { EventRepositoryHelper.new }
+  ::RSpec.shared_examples :event_repository do |mk_repository, helper|
+    let(:repository)    { mk_repository.call }
     let(:specification) { Specification.new(SpecificationReader.new(repository, Mappers::NullMapper.new)) }
     let(:global_stream) { Stream.new(GLOBAL_STREAM) }
     let(:stream)        { Stream.new(SecureRandom.uuid) }
-    let(:stream_flow)   { Stream.new('flow') }
-    let(:stream_other)  { Stream.new('other') }
-    let(:stream_test)   { Stream.new('test') }
+    let(:stream_flow)   { Stream.new("flow") }
+    let(:stream_other)  { Stream.new("other") }
+    let(:stream_test)   { Stream.new("test") }
     let(:version_none)  { ExpectedVersion.none }
     let(:version_auto)  { ExpectedVersion.auto }
     let(:version_any)   { ExpectedVersion.any }
@@ -78,12 +45,12 @@ module RubyEventStore
     let(:version_2)     { ExpectedVersion.new(2) }
     let(:version_3)     { ExpectedVersion.new(3) }
 
-    def verify_conncurency_assumptions
+    def verify_conncurency_assumptions(helper)
       return unless helper.has_connection_pooling?
-      expect(helper.connection_pool_size).to eq(5)
+      expect(helper.connection_pool_size).to eq(5), "expected connection pool of size 5, got #{helper.connection_pool_size}"
     end
 
-    def read_events(scope, stream = nil, from: nil, to: nil, count: nil)
+    def read_events(repository, scope, stream = nil, from: nil, to: nil, count: nil)
       scope = scope.stream(stream.name) if stream
       scope = scope.from(from) if from
       scope = scope.to(to) if to
@@ -91,44 +58,44 @@ module RubyEventStore
       repository.read(scope.result).to_a
     end
 
-    def read_events_forward(_repository, stream = nil, from: nil, to: nil, count: nil)
-      read_events(specification, stream, from: from, to: to, count: count)
+    def read_events_forward(repository, stream = nil, from: nil, to: nil, count: nil)
+      read_events(repository, specification, stream, from: from, to: to, count: count)
     end
 
-    def read_events_backward(_repository, stream = nil, from: nil, to: nil, count: nil)
-      read_events(specification.backward, stream, from: from, to: to, count: count)
+    def read_events_backward(repository, stream = nil, from: nil, to: nil, count: nil)
+      read_events(repository, specification.backward, stream, from: from, to: to, count: count)
     end
 
-    it 'just created is empty' do
+    it "just created is empty" do
       expect(read_events_forward(repository)).to be_empty
     end
 
-    specify 'append_to_stream returns self' do
+    specify "append_to_stream returns self" do
       repository
-        .append_to_stream(event = SRecord.new, stream, version_none)
-        .append_to_stream(event = SRecord.new, stream, version_0)
+        .append_to_stream([event = SRecord.new], stream, version_none)
+        .append_to_stream([event = SRecord.new], stream, version_0)
     end
 
-    specify 'link_to_stream returns self' do
+    specify "link_to_stream returns self" do
       event0 = SRecord.new
       event1 = SRecord.new
       repository
         .append_to_stream([event0, event1], stream, version_none)
-        .link_to_stream(event0.event_id, stream_flow, version_none)
-        .link_to_stream(event1.event_id, stream_flow, version_0)
+        .link_to_stream([event0.event_id], stream_flow, version_none)
+        .link_to_stream([event1.event_id], stream_flow, version_0)
     end
 
-    specify 'adds an initial event to a new stream' do
-      repository.append_to_stream(event = SRecord.new, stream, version_none)
+    specify "adds an initial event to a new stream" do
+      repository.append_to_stream([event = SRecord.new], stream, version_none)
       expect(read_events_forward(repository).first).to eq(event)
       expect(read_events_forward(repository, stream).first).to eq(event)
       expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
-    specify 'links an initial event to a new stream' do
+    specify "links an initial event to a new stream" do
       repository
-        .append_to_stream(event = SRecord.new, stream, version_none)
-        .link_to_stream(event.event_id, stream_flow, version_none)
+        .append_to_stream([event = SRecord.new], stream, version_none)
+        .link_to_stream([event.event_id], stream_flow, version_none)
 
       expect(read_events_forward(repository, count: 1).first).to eq(event)
       expect(read_events_forward(repository, stream).first).to eq(event)
@@ -136,7 +103,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
-    specify 'adds multiple initial events to a new stream' do
+    specify "adds multiple initial events to a new stream" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -145,7 +112,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1])
     end
 
-    specify 'links multiple initial events to a new stream' do
+    specify "links multiple initial events to a new stream" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -157,7 +124,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow)).to eq([event0, event1])
     end
 
-    specify 'correct expected version on second write' do
+    specify "correct expected version on second write" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -170,7 +137,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
     end
 
-    specify 'correct expected version on second link' do
+    specify "correct expected version on second link" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -185,7 +152,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow)).to eq([event2, event3, event0, event1])
     end
 
-    specify 'incorrect expected version on second write' do
+    specify "incorrect expected version on second write" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -201,7 +168,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1])
     end
 
-    specify 'incorrect expected version on second link' do
+    specify "incorrect expected version on second link" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -221,7 +188,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1])
     end
 
-    specify ':none on first and subsequent write' do
+    specify ":none on first and subsequent write" do
       repository.append_to_stream([
         eventA = SRecord.new,
       ], stream, version_none)
@@ -234,7 +201,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([eventA])
     end
 
-    specify ':none on first and subsequent link' do
+    specify ":none on first and subsequent link" do
       repository.append_to_stream([
         eventA = SRecord.new,
         eventB = SRecord.new,
@@ -249,7 +216,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow)).to eq([eventA])
     end
 
-    specify ':any allows stream with best-effort order and no guarantee' do
+    specify ":any allows stream with best-effort order and no guarantee" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -262,7 +229,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream).to_set).to eq(Set.new([event0, event1, event2, event3]))
     end
 
-    specify ':any allows linking in stream with best-effort order and no guarantee' do
+    specify ":any allows linking in stream with best-effort order and no guarantee" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -281,7 +248,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow).to_set).to eq(Set.new([event0, event1, event2, event3]))
     end
 
-    specify ':auto queries for last position in given stream' do
+    specify ":auto queries for last position in given stream" do
       repository.append_to_stream([
         eventA = SRecord.new,
         eventB = SRecord.new,
@@ -297,7 +264,7 @@ module RubyEventStore
       ], stream, version_1)
     end
 
-    specify ':auto queries for last position in given stream when linking' do
+    specify ":auto queries for last position in given stream when linking" do
       repository.append_to_stream([
         eventA = SRecord.new,
         eventB = SRecord.new,
@@ -314,7 +281,7 @@ module RubyEventStore
       ], stream, version_1)
     end
 
-    specify ':auto starts from 0' do
+    specify ":auto starts from 0" do
       repository.append_to_stream([
         event0 = SRecord.new,
       ], stream, version_auto)
@@ -325,7 +292,7 @@ module RubyEventStore
       end.to raise_error(WrongExpectedEventVersion)
     end
 
-    specify ':auto linking starts from 0' do
+    specify ":auto linking starts from 0" do
       repository.append_to_stream([
         event0 = SRecord.new,
       ], stream_other, version_auto)
@@ -339,7 +306,7 @@ module RubyEventStore
       end.to raise_error(WrongExpectedEventVersion)
     end
 
-    specify ':auto queries for last position and follows in incremental way' do
+    specify ":auto queries for last position and follows in incremental way" do
       # It is expected that there is higher level lock
       # So this query is safe from race conditions
       repository.append_to_stream([
@@ -357,7 +324,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
     end
 
-    specify ':auto queries for last position and follows in incremental way when linking' do
+    specify ":auto queries for last position and follows in incremental way when linking" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -377,7 +344,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow)).to eq([event0, event1, event2, event3])
     end
 
-    specify ':auto is compatible with manual expectation' do
+    specify ":auto is compatible with manual expectation" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -390,7 +357,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
     end
 
-    specify ':auto is compatible with manual expectation when linking' do
+    specify ":auto is compatible with manual expectation when linking" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -405,7 +372,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow)).to eq([event0, event1,])
     end
 
-    specify 'manual is compatible with auto expectation' do
+    specify "manual is compatible with auto expectation" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -418,7 +385,7 @@ module RubyEventStore
       expect(read_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
     end
 
-    specify 'manual is compatible with auto expectation when linking' do
+    specify "manual is compatible with auto expectation when linking" do
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -433,9 +400,9 @@ module RubyEventStore
       expect(read_events_forward(repository, stream_flow)).to eq([event0, event1])
     end
 
-    specify 'unlimited concurrency for :any - everything should succeed', timeout: 10, mutant: false do
+    specify "unlimited concurrency for :any - everything should succeed", timeout: 10, mutant: false do
       skip unless helper.supports_concurrent_any?
-      verify_conncurency_assumptions
+      verify_conncurency_assumptions(helper)
       begin
         concurrency_level = 4
         fail_occurred     = false
@@ -466,14 +433,12 @@ module RubyEventStore
           ev.event_id.start_with?("0-")
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
-      ensure
-        helper.cleanup_concurrency_test
       end
     end
 
-    specify 'unlimited concurrency for :any - everything should succeed when linking', timeout: 10, mutant: false do
+    specify "unlimited concurrency for :any - everything should succeed when linking", timeout: 10, mutant: false do
       skip unless helper.supports_concurrent_any?
-      verify_conncurency_assumptions
+      verify_conncurency_assumptions(helper)
       begin
         concurrency_level = 4
         fail_occurred     = false
@@ -494,7 +459,7 @@ module RubyEventStore
             begin
               100.times do |j|
                 eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.link_to_stream(eid, stream_flow, version_any)
+                repository.link_to_stream([eid], stream_flow, version_any)
               end
             rescue WrongExpectedEventVersion
               fail_occurred = true
@@ -511,14 +476,12 @@ module RubyEventStore
           ev.event_id.start_with?("0-")
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
-      ensure
-        helper.cleanup_concurrency_test
       end
     end
 
-    specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered', mutant: false do
+    specify "limited concurrency for :auto - some operations will fail without outside lock, stream is ordered", mutant: false do
       skip unless helper.supports_concurrent_auto?
-      verify_conncurency_assumptions
+      verify_conncurency_assumptions(helper)
       begin
         concurrency_level = 4
 
@@ -535,7 +498,7 @@ module RubyEventStore
                   SRecord.new(event_id: eid),
                 ], stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion, *helper.rescuable_concurrency_test_errors
+              rescue WrongExpectedEventVersion
                 fail_occurred +=1
               end
             end
@@ -551,15 +514,15 @@ module RubyEventStore
           ev.event_id.start_with?("0-")
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
-        additional_limited_concurrency_for_auto_check if defined? additional_limited_concurrency_for_auto_check
-      ensure
-        helper.cleanup_concurrency_test
+
+        positions = repository.read(specification.stream(stream.name).result).map { |r| repository.position_in_stream(r.event_id, stream) }
+        expect(positions).to eq((0...positions.size).to_a)
       end
     end
 
-    specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered', mutant: false do
+    specify "limited concurrency for :auto - some operations will fail without outside lock, stream is ordered", mutant: false do
       skip unless helper.supports_concurrent_auto?
-      verify_conncurency_assumptions
+      verify_conncurency_assumptions(helper)
       begin
         concurrency_level = 4
 
@@ -581,9 +544,9 @@ module RubyEventStore
             100.times do |j|
               begin
                 eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.link_to_stream(eid, stream, version_auto)
+                repository.link_to_stream([eid], stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion, *helper.rescuable_concurrency_test_errors
+              rescue WrongExpectedEventVersion
                 fail_occurred +=1
               end
             end
@@ -599,51 +562,51 @@ module RubyEventStore
           ev.event_id.start_with?("0-")
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
-        additional_limited_concurrency_for_auto_check if defined? additional_limited_concurrency_for_auto_check
-      ensure
-        helper.cleanup_concurrency_test
+
+        positions = repository.read(specification.stream(stream.name).result).map { |r| repository.position_in_stream(r.event_id, stream) }
+        expect(positions).to eq((0...positions.size).to_a)
       end
     end
 
-    it 'appended event is stored in given stream' do
+    it "appended event is stored in given stream" do
       expected_event = SRecord.new
-      repository.append_to_stream(expected_event, stream, version_any)
+      repository.append_to_stream([expected_event], stream, version_any)
       expect(read_events_forward(repository, count: 1).first).to eq(expected_event)
       expect(read_events_forward(repository, stream).first).to eq(expected_event)
       expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
-    it 'data attributes are retrieved' do
+    it "data attributes are retrieved" do
       event = SRecord.new(data: { "order_id" => 3 })
-      repository.append_to_stream(event, stream, version_any)
+      repository.append_to_stream([event], stream, version_any)
       retrieved_event = read_events_forward(repository, count: 1).first
       expect(retrieved_event.data).to eq({ "order_id" => 3 })
     end
 
-    it 'metadata attributes are retrieved' do
+    it "metadata attributes are retrieved" do
       event = SRecord.new(metadata: { "request_id" => 3 })
-      repository.append_to_stream(event, stream, version_any)
+      repository.append_to_stream([event], stream, version_any)
       retrieved_event = read_events_forward(repository, count: 1).first
       expect(retrieved_event.metadata).to eq({ "request_id" => 3 })
     end
 
-    it 'data and metadata attributes are retrieved when linking' do
+    it "data and metadata attributes are retrieved when linking" do
       event = SRecord.new(
         data: { "order_id" => 3 },
         metadata: { "request_id" => 4},
       )
       repository
-        .append_to_stream(event, stream, version_any)
-        .link_to_stream(event.event_id, stream_flow, version_any)
+        .append_to_stream([event], stream, version_any)
+        .link_to_stream([event.event_id], stream_flow, version_any)
       retrieved_event = read_events_forward(repository, stream_flow).first
       expect(retrieved_event.metadata).to eq({ "request_id" => 4 })
       expect(retrieved_event.data).to eq({ "order_id" => 3 })
       expect(event).to eq(retrieved_event)
     end
 
-    it 'does not have deleted streams' do
-      repository.append_to_stream(e1 = SRecord.new, stream, version_none)
-      repository.append_to_stream(e2 = SRecord.new, stream_other, version_none)
+    it "does not have deleted streams" do
+      repository.append_to_stream([e1 = SRecord.new], stream, version_none)
+      repository.append_to_stream([e2 = SRecord.new], stream_other, version_none)
 
       repository.delete_stream(stream)
       expect(read_events_forward(repository, stream)).to be_empty
@@ -651,41 +614,108 @@ module RubyEventStore
       expect(read_events_forward(repository, count: 10)).to eq([e1,e2])
     end
 
-    it 'does not have deleted streams with linked events' do
+    it "does not have deleted streams with linked events" do
       repository
-        .append_to_stream(e1 = SRecord.new, stream, version_none)
-        .link_to_stream(e1.event_id, stream_flow, version_none)
+        .append_to_stream([e1 = SRecord.new], stream, version_none)
+        .link_to_stream([e1.event_id], stream_flow, version_none)
 
       repository.delete_stream(stream_flow)
       expect(read_events_forward(repository, stream_flow)).to be_empty
       expect(read_events_forward(repository, count: 10)).to eq([e1])
     end
 
-    it 'has or has not domain event' do
-      just_an_id = 'd5c134c2-db65-4e87-b6ea-d196f8f1a292'
-      repository.append_to_stream(SRecord.new(event_id: just_an_id), stream, version_none)
+    it "has or has not domain event" do
+      just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
+      repository.append_to_stream([SRecord.new(event_id: just_an_id)], stream, version_none)
 
       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
+      expect(repository.has_event?("any other id")).to be false
 
       repository.delete_stream(stream)
       expect(repository.has_event?(just_an_id)).to be_truthy
       expect(repository.has_event?(just_an_id.clone)).to be_truthy
     end
 
-    it 'knows last event in stream' do
-      repository.append_to_stream(a =SRecord.new(event_id: '00000000-0000-0000-0000-000000000001'), stream, version_none)
-      repository.append_to_stream(b = SRecord.new(event_id: '00000000-0000-0000-0000-000000000002'), stream, version_0)
+    it "#position_in_stream happy path" do
+      skip unless helper.supports_position_queries?
+      repository.append_to_stream([
+        event0 = SRecord.new,
+        event1 = SRecord.new
+      ], stream, version_auto)
+
+      expect(repository.position_in_stream(event0.event_id, stream)).to eq(0)
+      expect(repository.position_in_stream(event1.event_id, stream)).to eq(1)
+    end
+
+    it "#position_in_stream happy path with linking" do
+      skip unless helper.supports_position_queries?
+      repository.append_to_stream([
+        event0 = SRecord.new,
+        event1 = SRecord.new
+      ], stream, version_auto)
+      repository.link_to_stream([
+        event1.event_id,
+        event0.event_id,
+      ], stream_other, version_auto)
+
+      expect(repository.position_in_stream(event0.event_id, stream)).to eq(0)
+      expect(repository.position_in_stream(event1.event_id, stream)).to eq(1)
+      expect(repository.position_in_stream(event1.event_id, stream_other)).to eq(0)
+      expect(repository.position_in_stream(event0.event_id, stream_other)).to eq(1)
+    end
+
+    it "#position_in_stream when event is not in the stream" do
+      skip unless helper.supports_position_queries?
+      just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
+
+      expect do
+        repository.position_in_stream(just_an_id, stream)
+      end.to raise_error(EventNotFoundInStream)
+    end
+
+    it "#position_in_stream when event is published without position" do
+      skip unless helper.supports_position_queries?
+      repository.append_to_stream([event0 = SRecord.new], stream, version_any)
+
+      expect(repository.position_in_stream(event0.event_id, stream)).to eq(nil)
+    end
+
+    it "#global_position happy path" do
+      skip unless helper.supports_position_queries?
+      repository.append_to_stream([
+        event0 = SRecord.new,
+        event1 = SRecord.new
+      ], stream, version_any)
+
+      expect(repository.global_position(event0.event_id)).to eq(0)
+      expect(repository.global_position(event1.event_id)).to eq(1)
+    end
+
+    it "#global_position for not existing event" do
+      skip unless helper.supports_position_queries?
+      just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
+
+      expect do
+        repository.global_position(just_an_id)
+      end.to raise_error do |err|
+        expect(err).to be_a(EventNotFound)
+        expect(err.event_id).to eq(just_an_id)
+      end
+    end
+
+    it "knows last event in stream" do
+      repository.append_to_stream([a =SRecord.new(event_id: "00000000-0000-0000-0000-000000000001")], stream, version_none)
+      repository.append_to_stream([b = SRecord.new(event_id: "00000000-0000-0000-0000-000000000002")], stream, version_0)
 
       expect(repository.last_stream_event(stream)).to eq(b)
       expect(repository.last_stream_event(stream_other)).to be_nil
     end
 
-    it 'knows last event in stream when linked' do
+    it "knows last event in stream when linked" do
       repository.append_to_stream([
-          e0 = SRecord.new(event_id: '00000000-0000-0000-0000-000000000001'),
-          e1 = SRecord.new(event_id: '00000000-0000-0000-0000-000000000002'),
+          e0 = SRecord.new(event_id: "00000000-0000-0000-0000-000000000001"),
+          e1 = SRecord.new(event_id: "00000000-0000-0000-0000-000000000002"),
         ],
         stream,
         version_none
@@ -693,7 +723,7 @@ module RubyEventStore
       expect(repository.last_stream_event(stream_flow)).to eq(e0)
     end
 
-    it 'reads batch of events from stream forward & backward' do
+    it "reads batch of events from stream forward & backward" do
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
@@ -706,11 +736,11 @@ module RubyEventStore
         ab60114c-011d-4d58-ab31-7ba65d99975e
         868cac42-3d19-4b39-84e8-cd32d65c2445
       ].map { |id| SRecord.new(event_id: id) }
-      repository.append_to_stream(SRecord.new, stream_other, version_none)
+      repository.append_to_stream([SRecord.new], stream_other, version_none)
       events.each.with_index do |event, index|
-        repository.append_to_stream(event, stream, ExpectedVersion.new(index - 1))
+        repository.append_to_stream([event], stream, ExpectedVersion.new(index - 1))
       end
-      repository.append_to_stream(SRecord.new, stream_other, version_0)
+      repository.append_to_stream([SRecord.new], stream_other, version_0)
 
       expect(read_events_forward(repository, stream, count: 3)).to eq(events.first(3))
       expect(read_events_forward(repository, stream, count: 100)).to eq(events)
@@ -728,7 +758,7 @@ module RubyEventStore
       expect(read_events_backward(repository, stream, to: events[4].event_id, count: 100)).to eq(events.last(5).reverse)
     end
 
-    it 'reads batch of linked events from stream forward & backward' do
+    it "reads batch of linked events from stream forward & backward" do
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
@@ -741,13 +771,13 @@ module RubyEventStore
         ab60114c-011d-4d58-ab31-7ba65d99975e
         868cac42-3d19-4b39-84e8-cd32d65c2445
       ].map { |id| SRecord.new(event_id: id) }
-      repository.append_to_stream(SRecord.new, stream_other, version_none)
+      repository.append_to_stream([SRecord.new], stream_other, version_none)
       events.each.with_index do |event, index|
         repository
-          .append_to_stream(event, stream, ExpectedVersion.new(index - 1))
-          .link_to_stream(event.event_id, stream_flow, ExpectedVersion.new(index - 1))
+          .append_to_stream([event], stream, ExpectedVersion.new(index - 1))
+          .link_to_stream([event.event_id], stream_flow, ExpectedVersion.new(index - 1))
       end
-      repository.append_to_stream(SRecord.new, stream_other, version_0)
+      repository.append_to_stream([SRecord.new], stream_other, version_0)
 
       expect(read_events_forward(repository, stream_flow, count: 3)).to eq(events.first(3))
       expect(read_events_forward(repository, stream_flow, count: 100)).to eq(events)
@@ -764,39 +794,39 @@ module RubyEventStore
       expect(read_events_backward(repository, stream_flow, to: events[4].event_id, count: 100)).to eq(events[5..9].reverse)
     end
 
-    it 'reads all stream events forward & backward' do
+    it "reads all stream events forward & backward" do
       s1 = stream
       s2 = stream_other
       repository
-        .append_to_stream(a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, version_none)
-        .append_to_stream(b = SRecord.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s2, version_none)
-        .append_to_stream(c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, version_0)
-        .append_to_stream(d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s2, version_0)
-        .append_to_stream(e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s2, version_1)
+        .append_to_stream([a = SRecord.new(event_id: "7010d298-ab69-4bb1-9251-f3466b5d1282")], s1, version_none)
+        .append_to_stream([b = SRecord.new(event_id: "34f88aca-aaba-4ca0-9256-8017b47528c5")], s2, version_none)
+        .append_to_stream([c = SRecord.new(event_id: "8e61c864-ceae-4684-8726-97c34eb8fc4f")], s1, version_0)
+        .append_to_stream([d = SRecord.new(event_id: "30963ed9-6349-450b-ac9b-8ea50115b3bd")], s2, version_0)
+        .append_to_stream([e = SRecord.new(event_id: "5bdc58b7-e8a7-4621-afd6-ccb828d72457")], s2, version_1)
 
       expect(read_events_forward(repository, s1)).to eq [a,c]
       expect(read_events_backward(repository, s1)).to eq [c,a]
     end
 
-    it 'reads all stream linked events forward & backward' do
+    it "reads all stream linked events forward & backward" do
       s1, fs1, fs2 = stream, stream_flow, stream_other
       repository
-        .append_to_stream(a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, version_none)
-        .append_to_stream(b = SRecord.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s1, version_0)
-        .append_to_stream(c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, version_1)
-        .append_to_stream(d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s1, version_2)
-        .append_to_stream(e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s1, version_3)
-        .link_to_stream('7010d298-ab69-4bb1-9251-f3466b5d1282', fs1, version_none)
-        .link_to_stream('34f88aca-aaba-4ca0-9256-8017b47528c5', fs2, version_none)
-        .link_to_stream('8e61c864-ceae-4684-8726-97c34eb8fc4f', fs1, version_0)
-        .link_to_stream('30963ed9-6349-450b-ac9b-8ea50115b3bd', fs2, version_0)
-        .link_to_stream('5bdc58b7-e8a7-4621-afd6-ccb828d72457', fs2, version_1)
+        .append_to_stream([a = SRecord.new(event_id: "7010d298-ab69-4bb1-9251-f3466b5d1282")], s1, version_none)
+        .append_to_stream([b = SRecord.new(event_id: "34f88aca-aaba-4ca0-9256-8017b47528c5")], s1, version_0)
+        .append_to_stream([c = SRecord.new(event_id: "8e61c864-ceae-4684-8726-97c34eb8fc4f")], s1, version_1)
+        .append_to_stream([d = SRecord.new(event_id: "30963ed9-6349-450b-ac9b-8ea50115b3bd")], s1, version_2)
+        .append_to_stream([e = SRecord.new(event_id: "5bdc58b7-e8a7-4621-afd6-ccb828d72457")], s1, version_3)
+        .link_to_stream(["7010d298-ab69-4bb1-9251-f3466b5d1282"], fs1, version_none)
+        .link_to_stream(["34f88aca-aaba-4ca0-9256-8017b47528c5"], fs2, version_none)
+        .link_to_stream(["8e61c864-ceae-4684-8726-97c34eb8fc4f"], fs1, version_0)
+        .link_to_stream(["30963ed9-6349-450b-ac9b-8ea50115b3bd"], fs2, version_0)
+        .link_to_stream(["5bdc58b7-e8a7-4621-afd6-ccb828d72457"], fs2, version_1)
 
       expect(read_events_forward(repository, fs1)).to eq [a,c]
       expect(read_events_backward(repository, fs1)).to eq [c,a]
     end
 
-    it 'reads batch of events from all streams forward & backward' do
+    it "reads batch of events from all streams forward & backward" do
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
@@ -810,7 +840,7 @@ module RubyEventStore
         868cac42-3d19-4b39-84e8-cd32d65c2445
       ].map { |id| SRecord.new(event_id: id) }
       events.each do |ev|
-        repository.append_to_stream(ev, Stream.new(SecureRandom.uuid), version_none)
+        repository.append_to_stream([ev], Stream.new(SecureRandom.uuid), version_none)
       end
 
       expect(read_events_forward(repository, count: 3)).to eq(events.first(3))
@@ -828,7 +858,7 @@ module RubyEventStore
       expect(read_events_backward(repository, to: events[4].event_id, count: 100)).to eq(events.last(5).reverse)
     end
 
-    it 'linked events do not affect reading from all streams - no duplicates' do
+    it "linked events do not affect reading from all streams - no duplicates" do
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
@@ -843,8 +873,8 @@ module RubyEventStore
       ].map { |id| SRecord.new(event_id: id) }
       events.each do |ev|
         repository
-          .append_to_stream(ev, Stream.new(SecureRandom.uuid), version_none)
-          .link_to_stream(ev.event_id, Stream.new(SecureRandom.uuid), version_none)
+          .append_to_stream([ev], Stream.new(SecureRandom.uuid), version_none)
+          .link_to_stream([ev.event_id], Stream.new(SecureRandom.uuid), version_none)
       end
 
       expect(read_events_forward(repository, count: 3)).to eq(events.first(3))
@@ -862,13 +892,13 @@ module RubyEventStore
       expect(read_events_backward(repository, to: events[4].event_id, count: 100)).to eq(events.last(5).reverse)
     end
 
-    it 'reads events different uuid object but same content' do
+    it "reads events different uuid object but same content" do
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
       ].map{|id| SRecord.new(event_id: id) }
-      repository.append_to_stream(events.first, stream, version_none)
-      repository.append_to_stream(events.last,  stream,  version_0)
+      repository.append_to_stream([events.first], stream, version_none)
+      repository.append_to_stream([events.last],  stream,  version_0)
 
       expect(read_events_forward(repository, from: "96c920b1-cdd0-40f4-907c-861b9fff7d02")).to eq([events.last])
       expect(read_events_backward(repository, from: "56404f79-0ba0-4aa0-8524-dc3436368ca0")).to eq([events.first])
@@ -881,84 +911,82 @@ module RubyEventStore
       expect(read_events_backward(repository, stream, to: "96c920b1-cdd0-40f4-907c-861b9fff7d02", count: 1)).to eq([events.last])
     end
 
-    it 'does not allow same event twice in a stream' do
+    it "does not allow same event twice in a stream" do
       repository.append_to_stream(
-        SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
         stream,
         version_none
       )
       expect do
         repository.append_to_stream(
-          SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+          [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
           stream,
           version_0
         )
       end.to raise_error(EventDuplicatedInStream)
     end
 
-    it 'does not allow same event twice' do
+    it "does not allow same event twice" do
       repository.append_to_stream(
-        SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
         stream,
         version_none
       )
       expect do
         repository.append_to_stream(
-          SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+          [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
           stream_other,
           version_none
         )
       end.to raise_error(EventDuplicatedInStream)
     end
 
-    it 'does not allow linking same event twice in a stream' do
-      repository.append_to_stream([
-          SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-        ], stream,
+    it "does not allow linking same event twice in a stream" do
+      repository.append_to_stream(
+        [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
+        stream,
         version_none
-      ).link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", stream_flow, version_none)
+      ).link_to_stream(["a1b49edb-7636-416f-874a-88f94b859bef"], stream_flow, version_none)
       expect do
-        repository.link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", stream_flow, version_0)
+        repository.link_to_stream(["a1b49edb-7636-416f-874a-88f94b859bef"], stream_flow, version_0)
       end.to raise_error(EventDuplicatedInStream)
     end
 
-    it 'allows appending to GLOBAL_STREAM explicitly' do
+    it "allows appending to GLOBAL_STREAM explicitly" do
       event = SRecord.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-      repository.append_to_stream(event, global_stream, version_any)
+      repository.append_to_stream([event], global_stream, version_any)
 
       expect(read_events_forward(repository, count: 10)).to eq([event])
     end
 
     specify "events not persisted if append failed" do
-      repository.append_to_stream([
-        SRecord.new,
-      ], stream, version_none)
+      repository.append_to_stream([SRecord.new], stream, version_none)
 
       expect do
-        repository.append_to_stream([
-          SRecord.new(
-            event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
-          ),
-        ], stream, version_none)
+        repository.append_to_stream(
+          [SRecord.new(event_id: "9bedf448-e4d0-41a3-a8cd-f94aec7aa763")],
+          stream,
+          version_none
+        )
       end.to raise_error(WrongExpectedEventVersion)
-      expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
+      expect(repository.has_event?("9bedf448-e4d0-41a3-a8cd-f94aec7aa763")).to be false
     end
 
-    specify 'linking non-existent event' do
+    specify "linking non-existent event" do
       expect do
-        repository.link_to_stream('72922e65-1b32-4e97-8023-03ae81dd3a27', stream_flow, version_none)
+        repository.link_to_stream(["72922e65-1b32-4e97-8023-03ae81dd3a27"], stream_flow, version_none)
       end.to raise_error do |err|
         expect(err).to be_a(EventNotFound)
-        expect(err.event_id).to eq('72922e65-1b32-4e97-8023-03ae81dd3a27')
-        expect(err.message).to eq('Event not found: 72922e65-1b32-4e97-8023-03ae81dd3a27')
+        expect(err.event_id).to eq("72922e65-1b32-4e97-8023-03ae81dd3a27")
+        expect(err.message).to eq("Event not found: 72922e65-1b32-4e97-8023-03ae81dd3a27")
       end
     end
 
-    specify 'read returns enumerator' do
+    specify "read returns enumerator" do
       expect(repository.read(specification.result)).to be_kind_of(Enumerator)
     end
 
-    specify 'can store arbitrary binary data' do
+    specify "can store arbitrary binary data" do
       skip unless helper.supports_binary?
       binary = "\xB0"
       expect(binary.valid_encoding?).to eq(false)
@@ -966,7 +994,7 @@ module RubyEventStore
       expect(binary.valid_encoding?).to eq(true)
 
       repository.append_to_stream(
-        event = SRecord.new(data: binary, metadata: binary),
+        [event = SRecord.new(data: binary, metadata: binary)],
         stream,
         version_none
       )
@@ -974,6 +1002,8 @@ module RubyEventStore
 
     specify do
       expect(repository.read(specification.in_batches.result)).to be_kind_of(Enumerator)
+      expect(repository.read(specification.in_batches.as_at.result)).to be_kind_of(Enumerator)
+      expect(repository.read(specification.in_batches.as_of.result)).to be_kind_of(Enumerator)
       events = Array.new(10) { SRecord.new }
       repository.append_to_stream(
         events,
@@ -981,6 +1011,9 @@ module RubyEventStore
         ExpectedVersion.none
       )
       expect(repository.read(specification.in_batches.result)).to be_kind_of(Enumerator)
+      expect(repository.read(specification.in_batches.as_at.result)).to be_kind_of(Enumerator)
+      expect(repository.read(specification.in_batches.as_of.result)).to be_kind_of(Enumerator)
+
     end
 
     specify do
@@ -1177,50 +1210,50 @@ module RubyEventStore
     end
 
     specify do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea')
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7')
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e')
-      stream_a = Stream.new('Stream A')
-      stream_b = Stream.new('Stream B')
-      stream_c = Stream.new('Stream C')
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea")
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7")
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e")
+      stream_a = Stream.new("Stream A")
+      stream_b = Stream.new("Stream B")
+      stream_c = Stream.new("Stream C")
       repository.append_to_stream([event_1, event_2], stream_a, version_any)
       repository.append_to_stream([event_3], stream_b, version_any)
-      repository.link_to_stream(event_1.event_id, stream_c, version_none)
+      repository.link_to_stream([event_1.event_id], stream_c, version_none)
 
-      expect(repository.streams_of('8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea')).to eq [stream_a, stream_c]
-      expect(repository.streams_of('8cee1139-4f96-483a-a175-2b947283c3c7')).to eq [stream_a]
-      expect(repository.streams_of('d345f86d-b903-4d78-803f-38990c078d9e')).to eq [stream_b]
-      expect(repository.streams_of('d10c8fe9-2163-418d-ba47-88c9a1f9391b')).to eq []
+      expect(repository.streams_of("8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea")).to eq [stream_a, stream_c]
+      expect(repository.streams_of("8cee1139-4f96-483a-a175-2b947283c3c7")).to eq [stream_a]
+      expect(repository.streams_of("d345f86d-b903-4d78-803f-38990c078d9e")).to eq [stream_b]
+      expect(repository.streams_of("d10c8fe9-2163-418d-ba47-88c9a1f9391b")).to eq []
     end
 
     specify do
-      e1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea')
-      e2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7')
-      e3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e')
-      stream = Stream.new('Stream A')
+      e1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea")
+      e2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7")
+      e3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e")
+      stream = Stream.new("Stream A")
       repository.append_to_stream([e1, e2, e3], stream, version_any)
 
       expect(repository.read(specification.with_id([
-        '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea'
+        "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea"
       ]).read_first.result)).to eq(e1)
       expect(repository.read(specification.with_id([
-        'd345f86d-b903-4d78-803f-38990c078d9e'
+        "d345f86d-b903-4d78-803f-38990c078d9e"
       ]).read_first.result)).to eq(e3)
       expect(repository.read(specification.with_id([
-        'c31b327c-0da1-4178-a3cd-d2f6bb5d0688'
+        "c31b327c-0da1-4178-a3cd-d2f6bb5d0688"
       ]).read_first.result)).to eq(nil)
       expect(repository.read(specification.with_id([
-        '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea',
-        'd345f86d-b903-4d78-803f-38990c078d9e'
+        "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea",
+        "d345f86d-b903-4d78-803f-38990c078d9e"
       ]).in_batches.result).to_a[0]).to eq([e1,e3])
-      expect(repository.read(specification.stream('Stream A').with_id([
-        '8cee1139-4f96-483a-a175-2b947283c3c7'
+      expect(repository.read(specification.stream("Stream A").with_id([
+        "8cee1139-4f96-483a-a175-2b947283c3c7"
       ]).read_first.result)).to eq(e2)
-      expect(repository.read(specification.stream('Stream B').with_id([
-        '8cee1139-4f96-483a-a175-2b947283c3c7'
+      expect(repository.read(specification.stream("Stream B").with_id([
+        "8cee1139-4f96-483a-a175-2b947283c3c7"
       ]).read_first.result)).to eq(nil)
-      expect(repository.read(specification.stream('Stream B').with_id([
-        'c31b327c-0da1-4178-a3cd-d2f6bb5d0688'
+      expect(repository.read(specification.stream("Stream B").with_id([
+        "c31b327c-0da1-4178-a3cd-d2f6bb5d0688"
       ]).read_first.result)).to eq(nil)
       expect(repository.read(specification.with_id([]).result).to_a).to eq([])
     end
@@ -1229,7 +1262,7 @@ module RubyEventStore
       e1 = SRecord.new(event_type: Type1.to_s)
       e2 = SRecord.new(event_type: Type2.to_s)
       e3 = SRecord.new(event_type: Type1.to_s)
-      stream = Stream.new('Stream A')
+      stream = Stream.new("Stream A")
       repository.append_to_stream([e1, e2, e3], stream, version_any)
 
       expect(repository.read(specification.of_type([Type1]).result).to_a).to eq([e1,e3])
@@ -1239,8 +1272,8 @@ module RubyEventStore
     end
 
     specify do
-      stream = Stream.new('Stream A')
-      dummy  = Stream.new('Dummy')
+      stream = Stream.new("Stream A")
+      dummy  = Stream.new("Dummy")
 
       expect(repository.count(specification.result)).to eq(0)
       (1..3).each do
@@ -1258,8 +1291,8 @@ module RubyEventStore
       expect(repository.count(specification.with_id([not_existing_uuid]).result)).to eq(0)
 
       expect(repository.count(specification.stream(stream.name).result)).to eq(3)
-      expect(repository.count(specification.stream('Dummy').result)).to eq(1)
-      expect(repository.count(specification.stream('not-existing-stream').result)).to eq(0)
+      expect(repository.count(specification.stream("Dummy").result)).to eq(1)
+      expect(repository.count(specification.stream("not-existing-stream").result)).to eq(0)
 
       repository.append_to_stream([SRecord.new(event_type: Type1.to_s)], dummy, version_any)
       expect(repository.count(specification.from(event_id).result)).to eq(1)
@@ -1279,100 +1312,100 @@ module RubyEventStore
       expect(repository.count(specification.stream(stream.name).of_type([Type3]).result)).to eq(0)
     end
 
-    specify 'timestamp precision' do
+    specify "timestamp precision" do
       time = Time.utc(2020, 9, 11, 12, 26, 0, 123456)
-      repository.append_to_stream(SRecord.new(timestamp: time), stream, version_none)
+      repository.append_to_stream([SRecord.new(timestamp: time)], stream, version_none)
       event = read_events_forward(repository, count: 1).first
 
       expect(event.timestamp).to eq(time)
     end
 
-    specify 'fetching records older than specified date in stream' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records older than specified date in stream" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream('whatever').older_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1])
+      expect(repository.read(specification.stream("whatever").older_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1])
     end
 
-    specify 'fetching records older than or equal to specified date in stream' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records older than or equal to specified date in stream" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream('whatever').older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1, event_2])
+      expect(repository.read(specification.stream("whatever").older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1, event_2])
     end
 
-    specify 'fetching records newer than specified date in stream' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records newer than specified date in stream" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream('whatever').newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_3])
+      expect(repository.read(specification.stream("whatever").newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_3])
     end
 
-    specify 'fetching records newer than or equal to specified date in stream' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records newer than or equal to specified date in stream" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream('whatever').newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_2, event_3])
+      expect(repository.read(specification.stream("whatever").newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_2, event_3])
     end
 
-    specify 'fetching records older than specified date' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records older than specified date" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
       expect(repository.read(specification.older_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1])
     end
 
-    specify 'fetching records older than or equal to specified date' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records older than or equal to specified date" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
       expect(repository.read(specification.older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1, event_2])
     end
 
-    specify 'fetching records newer than specified date' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records newer than specified date" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
       expect(repository.read(specification.newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_3])
     end
 
-    specify 'fetching records newer than or equal to specified date' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records newer than or equal to specified date" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
       expect(repository.read(specification.newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_2, event_3])
     end
 
-    specify 'fetching records from disjoint periods' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records from disjoint periods" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
       expect(repository.read(specification.older_than(Time.utc(2020, 1, 2)).newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq([])
     end
 
-    specify 'fetching records within time range' do
-      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
-      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
-      event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e', timestamp: Time.utc(2020, 1, 3))
-      repository.append_to_stream([event_1, event_2, event_3], Stream.new('whatever'), version_any)
+    specify "fetching records within time range" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
       expect(repository.read(specification.between(Time.utc(2020, 1, 1)...Time.utc(2020, 1, 3)).result).to_a).to eq([event_1, event_2])
     end
@@ -1386,11 +1419,35 @@ module RubyEventStore
         Stream.new("Dummy"),
         ExpectedVersion.any
       )
-      expect(repository.read(specification.result).map(&:event_id)).to eq [e1, e2, e3]
-      expect(repository.read(specification.as_at.result).map(&:event_id)).to eq [e1, e3, e2]
-      expect(repository.read(specification.as_at.backward.result).map(&:event_id)).to eq [e2, e3, e1]
-      expect(repository.read(specification.as_of.result).map(&:event_id)).to eq [e3, e2, e1]
-      expect(repository.read(specification.as_of.backward.result).map(&:event_id)).to eq [e1, e2, e3]
+      expect(repository.read(specification.result)).to                eq_ids([e1, e2, e3])
+      expect(repository.read(specification.as_at.result)).to          eq_ids([e1, e3, e2])
+      expect(repository.read(specification.as_at.backward.result)).to eq_ids([e2, e3, e1])
+      expect(repository.read(specification.as_of.result)).to          eq_ids([e3, e2, e1])
+      expect(repository.read(specification.as_of.backward.result)).to eq_ids([e1, e2, e3])
+    end
+
+    specify "time order is respected with batches" do
+      repository.append_to_stream([
+        SRecord.new(event_id: e1 = SecureRandom.uuid, timestamp: Time.new(2020,1,1), valid_at: Time.new(2020,1,9)),
+        SRecord.new(event_id: e2 = SecureRandom.uuid, timestamp: Time.new(2020,1,3), valid_at: Time.new(2020,1,6)),
+        SRecord.new(event_id: e3 = SecureRandom.uuid, timestamp: Time.new(2020,1,2), valid_at: Time.new(2020,1,3)),
+      ],
+        Stream.new("Dummy"),
+        ExpectedVersion.any
+      )
+      expect(repository.read(specification.in_batches.result).to_a.flatten).to                eq_ids([e1, e2, e3])
+      expect(repository.read(specification.in_batches.as_at.result).to_a.flatten).to          eq_ids([e1, e3, e2])
+      expect(repository.read(specification.in_batches.as_at.backward.result).to_a.flatten).to eq_ids([e2, e3, e1])
+      expect(repository.read(specification.in_batches.as_of.result).to_a.flatten).to          eq_ids([e3, e2, e1])
+      expect(repository.read(specification.in_batches.as_of.backward.result).to_a.flatten).to eq_ids([e1, e2, e3])
+    end
+  end
+
+  ::RSpec::Matchers.define :eq_ids do |expected_ids|
+    match do |enum|
+      @actual = enum.map(&:event_id)
+      expected_ids == @actual
     end
+    diffable
   end
 end