ruby_event_store 0.29.0 → 0.30.0

data/lib/ruby_event_store/projection.rb

@@ -58,6 +58,7 @@ module RubyEventStore
     end
 
     private
+
     def valid_starting_point?(start)
       return true if start === :head
       if streams.any?
@@ -67,44 +68,16 @@ module RubyEventStore
       end
     end
 
-    def reduce_events(events, initial_state)
-      events.reduce(initial_state, &method(:transition))
-    end
-
-    def read_events_from_stream(event_store, stream_name, start, count)
-      event_store.read_events_forward(stream_name, start: start, count: count)
-    end
-
     def reduce_from_streams(event_store, start, count)
       raise ArgumentError.new('Start must be an array with event ids or :head') unless valid_starting_point?(start)
       streams.zip(start_events(start)).reduce(initial_state) do |state, (stream_name, start_event_id)|
-        reader = ->(from){ read_events_from_stream(event_store, stream_name, from, count) }
-        read(state, start_event_id, reader)
+        event_store.read.in_batches(count).stream(stream_name).from(start_event_id).each.reduce(state, &method(:transition))
       end
     end
 
-    def read_events_from_all_streams(event_store, start, count)
-      event_store.read_all_streams_forward(start: start, count: count)
-    end
-
     def reduce_from_all_streams(event_store, start, count)
       raise ArgumentError.new('Start must be valid event id or :head') unless valid_starting_point?(start)
-      reader = ->(from){ read_events_from_all_streams(event_store, from, count) }
-      read(initial_state, start, reader)
-    end
-
-    def read(initial_state, start, reader)
-      state = initial_state
-
-      loop do
-        events = reader.call(start)
-        break if events.empty?
-
-        reduce_events(events, state)
-        start = events.last.event_id
-      end
-
-      state
+      event_store.read.in_batches(count).from(start).each.reduce(initial_state, &method(:transition))
     end
 
     def start_events(start)

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -6,19 +6,32 @@ class SRecord
     event_type: SecureRandom.uuid
   )
     RubyEventStore::SerializedRecord.new(
-      event_id: event_id,
-      data: data,
-      metadata: metadata,
+      event_id:   event_id,
+      data:       data,
+      metadata:   metadata,
       event_type: event_type,
     )
   end
 end
 
 RSpec.shared_examples :event_repository do |repository_class|
-  let(:repository) { subject || repository_class.new }
+  let(:repository)    { subject || repository_class.new }
+  let(:mapper)        { RubyEventStore::Mappers::NullMapper.new }
+  let(:specification) { RubyEventStore::Specification.new(repository, mapper) }
+  let(:global_stream) { RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM) }
+  let(:stream)        { RubyEventStore::Stream.new(SecureRandom.uuid) }
+  let(:stream_flow)   { RubyEventStore::Stream.new('flow') }
+  let(:stream_other)  { RubyEventStore::Stream.new('other') }
+  let(:stream_test)   { RubyEventStore::Stream.new('test') }
+  let(:version_none)  { RubyEventStore::ExpectedVersion.none }
+  let(:version_auto)  { RubyEventStore::ExpectedVersion.auto }
+  let(:version_any)   { RubyEventStore::ExpectedVersion.any }
+  let(:version_0)     { RubyEventStore::ExpectedVersion.new(0) }
+  let(:version_1)     { RubyEventStore::ExpectedVersion.new(1) }
+  let(:version_2)     { RubyEventStore::ExpectedVersion.new(2) }
+  let(:version_3)     { RubyEventStore::ExpectedVersion.new(3) }
 
   def read_stream_events_forward(repository, stream)
