ruby_event_store 0.27.1 → 0.28.0

data/lib/ruby_event_store/mappers/default.rb

@@ -11,24 +11,24 @@ module RubyEventStore
       def event_to_serialized_record(domain_event)
         SerializedRecord.new(
           event_id:         domain_event.event_id,
-          metadata:   @serializer.dump(domain_event.metadata),
-          data:       @serializer.dump(domain_event.data),
+          metadata:   serializer.dump(domain_event.metadata.to_h),
+          data:       serializer.dump(domain_event.data),
           event_type: domain_event.class.name
         )
       end
 
       def serialized_record_to_event(record)
-        event_type = @events_class_remapping.fetch(record.event_type) { record.event_type }
+        event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
         Object.const_get(event_type).new(
           event_id: record.event_id,
-          metadata: @serializer.load(record.metadata),
-          data:     @serializer.load(record.data)
+          metadata: serializer.load(record.metadata),
+          data:     serializer.load(record.data)
         )
       end
 
-      def add_metadata(event, key, value)
-        event.metadata[key.to_sym] = value
-      end
+      private
+
+      attr_reader :serializer, :events_class_remapping
 
     end
   end

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -0,0 +1,15 @@
+module RubyEventStore
+  module Mappers
+    class NullMapper
+
+      def event_to_serialized_record(domain_event)
+        domain_event
+      end
+
+      def serialized_record_to_event(record)
+        record
+      end
+
+    end
+  end
+end

data/lib/ruby_event_store/mappers/protobuf.rb

@@ -1,35 +1,78 @@
 module RubyEventStore
+  class Proto < RubyEventStore::Event
+    def initialize(event_id: SecureRandom.uuid, metadata: nil, data:)
+      @event_id = event_id
+      @metadata = Metadata.new(metadata.to_h)
+      @data     = data
+    end
+
+    def type
+      data.class.descriptor.name
+    end
+
+    def encode_with(coder)
+      coder['event_id']   = event_id
+      coder['metadata']   = ProtobufNestedStruct::HashMapStringValue.dump(metadata.each_with_object({}){|(k,v),h| h[k.to_s] =v })
+      coder['data.proto'] = data.class.encode(data)
+      coder['data.type']  = type
+    end
+
+    def init_with(coder)
+      @event_id = coder['event_id']
+      @metadata = Metadata.new
+      ProtobufNestedStruct::HashMapStringValue.load(coder['metadata']).each_with_object(metadata){|(k,v),meta| meta[k.to_sym] = v }
+      @data = pool.lookup(coder['data.type']).msgclass.decode(coder['data.proto'])
+    end
+
+    def ==(other_event)
+      other_event.instance_of?(self.class) &&
+        other_event.event_id.eql?(event_id) &&
+        other_event.data == data # https://github.com/google/protobuf/issues/4455
+    end
+
+    private
+
+    def pool
+      Google::Protobuf::DescriptorPool.generated_pool
+    end
+  end
+
   module Mappers
     class Protobuf
-      def initialize(event_id_getter: :event_id, events_class_remapping: {})
-        @event_id_getter = event_id_getter
+      def initialize(events_class_remapping: {})
+        require_optional_dependency
         @events_class_remapping = events_class_remapping
       end
 
       def event_to_serialized_record(domain_event)
         SerializedRecord.new(
-          event_id:   domain_event.public_send(event_id_getter),
-          metadata:   "",
-          data:       domain_event.class.encode(domain_event),
-          event_type: domain_event.class.name
+          event_id:   domain_event.event_id,
+          metadata:   ProtobufNestedStruct::HashMapStringValue.dump(domain_event.metadata.each_with_object({}){|(k,v),h| h[k.to_s] =v }),
+          data:       domain_event.data.class.encode(domain_event.data),
+          event_type: domain_event.type
         )
       end
 
       def serialized_record_to_event(record)
         event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
-        Object.const_get(event_type).decode(record.data)
-      end
-
-      def add_metadata(event, key, value)
-        setter = "#{key}="
-        if event.respond_to?(setter)
-          event.public_send(setter, value)
+        data = Google::Protobuf::DescriptorPool.generated_pool.lookup(event_type).msgclass.decode(record.data)
+        Proto.new(
+          event_id: record.event_id,
+          data: data,
+        ).tap do |p|
+          ProtobufNestedStruct::HashMapStringValue.load(record.metadata).each_with_object(p.metadata) {|(k, v), meta| meta[k.to_sym] = v}
         end
       end
 
       private
 
       attr_reader :event_id_getter, :events_class_remapping
+
+      def require_optional_dependency
+        require 'protobuf_nested_struct'
+      rescue LoadError
+        raise LoadError, "cannot load such file -- protobuf_nested_struct. Add protobuf_nested_struct gem to Gemfile"
+      end
     end
   end
 end

data/lib/ruby_event_store/metadata.rb

@@ -0,0 +1,51 @@
+require 'date'
+require 'time'
+require 'forwardable'
+
+module RubyEventStore
+  class Metadata
+    include Enumerable
+    extend  Forwardable
+
+    def initialize(h = self)
+      @h = {}
+      h.each do |k, v|
+        self[k] = (v)
+      end
+    end
+
+    def [](key)
+      raise ArgumentError unless Symbol === key
+      @h[key]
+    end
+
+    def []=(key, val)
+      raise ArgumentError unless allowed_types.any?{|klass| klass === val }
+      raise ArgumentError unless Symbol === key
+      @h[key]=val
+    end
+
+    def each(&block)
+      @h.each(&block)
+    end
+
+    SAFE_HASH_METHODS = [:<, :<=, :>, :>=, :assoc, :clear, :compact, :compact!,
+      :delete, :delete_if, :dig, :each_key, :each_pair,
+      :each_value, :empty?, :fetch, :fetch_values,
+      :flatten, :has_key?, :has_value?,
+      :keep_if, :key, :key?, :keys, :length,
+      :rassoc, :reject!, :select!, :shift, :size, :slice,
+      :to_proc, :transform_keys, :transform_values,
+      :value?, :values, :values_at]
+
+    delegate SAFE_HASH_METHODS => :@h
+
+    private
+
+    def allowed_types
+      [String, Integer, Float, Date, Time, TrueClass, FalseClass]
+    end
+
+    private_constant :SAFE_HASH_METHODS
+  end
+end

data/lib/ruby_event_store/pub_sub/broker.rb

@@ -24,27 +24,27 @@ module RubyEventStore
 
       def add_global_subscriber(subscriber)
         verify_subscriber(subscriber)
-        @global_subscribers << subscriber
+        global_subscribers << subscriber
 
-        ->() { @global_subscribers.delete(subscriber) }
+        ->() { global_subscribers.delete(subscriber) }
       end
 
       def add_thread_global_subscriber(subscriber)
         verify_subscriber(subscriber)
-        @thread_global_subscribers.value += [subscriber]
+        thread_global_subscribers.value += [subscriber]
 
-        ->() { @thread_global_subscribers.value -= [subscriber] }
+        ->() { thread_global_subscribers.value -= [subscriber] }
       end
 
       def add_thread_subscriber(subscriber, event_types)
         verify_subscriber(subscriber)
-        event_types.each{ |type| @thread_subscribers.value[type.name] << subscriber }
-        ->() {event_types.each{ |type| @thread_subscribers.value.fetch(type.name).delete(subscriber) } }
+        event_types.each{ |type| thread_subscribers.value[type.to_s] << subscriber }
+        ->() {event_types.each{ |type| thread_subscribers.value.fetch(type.to_s).delete(subscriber) } }
       end
 
       def notify_subscribers(event)
-        all_subscribers_for(event.class).each do |subscriber|
-          @dispatcher.call(subscriber, event)
+        all_subscribers_for(event.type).each do |subscriber|
+          dispatcher.call(subscriber, event)
         end
       end
 
@@ -52,20 +52,22 @@ module RubyEventStore
 
       def verify_subscriber(subscriber)
         raise SubscriberNotExist if subscriber.nil?
-        @dispatcher.verify(subscriber)
+        dispatcher.verify(subscriber)
       end
 
       def subscribe(subscriber, event_types)
-        event_types.each{ |type| @subscribers[type.name] << subscriber }
-        ->() {event_types.each{ |type| @subscribers.fetch(type.name).delete(subscriber) } }
+        event_types.each{ |type| subscribers[type.to_s] << subscriber }
+        ->() {event_types.each{ |type| subscribers.fetch(type.to_s).delete(subscriber) } }
       end
 
       def all_subscribers_for(event_type)
-        @subscribers[event_type.name] +
-        @global_subscribers +
-        @thread_global_subscribers.value +
-        @thread_subscribers.value[event_type.name]
+        subscribers[event_type] +
+        global_subscribers +
+        thread_global_subscribers.value +
+        thread_subscribers.value[event_type]
       end
+
+      attr_reader :dispatcher, :subscribers, :global_subscribers, :thread_global_subscribers, :thread_subscribers
     end
   end
 end

data/lib/ruby_event_store/serialized_record.rb

@@ -11,5 +11,35 @@ module RubyEventStore
     end
 
     attr_reader :event_id, :data, :metadata, :event_type
+
+    BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110011
+    def hash
+      [
+        self.class,
+        event_id,
+        data,
+        metadata,
+        event_type,
+      ].hash ^ BIG_VALUE
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) &&
+        other.event_id.eql?(event_id) &&
+        other.data.eql?(data) &&
+        other.metadata.eql?(metadata) &&
+        other.event_type.eql?(event_type)
+    end
+
+    def to_h
+      {
+        event_id: event_id,
+        data: data,
+        metadata: metadata,
+        event_type: event_type,
+      }
+    end
+
+    alias_method :eql?, :==
   end
 end

data/lib/ruby_event_store/spec/event_broker_lint.rb

@@ -186,6 +186,17 @@ RSpec.shared_examples :event_broker do |broker_class|
     expect(dispatcher.dispatched).to eq([{subscriber: handler, event: event1}])
   end
 
+  it 'subscribes by type of event which is a String' do
+    handler         = TestHandler.new
+    broker.add_subscriber(handler, ["Test1DomainEvent"])
+    broker.add_thread_subscriber(handler, ["Test1DomainEvent"])
+
+    event1 = Test1DomainEvent.new
+    broker.notify_subscribers(event1)
+
+    expect(handler.events).to eq([event1,event1])
+  end
+
   private
 
   class HandlerClass

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -1,256 +1,319 @@
-TestDomainEvent = Class.new(RubyEventStore::Event)
+class SRecord
+  def self.new(
+    event_id:   SecureRandom.uuid,
+    data:       SecureRandom.uuid,
+    metadata:   SecureRandom.uuid,
+    event_type: SecureRandom.uuid
+  )
+    RubyEventStore::SerializedRecord.new(
+      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 }
 
-  it 'just created is empty' do
-    expect(repository.read_all_streams_forward(:head, 1)).to be_empty
+  def read_stream_events_forward(repository, stream)
+    specification = RubyEventStore::Specification.new(repository)
+    repository.read(
+      specification
+        .stream(stream.name)
+        .result
+    ).to_a
+  end
+
+  def read_stream_events_backward(repository, stream)
+    specification = RubyEventStore::Specification.new(repository)
+    repository.read(
+      specification
+        .stream(stream.name)
+        .backward
+        .result
+    ).to_a
+  end
+
+  def read_events_forward(repository, stream, start, count)
+    specification = RubyEventStore::Specification.new(repository)
+    repository.read(
+      specification
+        .stream(stream.name)
+        .from(start)
+        .limit(count)
+        .result
+    ).to_a
+  end
+
+  def read_events_backward(repository, stream, start, count)
+    specification = RubyEventStore::Specification.new(repository)
+    repository.read(
+      specification
+        .stream(stream.name)
+        .from(start)
+        .limit(count)
+        .backward
+        .result
+    ).to_a
+  end
+
+  def read_all_streams_forward(repository, start, count)
+    specification = RubyEventStore::Specification.new(repository)
+    repository.read(
+      specification
+        .from(start)
+        .limit(count)
+        .result
+    ).to_a
+  end
+
+  def read_all_streams_backward(repository, start, count)
+    specification = RubyEventStore::Specification.new(repository)
+    repository.read(
+      specification
+        .from(start)
+        .limit(count)
+        .backward
+        .result
+    ).to_a
   end
 
-  specify 'append_to_stream fail if expected version is nil' do
-    expect do
-      repository.append_to_stream(event = TestDomainEvent.new, 'stream', nil)
-    end.to raise_error(RubyEventStore::InvalidExpectedVersion)
-  end
-
-  specify 'link_to_stream fail if expected version is nil' do
-    skip unless test_link_events_to_stream
-    repository.append_to_stream(event = TestDomainEvent.new, 'stream', :any)
-    expect do
-      repository.link_to_stream(event.event_id, 'stream', nil)
-    end.to raise_error(RubyEventStore::InvalidExpectedVersion)
+  it 'just created is empty' do
+    expect(read_all_streams_forward(repository, :head, 1)).to be_empty
   end
 
   specify 'append_to_stream returns self' do
     repository.