-    specification = RubyEventStore::Specification.new(repository)
     repository.read(
       specification
         .stream(stream.name)
@@ -27,7 +40,6 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   def read_stream_events_backward(repository, stream)
-    specification = RubyEventStore::Specification.new(repository)
     repository.read(
       specification
         .stream(stream.name)
@@ -37,7 +49,6 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   def read_events_forward(repository, stream, start, count)
-    specification = RubyEventStore::Specification.new(repository)
     repository.read(
       specification
         .stream(stream.name)
@@ -48,7 +59,6 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   def read_events_backward(repository, stream, start, count)
-    specification = RubyEventStore::Specification.new(repository)
     repository.read(
       specification
         .stream(stream.name)
@@ -60,7 +70,6 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   def read_all_streams_forward(repository, start, count)
-    specification = RubyEventStore::Specification.new(repository)
     repository.read(
       specification
         .from(start)
@@ -70,7 +79,6 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   def read_all_streams_backward(repository, start, count)
-    specification = RubyEventStore::Specification.new(repository)
     repository.read(
       specification
         .from(start)
@@ -86,8 +94,8 @@ RSpec.shared_examples :event_repository do |repository_class|
 
   specify 'append_to_stream returns self' do
     repository.
-      append_to_stream(event = SRecord.new, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none).
-      append_to_stream(event = SRecord.new, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(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
@@ -95,225 +103,225 @@ RSpec.shared_examples :event_repository do |repository_class|
     event0 = SRecord.new
     event1 = SRecord.new
     repository.
-      append_to_stream([event0, event1], RubyEventStore::Stream.new("stream0"), RubyEventStore::ExpectedVersion.none).
-      link_to_stream(event0.event_id, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none).
-      link_to_stream(event1.event_id, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(0))
+      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)
   end
 
   specify 'adds an initial event to a new stream' do
-    repository.append_to_stream(event = SRecord.new, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+    repository.append_to_stream(event = SRecord.new, stream, version_none)
     expect(read_all_streams_forward(repository, :head, 1).first).to eq(event)
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream')).first).to eq(event)
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("other_stream"))).to be_empty
+    expect(read_stream_events_forward(repository, stream).first).to eq(event)
+    expect(read_stream_events_forward(repository, stream_other)).to be_empty
   end
 
   specify 'links an initial event to a new stream' do
     skip unless test_link_events_to_stream
     repository.
-      append_to_stream(event = SRecord.new, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none).
-      link_to_stream(event.event_id, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+      append_to_stream(event = SRecord.new, stream, version_none).
+      link_to_stream(event.event_id, stream_flow, version_none)
 
     expect(read_all_streams_forward(repository, :head, 1).first).to eq(event)
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream')).first).to eq(event)
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([event])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("other"))).to be_empty
+    expect(read_stream_events_forward(repository, stream).first).to eq(event)
+    expect(read_stream_events_forward(repository, stream_flow)).to eq([event])
+    expect(read_stream_events_forward(repository, stream_other)).to be_empty
   end
 
   specify 'adds multiple initial events to a new stream' do
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none)
     expect(read_all_streams_forward(repository, :head, 2)).to eq([event0, event1])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1])
+    expect(read_stream_events_forward(repository, stream)).to eq([event0, event1])
   end
 
   specify 'links multiple initial events to a new stream' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none).link_to_stream([
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none).link_to_stream([
       event0.event_id,
       event1.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+    ], stream_flow, version_none)
     expect(read_all_streams_forward(repository, :head, 2)).to eq([event0, event1])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([event0, event1])
+    expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1])
   end
 
   specify 'correct expected version on second write' do
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(1))
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_1)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1, event2, event3])
+    expect(read_stream_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
   end
 
   specify 'correct expected version on second link' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none).append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none).link_to_stream([
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none).append_to_stream([
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream_flow, version_none).link_to_stream([
       event0.event_id,
       event1.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(1))
+    ], stream_flow, version_1)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([event2, event3, event0, event1])
+    expect(read_stream_events_forward(repository, stream_flow)).to eq([event2, event3, event0, event1])
   end
 
   specify 'incorrect expected version on second write' do
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none)
     expect do
       repository.append_to_stream([
-        event2 = SRecord.new(event_id: SecureRandom.uuid),
-        event3 = SRecord.new(event_id: SecureRandom.uuid),
-      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(0))
+        event2 = SRecord.new,
+        event3 = SRecord.new,
+      ], stream, version_0)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
 
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1])
+    expect(read_stream_events_forward(repository, stream)).to eq([event0, event1])
   end
 
   specify 'incorrect expected version on second link' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new("other"), RubyEventStore::ExpectedVersion.none)
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream_other, version_none)
     expect do
       repository.link_to_stream([
         event2.event_id,
         event3.event_id,
-      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(0))
+      ], stream, version_0)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
 
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1])
+    expect(read_stream_events_forward(repository, stream)).to eq([event0, event1])
   end
 
   specify ':none on first and subsequent write' do
     repository.append_to_stream([
-      eventA = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      eventA = SRecord.new,
+    ], stream, version_none)
     expect do
       repository.append_to_stream([
-        eventB = SRecord.new(event_id: SecureRandom.uuid),
-      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+        eventB = SRecord.new,
+      ], stream, version_none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
     expect(read_all_streams_forward(repository, :head, 1)).to eq([eventA])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([eventA])
+    expect(read_stream_events_forward(repository, stream)).to eq([eventA])
   end
 
   specify ':none on first and subsequent link' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      eventA = SRecord.new(event_id: SecureRandom.uuid),
-      eventB = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      eventA = SRecord.new,
+      eventB = SRecord.new,
+    ], stream, version_none)
 