-      append_to_stream(event = TestDomainEvent.new, 'stream', -1).
-      append_to_stream(event = TestDomainEvent.new, 'stream', 0)
+      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))
   end
 
   specify 'link_to_stream returns self' do
     skip unless test_link_events_to_stream
-    event0 = TestDomainEvent.new
-    event1 = TestDomainEvent.new
+    event0 = SRecord.new
+    event1 = SRecord.new
     repository.
-      append_to_stream([event0, event1], 'stream0', -1).
-      link_to_stream(event0.event_id, 'flow', -1).
-      link_to_stream(event1.event_id, 'flow', 0)
+      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))
   end
 
   specify 'adds an initial event to a new stream' do
-    repository.append_to_stream(event = TestDomainEvent.new, 'stream', :none)
-    expect(repository.read_all_streams_forward(:head, 1).first).to eq(event)
-    expect(repository.read_stream_events_forward('stream').first).to eq(event)
-    expect(repository.read_stream_events_forward('other_stream')).to be_empty
+    repository.append_to_stream(event = SRecord.new, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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
   end
 
   specify 'links an initial event to a new stream' do
     skip unless test_link_events_to_stream
     repository.
-      append_to_stream(event = TestDomainEvent.new, 'stream', :none).
-      link_to_stream(event.event_id, 'flow', :none)
+      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)
 
-    expect(repository.read_all_streams_forward(:head, 1).first).to eq(event)
-    expect(repository.read_stream_events_forward('stream').first).to eq(event)
-    expect(repository.read_stream_events_forward('flow')).to eq([event])
-    expect(repository.read_stream_events_forward('other')).to be_empty
+    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
   end
 
   specify 'adds multiple initial events to a new stream' do
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
-    expect(repository.read_all_streams_forward(:head, 2)).to eq([event0, event1])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1])
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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])
   end
 
   specify 'links multiple initial events to a new stream' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none).link_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.event_id,
       event1.event_id,
-    ], 'flow', :none)
-    expect(repository.read_all_streams_forward(:head, 2)).to eq([event0, event1])
-    expect(repository.read_stream_events_forward('flow')).to eq([event0, event1])
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.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])
   end
 
   specify 'correct expected version on second write' do
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', 1)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(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])
   end
 
   specify 'correct expected version on second link' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none).append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'flow', :none).link_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.event_id,
       event1.event_id,
-    ], 'flow', 1)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
-    expect(repository.read_stream_events_forward('flow')).to eq([event2, event3, event0, event1])
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(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])
   end
 
   specify 'incorrect expected version on second write' do
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     expect do
       repository.append_to_stream([
-        event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-        event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      ], 'stream', 0)
+        event2 = SRecord.new(event_id: SecureRandom.uuid),
+        event3 = SRecord.new(event_id: SecureRandom.uuid),
+      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(0))
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
 
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1])
+    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])
   end
 
   specify 'incorrect expected version on second link' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'other', -1)
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new("other"), RubyEventStore::ExpectedVersion.none)
     expect do
       repository.link_to_stream([
         event2.event_id,
         event3.event_id,
-      ], 'stream', 0)
+      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(0))
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
 
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1])
+    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])
   end
 
   specify ':none on first and subsequent write' do
     repository.append_to_stream([
-      eventA = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      eventA = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     expect do
       repository.append_to_stream([
-        eventB = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      ], 'stream', :none)
+        eventB = SRecord.new(event_id: SecureRandom.uuid),
+      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
-    expect(repository.read_all_streams_forward(:head, 1)).to eq([eventA])
-    expect(repository.read_stream_events_forward('stream')).to eq([eventA])
+    expect(read_all_streams_forward(repository, :head, 1)).to eq([eventA])
+    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      eventB = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      eventA = SRecord.new(event_id: SecureRandom.uuid),
+      eventB = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
 
-    repository.link_to_stream([eventA.event_id], 'flow', :none)
+    repository.link_to_stream([eventA.event_id], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
     expect do
-      repository.link_to_stream([eventB.event_id], 'flow', :none)
+      repository.link_to_stream([eventB.event_id], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
 
-    expect(repository.read_all_streams_forward(:head, 1)).to eq([eventA])
-    expect(repository.read_stream_events_forward('flow')).to eq([eventA])
+    expect(read_all_streams_forward(repository, :head, 1)).to eq([eventA])
+    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("flow"))).to eq([eventA])
   end
 
   specify ':any allows stream with best-effort order and no guarantee' do
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :any)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :any)
-    expect(repository.read_all_streams_forward(:head, 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
-    expect(repository.read_stream_events_forward('stream').to_set).to eq(Set.new([event0, event1, event2, event3]))
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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]))
   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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :any)
+      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)
 
     repository.link_to_stream([
       event0.event_id, event1.event_id,
-    ], 'flow', :any)
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
     repository.link_to_stream([
       event2.event_id, event3.event_id,
-    ], 'flow', :any)
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
 
-    expect(repository.read_all_streams_forward(:head, 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
-    expect(repository.read_stream_events_forward('flow').to_set).to eq(Set.new([event0, event1, event2, event3]))
+    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]))
   end
 
   specify ':auto queries for last position in given stream' do
     skip unless test_expected_version_auto
     repository.append_to_stream([
-      eventA = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      eventB = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      eventC = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'another', :auto)
+      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)
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', 1)
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      eventB = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      eventC = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'another', :auto)
+      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)
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     repository.link_to_stream([
       eventA.event_id,
       eventB.event_id,
       eventC.event_id,
-    ], 'stream', 1)
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(1))
   end
 
   specify ':auto starts from 0' do
     skip unless test_expected_version_auto
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     expect do
       repository.append_to_stream([
-        event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      ], 'stream', -1)
+        event1 = SRecord.new(event_id: SecureRandom.uuid),
+      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
   end
 
@@ -258,15 +321,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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'whatever', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new("whatever"), RubyEventStore::ExpectedVersion.auto)
     repository.link_to_stream([
       event0.event_id,
-    ], 'stream', :auto)
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     expect do
       repository.append_to_stream([
-        event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      ], 'stream', -1)
+        event1 = SRecord.new(event_id: SecureRandom.uuid),
+      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
   end
 