-    repository.link_to_stream([eventA.event_id], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+    repository.link_to_stream([eventA.event_id], stream_flow, version_none)
     expect do
-      repository.link_to_stream([eventB.event_id], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+      repository.link_to_stream([eventB.event_id], stream_flow, version_none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
 
     expect(read_all_streams_forward(repository, :head, 1)).to eq([eventA])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([eventA])
+    expect(read_stream_events_forward(repository, stream_flow)).to eq([eventA])
   end
 
   specify ':any allows stream with best-effort order and no guarantee' do
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_any)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_any)
     expect(read_all_streams_forward(repository, :head, 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream')).to_set).to eq(Set.new([event0, event1, event2, event3]))
+    expect(read_stream_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
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_any)
 
     repository.link_to_stream([
       event0.event_id, event1.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
+    ], stream_flow, version_any)
     repository.link_to_stream([
       event2.event_id, event3.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
+    ], stream_flow, version_any)
 
     expect(read_all_streams_forward(repository, :head, 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow")).to_set).to eq(Set.new([event0, event1, event2, event3]))
+    expect(read_stream_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
     skip unless test_expected_version_auto
     repository.append_to_stream([
-      eventA = SRecord.new(event_id: SecureRandom.uuid),
-      eventB = SRecord.new(event_id: SecureRandom.uuid),
-      eventC = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new("another"), RubyEventStore::ExpectedVersion.auto)
+      eventA = SRecord.new,
+      eventB = SRecord.new,
+      eventC = SRecord.new,
+    ], stream_other, version_auto)
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_auto)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(1))
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_1)
   end
 
   specify ':auto queries for last position in given stream when linking' do
     skip unless test_expected_version_auto
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      eventA = SRecord.new(event_id: SecureRandom.uuid),
-      eventB = SRecord.new(event_id: SecureRandom.uuid),
-      eventC = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new("another"), RubyEventStore::ExpectedVersion.auto)
+      eventA = SRecord.new,
+      eventB = SRecord.new,
+      eventC = SRecord.new,
+    ], stream_other, version_auto)
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_auto)
     repository.link_to_stream([
       eventA.event_id,
       eventB.event_id,
       eventC.event_id,
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(1))
+    ], stream, version_1)
   end
 
   specify ':auto starts from 0' do
     skip unless test_expected_version_auto
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+    ], stream, version_auto)
     expect do
       repository.append_to_stream([
-        event1 = SRecord.new(event_id: SecureRandom.uuid),
-      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+        event1 = SRecord.new,
+      ], stream, version_none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
   end
 
@@ -321,15 +329,15 @@ RSpec.shared_examples :event_repository do |repository_class|
     skip unless test_expected_version_auto
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new("whatever"), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+    ], stream_other, version_auto)
     repository.link_to_stream([
       event0.event_id,
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+    ], stream, version_auto)
     expect do
       repository.append_to_stream([
-        event1 = SRecord.new(event_id: SecureRandom.uuid),
-      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+        event1 = SRecord.new,
+      ], stream, version_none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
   end
 
@@ -338,102 +346,102 @@ RSpec.shared_examples :event_repository do |repository_class|
     # It is expected that there is higher level lock
     # So this query is safe from race conditions
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_auto)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_auto)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([
       event0, event1,
       event2, event3
     ])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1, event2, event3])
+    expect(read_stream_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
     skip unless test_expected_version_auto
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_auto)
     repository.link_to_stream([
       event0.event_id, event1.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
+    ], stream_flow, version_auto)
     repository.link_to_stream([
       event2.event_id, event3.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
+    ], stream_flow, version_auto)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([
       event0, event1,
       event2, event3
     ])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([event0, event1, event2, event3])
+    expect(read_stream_events_forward(repository, stream_flow)).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 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_auto)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(1))
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_1)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1, event2, event3])
+    expect(read_stream_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
   end
 
   specify ':auto is compatible with manual expectation when linking' do
     skip unless test_expected_version_auto
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_auto)
     repository.link_to_stream([
       event0.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
+    ], stream_flow, version_auto)
     repository.link_to_stream([
       event1.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(0))
+    ], stream_flow, version_0)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1,])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([event0, event1,])
+    expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1,])
   end
 
   specify 'manual is compatible with auto expectation' do
     skip unless test_expected_version_auto
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_none)
     repository.append_to_stream([
-      event2 = SRecord.new(event_id: SecureRandom.uuid),
-      event3 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event2 = SRecord.new,
+      event3 = SRecord.new,
+    ], stream, version_auto)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to eq([event0, event1, event2, event3])
+    expect(read_stream_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
   end
 
   specify 'manual is compatible with auto expectation when linking' do
     skip unless test_expected_version_auto
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = SRecord.new(event_id: SecureRandom.uuid),
-      event1 = SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+      event0 = SRecord.new,
+      event1 = SRecord.new,
+    ], stream, version_auto)
     repository.link_to_stream([
       event0.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+    ], stream_flow, version_none)
     repository.link_to_stream([
       event1.event_id,
-    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
+    ], stream_flow, version_auto)
     expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1])
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([event0, event1])
+    expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1])
   end
 
   specify 'unlimited concurrency for :any - everything should succeed', timeout: 10, mutant: false do
@@ -453,7 +461,7 @@ RSpec.shared_examples :event_repository do |repository_class|
               eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
               repository.append_to_stream([
                 SRecord.new(event_id: eid),
-              ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+              ], stream, version_any)
             end
           rescue RubyEventStore::WrongExpectedEventVersion
             fail_occurred = true
@@ -463,8 +471,8 @@ RSpec.shared_examples :event_repository do |repository_class|
       wait_for_it = false
       threads.each(&:join)
       expect(fail_occurred).to eq(false)
-      expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream')).size).to eq(400)
-      events_in_stream = read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))
+      expect(read_stream_events_forward(repository, stream).size).to eq(400)
+      events_in_stream = read_stream_events_forward(repository, stream)
       expect(events_in_stream.size).to eq(400)
       events0 = events_in_stream.select do |ev|
         ev.event_id.start_with?("0-")
@@ -490,7 +498,7 @@ RSpec.shared_examples :event_repository do |repository_class|
           eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
           repository.append_to_stream([
             SRecord.new(event_id: eid),
-          ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+          ], stream, version_any)
         end
       end
 
@@ -500,7 +508,7 @@ RSpec.shared_examples :event_repository do |repository_class|
           begin
             100.times do |j|
               eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-              repository.link_to_stream(eid, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
+              repository.link_to_stream(eid, stream_flow, version_any)
             end
           rescue RubyEventStore::WrongExpectedEventVersion
             fail_occurred = true
@@ -510,8 +518,8 @@ RSpec.shared_examples :event_repository do |repository_class|
       wait_for_it = false
       threads.each(&:join)
       expect(fail_occurred).to eq(false)
-      expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow")).size).to eq(400)
-      events_in_stream = read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))
+      expect(read_stream_events_forward(repository, stream_flow).size).to eq(400)
+      events_in_stream = read_stream_events_forward(repository, stream_flow)
       expect(events_in_stream.size).to eq(400)
       events0 = events_in_stream.select do |ev|
         ev.event_id.start_with?("0-")
@@ -540,7 +548,7 @@ RSpec.shared_examples :event_repository do |repository_class|
               eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
               repository.append_to_stream([
                 SRecord.new(event_id: eid),
-              ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+              ], stream, version_auto)
               sleep(rand(concurrency_level) / 1000.0)
             rescue RubyEventStore::WrongExpectedEventVersion
               fail_occurred +=1
@@ -551,7 +559,7 @@ RSpec.shared_examples :event_repository do |repository_class|
       wait_for_it = false
       threads.each(&:join)
       expect(fail_occurred).to be > 0
-      events_in_stream = read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))
+      events_in_stream = read_stream_events_forward(repository, stream)
       expect(events_in_stream.size).to be < 400
       expect(events_in_stream.size).to be >= 100
       events0 = events_in_stream.select do |ev|
@@ -578,7 +586,7 @@ RSpec.shared_examples :event_repository do |repository_class|
           eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
           repository.append_to_stream([
             SRecord.new(event_id: eid),
-          ], RubyEventStore::Stream.new("whatever"), RubyEventStore::ExpectedVersion.any)
+          ], stream_other, version_any)
         end
       end
 
@@ -591,7 +599,7 @@ RSpec.shared_examples :event_repository do |repository_class|
           100.times do |j|
             begin
               eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-              repository.link_to_stream(eid, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+              repository.link_to_stream(eid, stream, version_auto)
               sleep(rand(concurrency_level) / 1000.0)
             rescue RubyEventStore::WrongExpectedEventVersion
               fail_occurred +=1
@@ -602,7 +610,7 @@ RSpec.shared_examples :event_repository do |repository_class|
       wait_for_it = false
       threads.each(&:join)
       expect(fail_occurred).to be > 0
-      events_in_stream = read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))
+      events_in_stream = read_stream_events_forward(repository, stream)
       expect(events_in_stream.size).to be < 400
       expect(events_in_stream.size).to be >= 100
       events0 = events_in_stream.select do |ev|
@@ -617,22 +625,22 @@ RSpec.shared_examples :event_repository do |repository_class|
 
   it 'appended event is stored in given stream' do
     expected_event = SRecord.new
-    repository.append_to_stream(expected_event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+    repository.append_to_stream(expected_event, stream, version_any)
     expect(read_all_streams_forward(repository, :head, 1).first).to eq(expected_event)
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream')).first).to eq(expected_event)
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("other_stream"))).to be_empty
+    expect(read_stream_events_forward(repository, stream).first).to eq(expected_event)
+    expect(read_stream_events_forward(repository, stream_other)).to be_empty
   end
 
   it 'data attributes are retrieved' do
     event = SRecord.new(data: "{ order_id: 3 }")
-    repository.append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+    repository.append_to_stream(event, stream, version_any)
     retrieved_event = read_all_streams_forward(repository, :head, 1).first
     expect(retrieved_event.data).to eq("{ order_id: 3 }")
   end
 
   it 'metadata attributes are retrieved' do
     event = SRecord.new(metadata: "{ request_id: 3 }")
-    repository.append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+    repository.append_to_stream(event, stream, version_any)
     retrieved_event = read_all_streams_forward(repository, :head, 1).first
     expect(retrieved_event.metadata).to eq("{ request_id: 3 }")
   end
@@ -644,54 +652,54 @@ RSpec.shared_examples :event_repository do |repository_class|
       metadata: "{ request_id: 4 }",
     )
     repository.