@@ -275,105 +338,105 @@ 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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
+    expect(read_all_streams_forward(repository, :head, 4)).to eq([
       event0, event1,
       event2, event3
     ])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new('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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      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)
     repository.link_to_stream([
       event0.event_id, event1.event_id,
-    ], 'flow', :auto)
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
     repository.link_to_stream([
       event2.event_id, event3.event_id,
-    ], 'flow', :auto)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
+    expect(read_all_streams_forward(repository, :head, 4)).to eq([
       event0, event1,
       event2, event3
     ])
-    expect(repository.read_stream_events_forward('flow')).to eq([event0, event1, event2, event3])
+    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', 1)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(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])
   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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     repository.link_to_stream([
       event0.event_id,
-    ], 'flow', :auto)
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.auto)
     repository.link_to_stream([
       event1.event_id,
-    ], 'flow', 0)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1,])
-    expect(repository.read_stream_events_forward('flow')).to eq([event0, event1,])
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(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,])
   end
 
   specify 'manual is compatible with auto expectation' do
     skip unless test_expected_version_auto
     repository.append_to_stream([
-      event0 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     repository.append_to_stream([
-      event2 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event3 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1, event2, event3])
-    expect(repository.read_stream_events_forward('stream')).to eq([event0, event1, event2, event3])
+      event2 = SRecord.new(event_id: SecureRandom.uuid),
+      event3 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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])
   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 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-      event1 = TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :auto)
+      event0 = SRecord.new(event_id: SecureRandom.uuid),
+      event1 = SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
     repository.link_to_stream([
       event0.event_id,
-    ], 'flow', :none)
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.none)
     repository.link_to_stream([
       event1.event_id,
-    ], 'flow', :auto)
-    expect(repository.read_all_streams_forward(:head, 4)).to eq([event0, event1])
-    expect(repository.read_stream_events_forward('flow')).to eq([event0, event1])
+    ], RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.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])
   end
 
-  specify 'unlimited concurrency for :any - everything should succeed' do
+  specify 'unlimited concurrency for :any - everything should succeed', timeout: 10, mutant: false do
     skip unless test_race_conditions_any
     verify_conncurency_assumptions
     begin
@@ -389,8 +452,8 @@ RSpec.shared_examples :event_repository do |repository_class|
             100.times do |j|
               eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
               repository.append_to_stream([
-                TestDomainEvent.new(event_id: eid),
-              ], 'stream', :any)
+                SRecord.new(event_id: eid),
+              ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
             end
           rescue RubyEventStore::WrongExpectedEventVersion
             fail_occurred = true
@@ -400,8 +463,8 @@ RSpec.shared_examples :event_repository do |repository_class|
       wait_for_it = false
       threads.each(&:join)
       expect(fail_occurred).to eq(false)
-      expect(repository.read_stream_events_forward('stream').size).to eq(400)
-      events_in_stream = repository.read_stream_events_forward('stream')
+      expect(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(events_in_stream.size).to eq(400)
       events0 = events_in_stream.select do |ev|
         ev.event_id.start_with?("0-")
@@ -412,7 +475,7 @@ RSpec.shared_examples :event_repository do |repository_class|
     end
   end
 
-  specify 'unlimited concurrency for :any - everything should succeed when linking' do
+  specify 'unlimited concurrency for :any - everything should succeed when linking', timeout: 10, mutant: false do
     skip unless test_race_conditions_any
     skip unless test_link_events_to_stream
     verify_conncurency_assumptions
@@ -426,8 +489,8 @@ RSpec.shared_examples :event_repository do |repository_class|
         100.times do |j|
           eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
           repository.append_to_stream([
-            TestDomainEvent.new(event_id: eid),
-          ], 'stream', :any)
+            SRecord.new(event_id: eid),
+          ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
         end
       end
 
@@ -437,7 +500,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, 'flow', :any)
+              repository.link_to_stream(eid, RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.any)
             end
           rescue RubyEventStore::WrongExpectedEventVersion
             fail_occurred = true
@@ -447,8 +510,8 @@ RSpec.shared_examples :event_repository do |repository_class|
       wait_for_it = false
       threads.each(&:join)
       expect(fail_occurred).to eq(false)
-      expect(repository.read_stream_events_forward('flow').size).to eq(400)
-      events_in_stream = repository.read_stream_events_forward('flow')
+      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(events_in_stream.size).to eq(400)
       events0 = events_in_stream.select do |ev|
         ev.event_id.start_with?("0-")
@@ -476,8 +539,8 @@ RSpec.shared_examples :event_repository do |repository_class|
             begin
               eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
               repository.append_to_stream([
-                TestDomainEvent.new(event_id: eid),
-              ], 'stream', :auto)
+                SRecord.new(event_id: eid),
+              ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
               sleep(rand(concurrency_level) / 1000.0)
             rescue RubyEventStore::WrongExpectedEventVersion
               fail_occurred +=1
@@ -488,7 +551,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 = repository.read_stream_events_forward('stream')
+      events_in_stream = read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))
       expect(events_in_stream.size).to be < 400
       expect(events_in_stream.size).to be >= 100
       events0 = events_in_stream.select do |ev|
@@ -514,8 +577,8 @@ RSpec.shared_examples :event_repository do |repository_class|
         100.times do |j|
           eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
           repository.append_to_stream([
-            TestDomainEvent.new(event_id: eid),
-          ], 'whatever', :any)
+            SRecord.new(event_id: eid),
+          ], RubyEventStore::Stream.new("whatever"), RubyEventStore::ExpectedVersion.any)
         end
       end
 
@@ -528,7 +591,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, 'stream', :auto)
+              repository.link_to_stream(eid, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.auto)
               sleep(rand(concurrency_level) / 1000.0)
             rescue RubyEventStore::WrongExpectedEventVersion
               fail_occurred +=1
@@ -539,7 +602,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 = repository.read_stream_events_forward('stream')
+      events_in_stream = read_stream_events_forward(repository, RubyEventStore::Stream.new('stream'))
       expect(events_in_stream.size).to be < 400
       expect(events_in_stream.size).to be >= 100
       events0 = events_in_stream.select do |ev|
@@ -553,253 +616,292 @@ RSpec.shared_examples :event_repository do |repository_class|
   end
 
   it 'appended event is stored in given stream' do