-      append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any).
-      link_to_stream(event.event_id, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
-    retrieved_event = read_stream_events_forward(repository, RubyEventStore::Stream.new("flow")).first
+      append_to_stream(event, stream, version_any).
+      link_to_stream(event.event_id, stream_flow, version_any)
+    retrieved_event = read_stream_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, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
-    repository.append_to_stream(e2 = SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.none)
+    repository.append_to_stream(e1 = SRecord.new, stream, version_none)
+    repository.append_to_stream(e2 = SRecord.new, stream_other, version_none)
 
-    repository.delete_stream(RubyEventStore::Stream.new('stream'))
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))).to be_empty
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("other_stream"))).to eq([e2])
+    repository.delete_stream(stream)
+    expect(read_stream_events_forward(repository, stream)).to be_empty
+    expect(read_stream_events_forward(repository, stream_other)).to eq([e2])
     expect(read_all_streams_forward(repository, :head, 10)).to eq([e1,e2])
   end
 
   it 'does not have deleted streams with linked events' do
     skip unless test_link_events_to_stream
     repository.
-      append_to_stream(e1 = SRecord.new, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none).
-      link_to_stream(e1.event_id, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+      append_to_stream(e1 = SRecord.new, stream, version_none).
+      link_to_stream(e1.event_id, stream_flow, version_none)
 
-    repository.delete_stream(RubyEventStore::Stream.new("flow"))
-    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to be_empty
+    repository.delete_stream(stream_flow)
+    expect(read_stream_events_forward(repository, stream_flow)).to be_empty
     expect(read_all_streams_forward(repository, :head, 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), RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+    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
 
-    repository.delete_stream(RubyEventStore::Stream.new('stream'))
+    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'), RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
-    repository.append_to_stream(b = SRecord.new(event_id: '00000000-0000-0000-0000-000000000002'), RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(0))
+    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(RubyEventStore::Stream.new('stream'))).to eq(b)
-    expect(repository.last_stream_event(RubyEventStore::Stream.new("other_stream"))).to be_nil
+    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
@@ -700,10 +708,10 @@ RSpec.shared_examples :event_repository do |repository_class|
         e0 = SRecord.new(event_id: '00000000-0000-0000-0000-000000000001'),
         e1 = SRecord.new(event_id: '00000000-0000-0000-0000-000000000002'),
       ],
-      RubyEventStore::Stream.new('stream'),
-      RubyEventStore::ExpectedVersion.none
-    ).link_to_stream([e1.event_id, e0.event_id], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
-    expect(repository.last_stream_event(RubyEventStore::Stream.new("flow"))).to eq(e0)
+      stream,
+      version_none
+    ).link_to_stream([e1.event_id, e0.event_id], stream_flow, version_none)
+    expect(repository.last_stream_event(stream_flow)).to eq(e0)
   end
 
   it 'reads batch of events from stream forward & backward' do
@@ -719,21 +727,22 @@ RSpec.shared_examples :event_repository do |repository_class|
       ab60114c-011d-4d58-ab31-7ba65d99975e
       868cac42-3d19-4b39-84e8-cd32d65c2445
     ].map { |id| SRecord.new(event_id: id) }
-    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.none)
+    repository.append_to_stream(SRecord.new, stream_other, version_none)
     events.each.with_index do |event, index|
-      repository.append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(index - 1))
+      repository.append_to_stream(event, stream, RubyEventStore::ExpectedVersion.new(index - 1))
     end
-    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.new(0))
-
-    expect(read_events_forward(repository, RubyEventStore::Stream.new('stream'), :head, 3)).to eq(events.first(3))
-    expect(read_events_forward(repository, RubyEventStore::Stream.new('stream'), :head, 100)).to eq(events)
-    expect(read_events_forward(repository, RubyEventStore::Stream.new('stream'), events[4].event_id, 4)).to eq(events[5..8])
-    expect(read_events_forward(repository, RubyEventStore::Stream.new('stream'), events[4].event_id, 100)).to eq(events[5..9])
-
-    expect(read_events_backward(repository, RubyEventStore::Stream.new('stream'), :head, 3)).to eq(events.last(3).reverse)
-    expect(read_events_backward(repository, RubyEventStore::Stream.new('stream'), :head, 100)).to eq(events.reverse)
-    expect(read_events_backward(repository, RubyEventStore::Stream.new('stream'), events[4].event_id, 4)).to eq(events.first(4).reverse)
-    expect(read_events_backward(repository, RubyEventStore::Stream.new('stream'), events[4].event_id, 100)).to eq(events.first(4).reverse)
+    repository.append_to_stream(SRecord.new, stream_other, version_0)
+
+    expect(read_events_forward(repository, stream, :head, 3)).to eq(events.first(3))
+    expect(read_events_forward(repository, stream, :head, 100)).to eq(events)
+    expect(repository.read(specification.stream(stream.name).from(events[4].event_id).result).to_a).to eq(events[5..9])
+    expect(read_events_forward(repository, stream, events[4].event_id, 4)).to eq(events[5..8])
+    expect(read_events_forward(repository, stream, events[4].event_id, 100)).to eq(events[5..9])
+
+    expect(read_events_backward(repository, stream, :head, 3)).to eq(events.last(3).reverse)
+    expect(read_events_backward(repository, stream, :head, 100)).to eq(events.reverse)
+    expect(read_events_backward(repository, stream, events[4].event_id, 4)).to eq(events.first(4).reverse)
+    expect(read_events_backward(repository, stream, events[4].event_id, 100)).to eq(events.first(4).reverse)
   end
 
   it 'reads batch of linked events from stream forward & backward' do