-    expected_event = TestDomainEvent.new(data: {})
-    repository.append_to_stream(expected_event, 'stream', :any)
-    expect(repository.read_all_streams_forward(:head, 1).first).to eq(expected_event)
-    expect(repository.read_stream_events_forward('stream').first).to eq(expected_event)
-    expect(repository.read_stream_events_forward('other_stream')).to be_empty
+    expected_event = SRecord.new
+    repository.append_to_stream(expected_event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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
   end
 
   it 'data attributes are retrieved' do
-    event = TestDomainEvent.new(data: { order_id: 3 })
-    repository.append_to_stream(event, 'stream', :any)
-    retrieved_event = repository.read_all_streams_forward(:head, 1).first
-    expect(retrieved_event.data[:order_id]).to eq(3)
+    event = SRecord.new(data: "{ order_id: 3 }")
+    repository.append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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 = TestDomainEvent.new(metadata: { request_id: 3 })
-    repository.append_to_stream(event, 'stream', :any)
-    retrieved_event = repository.read_all_streams_forward(:head, 1).first
-    expect(retrieved_event.metadata[:request_id]).to eq(3)
+    event = SRecord.new(metadata: "{ request_id: 3 }")
+    repository.append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.any)
+    retrieved_event = read_all_streams_forward(repository, :head, 1).first
+    expect(retrieved_event.metadata).to eq("{ request_id: 3 }")
   end
 
   it 'data and metadata attributes are retrieved when linking' do
     skip unless test_link_events_to_stream
-    event = TestDomainEvent.new(
-      data: { order_id: 3 },
-      metadata: { request_id: 4 }
+    event = SRecord.new(
+      data: "{ order_id: 3 }",
+      metadata: "{ request_id: 4 }",
     )
     repository.
-      append_to_stream(event, 'stream', :any).
-      link_to_stream(event.event_id, 'flow', :any)
-    retrieved_event = repository.read_stream_events_forward('flow').first
-    expect(retrieved_event.metadata[:request_id]).to eq(4)
-    expect(retrieved_event.data[:order_id]).to eq(3)
+      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
+    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 = TestDomainEvent.new, 'stream', -1)
-    repository.append_to_stream(e2 = TestDomainEvent.new, 'other_stream', -1)
+    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.delete_stream('stream')
-    expect(repository.read_stream_events_forward('stream')).to be_empty
-    expect(repository.read_stream_events_forward('other_stream')).to eq([e2])
-    expect(repository.read_all_streams_forward(:head, 10)).to eq([e1,e2])
+    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])
+    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 = TestDomainEvent.new, 'stream', -1).
-      link_to_stream(e1.event_id, 'flow', -1)
+      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)
 
-    repository.delete_stream('flow')
-    expect(repository.read_stream_events_forward('flow')).to be_empty
-    expect(repository.read_all_streams_forward(:head, 10)).to eq([e1])
+    repository.delete_stream(RubyEventStore::Stream.new("flow"))
+    expect(read_stream_events_forward(repository, RubyEventStore::Stream.new("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(TestDomainEvent.new(event_id: just_an_id), 'stream', -1)
+    repository.append_to_stream(SRecord.new(event_id: just_an_id), RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.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('stream')
+    repository.delete_stream(RubyEventStore::Stream.new('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(TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000001'), 'stream', -1)
-    repository.append_to_stream(TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000002'), 'stream', 0)
+    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))
 
-    expect(repository.last_stream_event('stream')).to eq(TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000002'))
-    expect(repository.last_stream_event('other_stream')).to be_nil
+    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
   end
 
   it 'knows last event in stream when linked' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-        e0 = TestDomainEvent.new(event_id: '00000000-0000-0000-0000-000000000001'),
-        e1 = TestDomainEvent.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',
-      -1
-    ).link_to_stream([e1.event_id, e0.event_id], 'flow', -1)
-    expect(repository.last_stream_event('flow')).to eq(e0)
+      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)
   end
 
   it 'reads batch of events from stream forward & backward' do
-    event_ids = ["96c920b1-cdd0-40f4-907c-861b9fff7d02", "56404f79-0ba0-4aa0-8524-dc3436368ca0", "6a54dd21-f9d8-4857-a195-f5588d9e406c", "0e50a9cd-f981-4e39-93d5-697fc7285b98", "d85589bc-b993-41d4-812f-fc631d9185d5", "96bdacda-77dd-4d7d-973d-cbdaa5842855", "94688199-e6b7-4180-bf8e-825b6808e6cc", "68fab040-741e-4bc2-9cca-5b8855b0ca19", "ab60114c-011d-4d58-ab31-7ba65d99975e", "868cac42-3d19-4b39-84e8-cd32d65c2445"]
-    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
-    repository.append_to_stream(TestDomainEvent.new, 'other_stream', -1)
+    events = %w[
+      96c920b1-cdd0-40f4-907c-861b9fff7d02
+      56404f79-0ba0-4aa0-8524-dc3436368ca0
+      6a54dd21-f9d8-4857-a195-f5588d9e406c
+      0e50a9cd-f981-4e39-93d5-697fc7285b98
+      d85589bc-b993-41d4-812f-fc631d9185d5
+      96bdacda-77dd-4d7d-973d-cbdaa5842855
+      94688199-e6b7-4180-bf8e-825b6808e6cc
+      68fab040-741e-4bc2-9cca-5b8855b0ca19
+      ab60114c-011d-4d58-ab31-7ba65d99975e
+      868cac42-3d19-4b39-84e8-cd32d65c2445
+    ].map { |id| SRecord.new(event_id: id) }
+    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.none)
     events.each.with_index do |event, index|
-      repository.append_to_stream(event, 'stream', index - 1)
+      repository.append_to_stream(event, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.new(index - 1))
     end
-    repository.append_to_stream(TestDomainEvent.new, 'other_stream', 0)
+    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.new(0))
 
-    expect(repository.read_events_forward('stream', :head, 3)).to eq(events.first(3))
-    expect(repository.read_events_forward('stream', :head, 100)).to eq(events)
-    expect(repository.read_events_forward('stream', events[4].event_id, 4)).to eq(events[5..8])
-    expect(repository.read_events_forward('stream', events[4].event_id, 100)).to eq(events[5..9])
+    expect(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(repository.read_events_backward('stream', :head, 3)).to eq(events.last(3).reverse)
-    expect(repository.read_events_backward('stream', :head, 100)).to eq(events.reverse)
-    expect(repository.read_events_backward('stream', events[4].event_id, 4)).to eq(events.first(4).reverse)
-    expect(repository.read_events_backward('stream', events[4].event_id, 100)).to eq(events.first(4).reverse)
+    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)
   end
 
   it 'reads batch of linked events from stream forward & backward' do
     skip unless test_link_events_to_stream