@@ -750,34 +759,34 @@ RSpec.shared_examples :event_repository do |repository_class|
       ab60114c-011d-4d58-ab31-7ba65d99975e
       868cac42-3d19-4b39-84e8-cd32d65c2445
     ].map { |id| SRecord.new(event_id: id) }
-    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.none)
+    repository.append_to_stream(SRecord.new, stream_other, version_none)
     events.each.with_index do |event, index|
       repository.
-        append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(index - 1)).
-        link_to_stream(event.event_id, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(index - 1))
+        append_to_stream(event, stream, RubyEventStore::ExpectedVersion.new(index - 1)).
+        link_to_stream(event.event_id, stream_flow, RubyEventStore::ExpectedVersion.new(index - 1))
     end
-    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.new(0))
+    repository.append_to_stream(SRecord.new, stream_other, version_0)
 
-    expect(read_events_forward(repository, RubyEventStore::Stream.new("flow"), :head, 3)).to eq(events.first(3))
-    expect(read_events_forward(repository, RubyEventStore::Stream.new("flow"), :head, 100)).to eq(events)
-    expect(read_events_forward(repository, RubyEventStore::Stream.new("flow"), events[4].event_id, 4)).to eq(events[5..8])
-    expect(read_events_forward(repository, RubyEventStore::Stream.new("flow"), events[4].event_id, 100)).to eq(events[5..9])
+    expect(read_events_forward(repository, stream_flow, :head, 3)).to eq(events.first(3))
+    expect(read_events_forward(repository, stream_flow, :head, 100)).to eq(events)
+    expect(read_events_forward(repository, stream_flow, events[4].event_id, 4)).to eq(events[5..8])
+    expect(read_events_forward(repository, stream_flow, events[4].event_id, 100)).to eq(events[5..9])
 
-    expect(read_events_backward(repository, RubyEventStore::Stream.new("flow"), :head, 3)).to eq(events.last(3).reverse)
-    expect(read_events_backward(repository, RubyEventStore::Stream.new("flow"), :head, 100)).to eq(events.reverse)
-    expect(read_events_backward(repository, RubyEventStore::Stream.new("flow"), events[4].event_id, 4)).to eq(events.first(4).reverse)
-    expect(read_events_backward(repository, RubyEventStore::Stream.new("flow"), events[4].event_id, 100)).to eq(events.first(4).reverse)
+    expect(read_events_backward(repository, stream_flow, :head, 3)).to eq(events.last(3).reverse)
+    expect(read_events_backward(repository, stream_flow, :head, 100)).to eq(events.reverse)
+    expect(read_events_backward(repository, stream_flow, events[4].event_id, 4)).to eq(events.first(4).reverse)
+    expect(read_events_backward(repository, stream_flow, events[4].event_id, 100)).to eq(events.first(4).reverse)
   end
 
   it 'reads all stream events forward & backward' do
-    s1 = RubyEventStore::Stream.new('stream')
-    s2 = RubyEventStore::Stream.new("other_stream")
+    s1 = stream
+    s2 = stream_other
     repository.
-      append_to_stream(a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, RubyEventStore::ExpectedVersion.none).
-      append_to_stream(b = SRecord.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s2, RubyEventStore::ExpectedVersion.none).
-      append_to_stream(c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, RubyEventStore::ExpectedVersion.new(0)).
-      append_to_stream(d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s2, RubyEventStore::ExpectedVersion.new(0)).
-      append_to_stream(e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s2, RubyEventStore::ExpectedVersion.new(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_stream_events_forward(repository, s1)).to eq [a,c]
     expect(read_stream_events_backward(repository, s1)).to eq [c,a]
@@ -785,18 +794,18 @@ RSpec.shared_examples :event_repository do |repository_class|
 
   it 'reads all stream linked events forward & backward' do
     skip unless test_link_events_to_stream
-    s1, fs1, fs2 = RubyEventStore::Stream.new('stream'), RubyEventStore::Stream.new("flow"), RubyEventStore::Stream.new("other_flow")
+    s1, fs1, fs2 = stream, stream_flow, stream_other
     repository.
-      append_to_stream(a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, RubyEventStore::ExpectedVersion.none).
-      append_to_stream(b = SRecord.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s1, RubyEventStore::ExpectedVersion.new(0)).
-      append_to_stream(c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, RubyEventStore::ExpectedVersion.new(1)).
-      append_to_stream(d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s1, RubyEventStore::ExpectedVersion.new(2)).
-      append_to_stream(e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s1, RubyEventStore::ExpectedVersion.new(3)).
-      link_to_stream('7010d298-ab69-4bb1-9251-f3466b5d1282', fs1, RubyEventStore::ExpectedVersion.none).
-      link_to_stream('34f88aca-aaba-4ca0-9256-8017b47528c5', fs2, RubyEventStore::ExpectedVersion.none).
-      link_to_stream('8e61c864-ceae-4684-8726-97c34eb8fc4f', fs1, RubyEventStore::ExpectedVersion.new(0)).
-      link_to_stream('30963ed9-6349-450b-ac9b-8ea50115b3bd', fs2, RubyEventStore::ExpectedVersion.new(0)).
-      link_to_stream('5bdc58b7-e8a7-4621-afd6-ccb828d72457', fs2, RubyEventStore::ExpectedVersion.new(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_stream_events_forward(repository, fs1)).to eq [a,c]
     expect(read_stream_events_backward(repository, fs1)).to eq [c,a]
@@ -816,7 +825,7 @@ RSpec.shared_examples :event_repository do |repository_class|
       868cac42-3d19-4b39-84e8-cd32d65c2445
     ].map { |id| SRecord.new(event_id: id) }
     events.each do |ev|
-      repository.append_to_stream(ev, RubyEventStore::Stream.new(SecureRandom.uuid), RubyEventStore::ExpectedVersion.none)
+      repository.append_to_stream(ev, RubyEventStore::Stream.new(SecureRandom.uuid), version_none)
     end
 
     expect(read_all_streams_forward(repository, :head, 3)).to eq(events.first(3))
@@ -846,8 +855,8 @@ RSpec.shared_examples :event_repository do |repository_class|
     ].map { |id| SRecord.new(event_id: id) }
     events.each do |ev|
       repository.