-    event_ids = ["96c920b1-cdd0-40f4-907c-861b9fff7d02", "56404f79-0ba0-4aa0-8524-dc3436368ca0", "6a54dd21-f9d8-4857-a195-f5588d9e406c", "0e50a9cd-f981-4e39-93d5-697fc7285b98", "d85589bc-b993-41d4-812f-fc631d9185d5", "96bdacda-77dd-4d7d-973d-cbdaa5842855", "94688199-e6b7-4180-bf8e-825b6808e6cc", "68fab040-741e-4bc2-9cca-5b8855b0ca19", "ab60114c-011d-4d58-ab31-7ba65d99975e", "868cac42-3d19-4b39-84e8-cd32d65c2445"]
-    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
-    repository.append_to_stream(TestDomainEvent.new, 'other_stream', -1)
+    events = %w[
+      96c920b1-cdd0-40f4-907c-861b9fff7d02
+      56404f79-0ba0-4aa0-8524-dc3436368ca0
+      6a54dd21-f9d8-4857-a195-f5588d9e406c
+      0e50a9cd-f981-4e39-93d5-697fc7285b98
+      d85589bc-b993-41d4-812f-fc631d9185d5
+      96bdacda-77dd-4d7d-973d-cbdaa5842855
+      94688199-e6b7-4180-bf8e-825b6808e6cc
+      68fab040-741e-4bc2-9cca-5b8855b0ca19
+      ab60114c-011d-4d58-ab31-7ba65d99975e
+      868cac42-3d19-4b39-84e8-cd32d65c2445
+    ].map { |id| SRecord.new(event_id: id) }
+    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.none)
     events.each.with_index do |event, index|
       repository.
-        append_to_stream(event, 'stream', index - 1).
-        link_to_stream(event.event_id, 'flow', index - 1)
+        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))
     end
-    repository.append_to_stream(TestDomainEvent.new, 'other_stream', 0)
+    repository.append_to_stream(SRecord.new, RubyEventStore::Stream.new("other_stream"), RubyEventStore::ExpectedVersion.new(0))
 
-    expect(repository.read_events_forward('flow', :head, 3)).to eq(events.first(3))
-    expect(repository.read_events_forward('flow', :head, 100)).to eq(events)
-    expect(repository.read_events_forward('flow', events[4].event_id, 4)).to eq(events[5..8])
-    expect(repository.read_events_forward('flow', events[4].event_id, 100)).to eq(events[5..9])
+    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(repository.read_events_backward('flow', :head, 3)).to eq(events.last(3).reverse)
-    expect(repository.read_events_backward('flow', :head, 100)).to eq(events.reverse)
-    expect(repository.read_events_backward('flow', events[4].event_id, 4)).to eq(events.first(4).reverse)
-    expect(repository.read_events_backward('flow', events[4].event_id, 100)).to eq(events.first(4).reverse)
+    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)
   end
 
   it 'reads all stream events forward & backward' do
-    s1 = 'stream'
-    s2 = 'other_stream'
+    s1 = RubyEventStore::Stream.new('stream')
+    s2 = RubyEventStore::Stream.new("other_stream")
     repository.
-      append_to_stream(a = TestDomainEvent.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, -1).
-      append_to_stream(b = TestDomainEvent.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s2, -1).
-      append_to_stream(c = TestDomainEvent.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, 0).
-      append_to_stream(d = TestDomainEvent.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s2, 0).
-      append_to_stream(e = TestDomainEvent.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s2, 1)
+      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))
 
-    expect(repository.read_stream_events_forward(s1)).to eq [a,c]
-    expect(repository.read_stream_events_backward(s1)).to eq [c,a]
+    expect(read_stream_events_forward(repository, s1)).to eq [a,c]
+    expect(read_stream_events_backward(repository, s1)).to eq [c,a]
   end
 
   it 'reads all stream linked events forward & backward' do
     skip unless test_link_events_to_stream
-    s1, fs1, fs2 = 'stream', 'flow', 'other_flow'
+    s1, fs1, fs2 = RubyEventStore::Stream.new('stream'), RubyEventStore::Stream.new("flow"), RubyEventStore::Stream.new("other_flow")
     repository.
-      append_to_stream(a = TestDomainEvent.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, -1).
-      append_to_stream(b = TestDomainEvent.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5'), s1, 0).
-      append_to_stream(c = TestDomainEvent.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, 1).
-      append_to_stream(d = TestDomainEvent.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s1, 2).
-      append_to_stream(e = TestDomainEvent.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s1, 3).
-      link_to_stream('7010d298-ab69-4bb1-9251-f3466b5d1282', fs1, -1).
-      link_to_stream('34f88aca-aaba-4ca0-9256-8017b47528c5', fs2, -1).
-      link_to_stream('8e61c864-ceae-4684-8726-97c34eb8fc4f', fs1, 0).
-      link_to_stream('30963ed9-6349-450b-ac9b-8ea50115b3bd', fs2, 0).
-      link_to_stream('5bdc58b7-e8a7-4621-afd6-ccb828d72457', fs2, 1)
+      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))
 
-    expect(repository.read_stream_events_forward(fs1)).to eq [a,c]
-    expect(repository.read_stream_events_backward(fs1)).to eq [c,a]
+    expect(read_stream_events_forward(repository, fs1)).to eq [a,c]
+    expect(read_stream_events_backward(repository, fs1)).to eq [c,a]
   end
 
   it 'reads batch of events from all streams forward & backward' do
-    event_ids = ["96c920b1-cdd0-40f4-907c-861b9fff7d02", "56404f79-0ba0-4aa0-8524-dc3436368ca0", "6a54dd21-f9d8-4857-a195-f5588d9e406c", "0e50a9cd-f981-4e39-93d5-697fc7285b98", "d85589bc-b993-41d4-812f-fc631d9185d5", "96bdacda-77dd-4d7d-973d-cbdaa5842855", "94688199-e6b7-4180-bf8e-825b6808e6cc", "68fab040-741e-4bc2-9cca-5b8855b0ca19", "ab60114c-011d-4d58-ab31-7ba65d99975e", "868cac42-3d19-4b39-84e8-cd32d65c2445"]
-    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
+    events = %w[
+      96c920b1-cdd0-40f4-907c-861b9fff7d02
+      56404f79-0ba0-4aa0-8524-dc3436368ca0
+      6a54dd21-f9d8-4857-a195-f5588d9e406c
+      0e50a9cd-f981-4e39-93d5-697fc7285b98
+      d85589bc-b993-41d4-812f-fc631d9185d5
+      96bdacda-77dd-4d7d-973d-cbdaa5842855
+      94688199-e6b7-4180-bf8e-825b6808e6cc
+      68fab040-741e-4bc2-9cca-5b8855b0ca19
+      ab60114c-011d-4d58-ab31-7ba65d99975e
+      868cac42-3d19-4b39-84e8-cd32d65c2445
+    ].map { |id| SRecord.new(event_id: id) }
     events.each do |ev|