-        append_to_stream(ev, RubyEventStore::Stream.new(SecureRandom.uuid), RubyEventStore::ExpectedVersion.none).
-        link_to_stream(ev.event_id, RubyEventStore::Stream.new(SecureRandom.uuid), RubyEventStore::ExpectedVersion.none)
+        append_to_stream(ev, RubyEventStore::Stream.new(SecureRandom.uuid), version_none).
+        link_to_stream(ev.event_id, RubyEventStore::Stream.new(SecureRandom.uuid), version_none)
     end
 
     expect(read_all_streams_forward(repository, :head, 3)).to eq(events.first(3))
@@ -866,27 +875,27 @@ RSpec.shared_examples :event_repository do |repository_class|
       96c920b1-cdd0-40f4-907c-861b9fff7d02
       56404f79-0ba0-4aa0-8524-dc3436368ca0
     ].map{|id| SRecord.new(event_id: id) }
-    repository.append_to_stream(events.first, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
-    repository.append_to_stream(events.last,  RubyEventStore::Stream.new('stream'),  RubyEventStore::ExpectedVersion.new(0))
+    repository.append_to_stream(events.first, stream, version_none)
+    repository.append_to_stream(events.last,  stream,  version_0)
 
     expect(read_all_streams_forward(repository, "96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
     expect(read_all_streams_backward(repository, "56404f79-0ba0-4aa0-8524-dc3436368ca0", 1)).to eq([events.first])
 
-    expect(read_events_forward(repository, RubyEventStore::Stream.new('stream'), "96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
-    expect(read_events_backward(repository, RubyEventStore::Stream.new('stream'), "56404f79-0ba0-4aa0-8524-dc3436368ca0", 1)).to eq([events.first])
+    expect(read_events_forward(repository, stream, "96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
+    expect(read_events_backward(repository, 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(
       SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-      RubyEventStore::Stream.new('stream'),
-      RubyEventStore::ExpectedVersion.none
+      stream,
+      version_none
     )
     expect do
       repository.append_to_stream(
         SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-        RubyEventStore::Stream.new('stream'),
-        RubyEventStore::ExpectedVersion.new(0)
+        stream,
+        version_0
       )
     end.to raise_error(RubyEventStore::EventDuplicatedInStream)
   end
@@ -894,14 +903,14 @@ RSpec.shared_examples :event_repository do |repository_class|
   it 'does not allow same event twice' do
     repository.append_to_stream(
       SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-      RubyEventStore::Stream.new('stream'),
-      RubyEventStore::ExpectedVersion.none
+      stream,
+      version_none
     )
     expect do
       repository.append_to_stream(
         SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-        RubyEventStore::Stream.new("another"),
-        RubyEventStore::ExpectedVersion.none
+        stream_other,
+        version_none
       )
     end.to raise_error(RubyEventStore::EventDuplicatedInStream)
   end
@@ -910,32 +919,32 @@ RSpec.shared_examples :event_repository do |repository_class|
     skip unless test_link_events_to_stream
     repository.append_to_stream([
         SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-      ], RubyEventStore::Stream.new('stream'),
-      RubyEventStore::ExpectedVersion.none
-    ).link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
+      ], stream,
+      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", RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(0))
+      repository.link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", stream_flow, version_0)
     end.to raise_error(RubyEventStore::EventDuplicatedInStream)
   end
 
   it 'allows appending to GLOBAL_STREAM explicitly' do
     event = SRecord.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-    repository.append_to_stream(event, RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM), RubyEventStore::ExpectedVersion.any)
+    repository.append_to_stream(event, global_stream, version_any)
 
     expect(read_all_streams_forward(repository, :head, 10)).to eq([event])
   end
 
   specify "events not persisted if append failed" do
     repository.append_to_stream([
-      SRecord.new(event_id: SecureRandom.uuid),
-    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      SRecord.new,
+    ], stream, version_none)
 
     expect do
       repository.append_to_stream([
         SRecord.new(
           event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
         ),
-      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+      ], stream, version_none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
     expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
   end
@@ -943,8 +952,8 @@ RSpec.shared_examples :event_repository do |repository_class|
   specify 'reading particular event' do
     test_event = SRecord.new(event_id: "941cd8f5-b3f9-47af-b4e4-07f8cea37467")
     repository.
-      append_to_stream(SRecord.new, RubyEventStore::Stream.new("test"), RubyEventStore::ExpectedVersion.none).
-      append_to_stream(test_event, RubyEventStore::Stream.new("test"), RubyEventStore::ExpectedVersion.new(0))
+      append_to_stream(SRecord.new, stream_test, version_none).
+      append_to_stream(test_event, stream_test, version_0)
 
     expect(repository.read_event("941cd8f5-b3f9-47af-b4e4-07f8cea37467")).to eq(test_event)
   end
@@ -962,7 +971,7 @@ RSpec.shared_examples :event_repository do |repository_class|
   specify 'linking non-existent event' do
     skip unless test_link_events_to_stream
     expect do
-      repository.link_to_stream('72922e65-1b32-4e97-8023-03ae81dd3a27', RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.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(RubyEventStore::EventNotFound)
       expect(err.event_id).to eq('72922e65-1b32-4e97-8023-03ae81dd3a27')
@@ -971,7 +980,6 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   specify 'read returns enumerator' do
-    specification = RubyEventStore::Specification.new(repository)
     expect(repository.read(specification.result)).to be_kind_of(Enumerator)
   end
 
@@ -985,8 +993,110 @@ RSpec.shared_examples :event_repository do |repository_class|
 
     repository.append_to_stream(
       event = SRecord.new(data: binary, metadata: binary),
-      RubyEventStore::Stream.new('stream'),
+      stream,
+      version_none
+    )
+  end
+
+  specify do
+    events = Array.new(400) { SRecord.new }
+    repository.append_to_stream(
+      events[200...400],
+      RubyEventStore::Stream.new("Foo"),
+      RubyEventStore::ExpectedVersion.none
+    )
+    repository.append_to_stream(
+      events[0...200],
+      RubyEventStore::Stream.new("Dummy"),
       RubyEventStore::ExpectedVersion.none
     )
+
+    batches = repository.read(specification.stream("Dummy").in_batches.result).to_a
+    expect(batches.size).to eq(2)
+    expect(batches[0].size).to eq(100)
+    expect(batches[0]).to eq(events[0..99])
+  end
+
+  specify do
+    events = Array.new(200) { SRecord.new }
+    repository.append_to_stream(
+      events,
+      RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+      RubyEventStore::ExpectedVersion.any
+    )
+
+    batches = repository.read(specification.in_batches.result).to_a
+    expect(batches.size).to eq(2)
+    expect(batches[0].size).to eq(100)
+    expect(batches[0]).to eq(events[0..99])
+  end
+
+  specify do
+    events = Array.new(200) { SRecord.new }
+    repository.append_to_stream(
+      events,
+      RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+      RubyEventStore::ExpectedVersion.any
+    )
+
+    expect(repository.read(specification.in_batches(200).result).to_a.size).to eq(1)
+  end
+
+  specify do
+    events = Array.new(200) { SRecord.new }
+    repository.append_to_stream(
+      events,
+      RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+      RubyEventStore::ExpectedVersion.any
+    )
+
+    batches = repository.read(specification.limit(199).in_batches.result).to_a
+    expect(batches.size).to eq(2)
+    expect(batches[0].size).to eq(100)
+    expect(batches[0]).to eq(events[0..99])
+    expect(batches[1].size).to eq(99)
+    expect(batches[1]).to eq(events[100..198])
+  end
+
+  specify do
+    events = Array.new(200) { SRecord.new }
+    repository.append_to_stream(
+      events,
+      RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+      RubyEventStore::ExpectedVersion.any
+    )
+
+    batches = repository.read(specification.limit(99).in_batches.result).to_a
+    expect(batches.size).to eq(1)
+    expect(batches[0].size).to eq(99)
+    expect(batches[0]).to eq(events[0..98])
+  end
+
+  specify do
+    events = Array.new(200) { SRecord.new }
+    repository.append_to_stream(
+      events,
+      RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+      RubyEventStore::ExpectedVersion.any
+    )
+
+    batches = repository.read(specification.backward.limit(99).in_batches.result).to_a
+    expect(batches.size).to eq(1)
+    expect(batches[0].size).to eq(99)
+    expect(batches[0]).to eq(events[101..-1].reverse)
+  end
+
+  specify do
+    events = Array.new(200) { SRecord.new }
+    repository.append_to_stream(
+      events,
+      RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+      RubyEventStore::ExpectedVersion.any
+    )
+
+    batches = repository.read(specification.from(events[100].event_id).limit(99).in_batches.result).to_a
+    expect(batches.size).to eq(1)
+    expect(batches[0].size).to eq(99)
+    expect(batches[0]).to eq(events[101..199])
   end
 end