-      repository.append_to_stream(ev, SecureRandom.uuid, -1)
+      repository.append_to_stream(ev, RubyEventStore::Stream.new(SecureRandom.uuid), RubyEventStore::ExpectedVersion.none)
     end
 
-    expect(repository.read_all_streams_forward(:head, 3)).to eq(events.first(3))
-    expect(repository.read_all_streams_forward(:head, 100)).to eq(events)
-    expect(repository.read_all_streams_forward(events[4].event_id, 4)).to eq(events[5..8])
-    expect(repository.read_all_streams_forward(events[4].event_id, 100)).to eq(events[5..9])
+    expect(read_all_streams_forward(repository, :head, 3)).to eq(events.first(3))
+    expect(read_all_streams_forward(repository, :head, 100)).to eq(events)
+    expect(read_all_streams_forward(repository, events[4].event_id, 4)).to eq(events[5..8])
+    expect(read_all_streams_forward(repository, events[4].event_id, 100)).to eq(events[5..9])
 
-    expect(repository.read_all_streams_backward(:head, 3)).to eq(events.last(3).reverse)
-    expect(repository.read_all_streams_backward(:head, 100)).to eq(events.reverse)
-    expect(repository.read_all_streams_backward(events[4].event_id, 4)).to eq(events.first(4).reverse)
-    expect(repository.read_all_streams_backward(events[4].event_id, 100)).to eq(events.first(4).reverse)
+    expect(read_all_streams_backward(repository, :head, 3)).to eq(events.last(3).reverse)
+    expect(read_all_streams_backward(repository, :head, 100)).to eq(events.reverse)
+    expect(read_all_streams_backward(repository, events[4].event_id, 4)).to eq(events.first(4).reverse)
+    expect(read_all_streams_backward(repository, events[4].event_id, 100)).to eq(events.first(4).reverse)
   end
 
   it 'linked events do not affect reading from all streams - no duplicates' do
     skip unless test_link_events_to_stream
-    event_ids = ["96c920b1-cdd0-40f4-907c-861b9fff7d02", "56404f79-0ba0-4aa0-8524-dc3436368ca0", "6a54dd21-f9d8-4857-a195-f5588d9e406c", "0e50a9cd-f981-4e39-93d5-697fc7285b98", "d85589bc-b993-41d4-812f-fc631d9185d5", "96bdacda-77dd-4d7d-973d-cbdaa5842855", "94688199-e6b7-4180-bf8e-825b6808e6cc", "68fab040-741e-4bc2-9cca-5b8855b0ca19", "ab60114c-011d-4d58-ab31-7ba65d99975e", "868cac42-3d19-4b39-84e8-cd32d65c2445"]
-    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
+    events = %w[
+      96c920b1-cdd0-40f4-907c-861b9fff7d02
+      56404f79-0ba0-4aa0-8524-dc3436368ca0
+      6a54dd21-f9d8-4857-a195-f5588d9e406c
+      0e50a9cd-f981-4e39-93d5-697fc7285b98
+      d85589bc-b993-41d4-812f-fc631d9185d5
+      96bdacda-77dd-4d7d-973d-cbdaa5842855
+      94688199-e6b7-4180-bf8e-825b6808e6cc
+      68fab040-741e-4bc2-9cca-5b8855b0ca19
+      ab60114c-011d-4d58-ab31-7ba65d99975e
+      868cac42-3d19-4b39-84e8-cd32d65c2445
+    ].map { |id| SRecord.new(event_id: id) }
     events.each do |ev|
       repository.
-        append_to_stream(ev, SecureRandom.uuid, -1).
-        link_to_stream(ev.event_id, SecureRandom.uuid, -1)
+        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)
     end
 
-    expect(repository.read_all_streams_forward(:head, 3)).to eq(events.first(3))
-    expect(repository.read_all_streams_forward(:head, 100)).to eq(events)
-    expect(repository.read_all_streams_forward(events[4].event_id, 4)).to eq(events[5..8])
-    expect(repository.read_all_streams_forward(events[4].event_id, 100)).to eq(events[5..9])
+    expect(read_all_streams_forward(repository, :head, 3)).to eq(events.first(3))
+    expect(read_all_streams_forward(repository, :head, 100)).to eq(events)
+    expect(read_all_streams_forward(repository, events[4].event_id, 4)).to eq(events[5..8])
+    expect(read_all_streams_forward(repository, events[4].event_id, 100)).to eq(events[5..9])
 
-    expect(repository.read_all_streams_backward(:head, 3)).to eq(events.last(3).reverse)
-    expect(repository.read_all_streams_backward(:head, 100)).to eq(events.reverse)
-    expect(repository.read_all_streams_backward(events[4].event_id, 4)).to eq(events.first(4).reverse)
-    expect(repository.read_all_streams_backward(events[4].event_id, 100)).to eq(events.first(4).reverse)
+    expect(read_all_streams_backward(repository, :head, 3)).to eq(events.last(3).reverse)
+    expect(read_all_streams_backward(repository, :head, 100)).to eq(events.reverse)
+    expect(read_all_streams_backward(repository, events[4].event_id, 4)).to eq(events.first(4).reverse)
+    expect(read_all_streams_backward(repository, events[4].event_id, 100)).to eq(events.first(4).reverse)
   end
 
   it 'reads events different uuid object but same content' do
-    event_ids = [
-      "96c920b1-cdd0-40f4-907c-861b9fff7d02",
-      "56404f79-0ba0-4aa0-8524-dc3436368ca0"
-    ]
-    events = event_ids.map{|id| TestDomainEvent.new(event_id: id) }
-    repository.append_to_stream(events.first, 'stream', -1)
-    repository.append_to_stream(events.last,  'stream',  0)
+    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, RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
+    repository.append_to_stream(events.last,  RubyEventStore::Stream.new('stream'),  RubyEventStore::ExpectedVersion.new(0))
 
-    expect(repository.read_all_streams_forward("96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
-    expect(repository.read_all_streams_backward("56404f79-0ba0-4aa0-8524-dc3436368ca0", 1)).to eq([events.first])
+    expect(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(repository.read_events_forward('stream', "96c920b1-cdd0-40f4-907c-861b9fff7d02", 1)).to eq([events.last])
-    expect(repository.read_events_backward('stream', "56404f79-0ba0-4aa0-8524-dc3436368ca0", 1)).to eq([events.first])
+    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])
   end
 
   it 'does not allow same event twice in a stream' do
     repository.append_to_stream(
-      TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-      'stream',
-      -1
+      SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+      RubyEventStore::Stream.new('stream'),
+      RubyEventStore::ExpectedVersion.none
     )
     expect do
       repository.append_to_stream(
-        TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-        'stream',
-        0
+        SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        RubyEventStore::Stream.new('stream'),
+        RubyEventStore::ExpectedVersion.new(0)
       )
     end.to raise_error(RubyEventStore::EventDuplicatedInStream)
   end
 
   it 'does not allow same event twice' do
     repository.append_to_stream(
-      TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-      'stream',
-      -1
+      SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+      RubyEventStore::Stream.new('stream'),
+      RubyEventStore::ExpectedVersion.none
     )
     expect do
       repository.append_to_stream(
-        TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-        'another',
-        -1
+        SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        RubyEventStore::Stream.new("another"),
+        RubyEventStore::ExpectedVersion.none
       )
     end.to raise_error(RubyEventStore::EventDuplicatedInStream)
   end
@@ -807,99 +909,42 @@ RSpec.shared_examples :event_repository do |repository_class|
   it 'does not allow linking same event twice in a stream' do
     skip unless test_link_events_to_stream
     repository.append_to_stream([
-        TestDomainEvent.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
-      ], 'stream',
-      -1
-    ).link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", 'flow', -1)
+        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)
     expect do
-      repository.link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", 'flow', 0)
+      repository.link_to_stream("a1b49edb-7636-416f-874a-88f94b859bef", RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.new(0))
     end.to raise_error(RubyEventStore::EventDuplicatedInStream)
   end
 
   it 'allows appending to GLOBAL_STREAM explicitly' do
-    event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-    repository.append_to_stream(event, "all", :any)
-
-    expect(repository.read_all_streams_forward(:head, 10)).to eq([event])
-  end
-
-  specify 'GLOBAL_STREAM is unordered, one cannot expect specific version number to work' do
-    expect {
-      event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-      repository.append_to_stream(event, "all", 42)
-    }.to raise_error(RubyEventStore::InvalidExpectedVersion)
-  end
-
-  specify 'GLOBAL_STREAM is unordered, one cannot expect :none to work' do
-    expect {
-      event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-      repository.append_to_stream(event, "all", :none)
-    }.to raise_error(RubyEventStore::InvalidExpectedVersion)
-  end
-
-  specify 'GLOBAL_STREAM is unordered, one cannot expect :auto to work' do
-    expect {
-      event = TestDomainEvent.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-      repository.append_to_stream(event, "all", :auto)
-    }.to raise_error(RubyEventStore::InvalidExpectedVersion)
-  end
+    event = SRecord.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
+    repository.append_to_stream(event, RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM), RubyEventStore::ExpectedVersion.any)
 
-  specify "only :none, :any, :auto and Integer allowed as expected_version" do
-    [Object.new, SecureRandom.uuid, :foo].each do |invalid_expected_version|
-      expect {
-        repository.append_to_stream(
-          TestDomainEvent.new(event_id: SecureRandom.uuid),
-          'some_stream',
-          invalid_expected_version
-        )
-      }.to raise_error(RubyEventStore::InvalidExpectedVersion)
-    end
-  end
-
-  specify "only :none, :any, :auto and Integer allowed as expected_version when linking" do
-    skip unless test_link_events_to_stream
-    [Object.new, SecureRandom.uuid, :foo].each do |invalid_expected_version|
-      repository.append_to_stream(
-        TestDomainEvent.new(event_id: evid = SecureRandom.uuid),
-        SecureRandom.uuid,
-        -1
-      )
-      expect {
-        repository.link_to_stream(evid, SecureRandom.uuid, invalid_expected_version)
-      }.to raise_error(RubyEventStore::InvalidExpectedVersion)
-    end
+    expect(read_all_streams_forward(repository, :head, 10)).to eq([event])
   end
 
   specify "events not persisted if append failed" do
     repository.append_to_stream([
-      TestDomainEvent.new(event_id: SecureRandom.uuid),
-    ], 'stream', :none)
+      SRecord.new(event_id: SecureRandom.uuid),
+    ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
 
     expect do
       repository.append_to_stream([
-        TestDomainEvent.new(
+        SRecord.new(
           event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
         ),
-      ], 'stream', :none)
+      ], RubyEventStore::Stream.new('stream'), RubyEventStore::ExpectedVersion.none)
     end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
     expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
   end
 
-  specify "all stream always present" do
-    expect(repository.get_all_streams).to match_array([RubyEventStore::Stream.new("all")])
-  end
-
-  specify "reading all existing stream names" do
-    repository.append_to_stream(TestDomainEvent.new, "test", -1)
-    repository.append_to_stream(TestDomainEvent.new, "test",  0)
-    expect(repository.get_all_streams).to match_array([RubyEventStore::Stream.new("all"), RubyEventStore::Stream.new("test")])
-  end
-
   specify 'reading particular event' do
-    test_event = TestDomainEvent.new(event_id: "941cd8f5-b3f9-47af-b4e4-07f8cea37467")
+    test_event = SRecord.new(event_id: "941cd8f5-b3f9-47af-b4e4-07f8cea37467")
     repository.
-      append_to_stream(TestDomainEvent.new, "test", -1).
-      append_to_stream(test_event, "test", 0)
+      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))
 
     expect(repository.read_event("941cd8f5-b3f9-47af-b4e4-07f8cea37467")).to eq(test_event)
   end
@@ -917,7 +962,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', "flow", -1)
+      repository.link_to_stream('72922e65-1b32-4e97-8023-03ae81dd3a27', RubyEventStore::Stream.new("flow"), RubyEventStore::ExpectedVersion.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')
@@ -925,7 +970,23 @@ RSpec.shared_examples :event_repository do |repository_class|
     end
   end
 
-  specify 'add_metadata' do
-    expect(repository).to respond_to(:add_metadata)
+  specify 'read returns enumerator' do
+    specification = RubyEventStore::Specification.new(repository)
+    expect(repository.read(specification.result)).to be_kind_of(Enumerator)
+  end
+
+  specify 'can store arbitrary binary data' do
+    skip unless test_binary
+    migrate_to_binary
+    binary = "\xB0"
+    expect(binary.valid_encoding?).to eq(false)
+    binary.force_encoding("binary")
+    expect(binary.valid_encoding?).to eq(true)
+
+    repository.append_to_stream(
+      event = SRecord.new(data: binary, metadata: binary),
+      RubyEventStore::Stream.new('stream'),
+      RubyEventStore::ExpectedVersion.none
+    )
   end
 end