ruby_event_store 0.36.0 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74ce24e16b83c5ce7158f1b2ca79e56ca2ea6b389957198b3f8478e20de1ca75
-  data.tar.gz: 7a3e066734b62828598475d528ef7d50c2b5420604f8d2746b8b769a45be4cff
+  metadata.gz: 4c759197c7079350367b3669fefa272cf9eee74c46cb084e73be1412f0fcfd53
+  data.tar.gz: ba5fa3e80f410e2d773217eb02985fa34157bf12b9dec933e77cb1ea2d9eaff0
 SHA512:
-  metadata.gz: '0158753e75e020c5a6e3b2699dc96049cbd1aef1cb87c11754e12f7397fca770b46b4871b92764bb7599370270eeb75e0417e7f4fc77495b2d05cc9031dc86c6'
-  data.tar.gz: c4fcf49f6a4ba43487a105b53836360db48b442ff6b805a9364ba9e751b28bd8d671454d977455387dd71cfdeb717f6ce7d8ac8617df6a09ae979351202e27c8
+  metadata.gz: b10c08c3ec291f278d667f9768d20b912f69bdcc0e9c37162350e2017cb5462608ec95ae63a6bdbefccfd169916a2d930bc0ba000a0d2327c2b3804300d6f236
+  data.tar.gz: cd35806dfe6c323eec8c30c3e2ddef0146c694a620a4366f640aa0fa9a90f85f825f9cc8c9ed73f6e5bda6194339d254c197a1d1472be6442e018d8e82c55a36

data/Gemfile

@@ -4,8 +4,5 @@ gemspec
 eval_gemfile File.expand_path('../lib/Gemfile.shared', __dir__)
 
 gem 'protobuf_nested_struct'
-gem 'parser'
-gem 'unparser'
-gem 'astrolabe'
 gem 'google-protobuf', '= 3.6.1', source: 'https://gem.fury.io/pawelpacana/'
 gem 'activesupport', '~> 5.0'

data/Makefile

@@ -2,17 +2,8 @@ GEM_VERSION = $(shell cat ../RES_VERSION)
 GEM_NAME    = ruby_event_store
 REQUIRE     = $(GEM_NAME)
 IGNORE      = RubyEventStore::InMemoryRepository\#append_with_synchronize \
-              RubyEventStore::InMemoryRepository\#normalize_to_array \
-              RubyEventStore::Client\#normalize_to_array \
-              RubyEventStore::Client::Within\#normalize_to_array \
               RubyEventStore::Client::Within\#add_thread_subscribers \
               RubyEventStore::Client::Within\#add_thread_global_subscribers \
-              RubyEventStore::DeprecatedReadAPIRunner* \
-              RubyEventStore::DeprecatedReadAPIRewriter* \
-              RubyEventStore::SpecificationResult\#count \
-              RubyEventStore::SpecificationResult\#direction \
-              RubyEventStore::SpecificationResult\#stream_name \
-              RubyEventStore::SpecificationResult\#global_stream? \
               RubyEventStore::Client::Within\#call
 SUBJECT     ?= RubyEventStore*
 

data/lib/ruby_event_store.rb

@@ -18,6 +18,7 @@ require 'ruby_event_store/transform_keys'
 require 'ruby_event_store/mappers/default'
 require 'ruby_event_store/mappers/protobuf'
 require 'ruby_event_store/mappers/null_mapper'
+require 'ruby_event_store/mappers/instrumented_mapper'
 require 'ruby_event_store/batch_enumerator'
 require 'ruby_event_store/correlated_commands'
 require 'ruby_event_store/link_by_metadata'

data/lib/ruby_event_store/client.rb

@@ -70,16 +70,6 @@ module RubyEventStore
       self
     end
 
-    # @deprecated Use {#read.event!(event_id)} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.33.0 More info}
-    def read_event(event_id)
-      warn <<~EOW
-        RubyEventStore::Client#read_event(event_id) has been deprecated.
-        Use `client.read.event!(event_id)` instead. Also available without
-        bang - return nil when no event is found.
-      EOW
-      read.event!(event_id)
-    end
-
     # Starts building a query specification for reading events.
     # {http://railseventstore.org/docs/read/ More info.}
     #
@@ -170,7 +160,7 @@ module RubyEventStore
       #   @return [self]
       def subscribe(handler=nil, to:, &handler2)
         raise ArgumentError if handler && handler2
-        @subscribers[handler || handler2] += normalize_to_array(to)
+        @subscribers[handler || handler2] += Array(to)
         self
       end
 
@@ -200,10 +190,6 @@ module RubyEventStore
           @broker.add_thread_global_subscription(subscriber)
         end
       end
-
-      def normalize_to_array(objs)
-        return *objs
-      end
     end
 
     # Use for starting temporary subscriptions.
@@ -276,7 +262,7 @@ module RubyEventStore
     # @param events [Array<Event, Proto>, Event, Proto] event(s) to serialize and overwrite again
     # @return [self]
     def overwrite(events_or_event)
-      events = normalize_to_array(events_or_event)
+      events = Array(events_or_event)
       serialized_events = serialize_events(events)
       repository.update_messages(serialized_events)
       self
@@ -297,12 +283,8 @@ module RubyEventStore
       end
     end
 
-    def normalize_to_array(events)
-      return *events
-    end
-
     def enrich_events_metadata(events)
-      events = normalize_to_array(events)
+      events = Array(events)
       events.each{|event| enrich_event_metadata(event) }
       events
     end

data/lib/ruby_event_store/errors.rb

@@ -4,6 +4,7 @@ module RubyEventStore
   IncorrectStreamData       = Class.new(StandardError)
   SubscriberNotExist        = Class.new(StandardError)
   InvalidPageStart          = Class.new(ArgumentError)
+  InvalidPageStop           = Class.new(ArgumentError)
   InvalidPageSize           = Class.new(ArgumentError)
   EventDuplicatedInStream   = Class.new(StandardError)
   ReservedInternalName      = Class.new(StandardError)

data/lib/ruby_event_store/in_memory_repository.rb

@@ -15,7 +15,7 @@ module RubyEventStore
     end
 
     def link_to_stream(event_ids, stream, expected_version)
-      events = normalize_to_array(event_ids).map {|eid| read_event(eid)}
+      events = Array(event_ids).map {|eid| read_event(eid)}
       add_to_stream(events, expected_version, stream, nil)
     end
 
@@ -73,6 +73,7 @@ module RubyEventStore
       events = events.select{|e| spec.with_types.any?{|x| x.eql?(e.event_type)}} if spec.with_types?
       events = events.reverse if spec.backward?
       events = events.drop(index_of(events, spec.start) + 1) unless spec.head?
+      events = events.take(index_of(events, spec.stop)) if spec.stop
       events = events[0...spec.limit] if spec.limit?
       events
     end
@@ -85,13 +86,8 @@ module RubyEventStore
       streams.fetch(name, Array.new)
     end
 
-    def normalize_to_array(events)
-      return *events
-    end
-
     def add_to_stream(events, expected_version, stream, include_global)
-      events = normalize_to_array(events)
-      append_with_synchronize(events, expected_version, stream, include_global)
+      append_with_synchronize(Array(events), expected_version, stream, include_global)
     end
 
     def last_stream_version(stream)

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -0,0 +1,26 @@
+module RubyEventStore
+  module Mappers
+    class InstrumentedMapper
+      def initialize(mapper, instrumentation)
+        @mapper = mapper
+        @instrumentation = instrumentation
+      end
+
+      def event_to_serialized_record(domain_event)
+        instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: domain_event) do
+          mapper.event_to_serialized_record(domain_event)
+        end
+      end
+
+      def serialized_record_to_event(record)
+        instrumentation.instrument("deserialize.mapper.rails_event_store", record: record) do
+          mapper.serialized_record_to_event(record)
+        end
+      end
+
+      private
+
+      attr_reader :instrumentation, :mapper
+    end
+  end
+end

data/lib/ruby_event_store/projection.rb

@@ -27,7 +27,7 @@ module RubyEventStore
 
     def when(events, handler)
       Array(events).each do |event|
-        handlers[event] = handler
+        handlers[event.to_s] = handler
       end
 
       self
@@ -42,7 +42,7 @@ module RubyEventStore
     end
 
     def call(event)
-      handlers.fetch(event.class).(current_state, event)
+      handlers.fetch(event.type).(current_state, event)
     end
 
     def handled_events
@@ -71,13 +71,13 @@ module RubyEventStore
     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)|
-        event_store.read.in_batches(count).stream(stream_name).from(start_event_id).each.reduce(state, &method(:transition))
+        event_store.read.in_batches(count).stream(stream_name).from(start_event_id).reduce(state, &method(:transition))
       end
     end
 
     def reduce_from_all_streams(event_store, start, count)
       raise ArgumentError.new('Start must be valid event id or :head') unless valid_starting_point?(start)
-      event_store.read.in_batches(count).from(start).each.reduce(initial_state, &method(:transition))
+      event_store.read.in_batches(count).from(start).reduce(initial_state, &method(:transition))
     end
 
     def start_events(start)
@@ -85,7 +85,7 @@ module RubyEventStore
     end
 
     def transition(state, event)
-      handlers[event.class].(state, event)
+      handlers[event.type].(state, event)
       state
     end
   end

data/lib/ruby_event_store/spec/event_lint.rb

@@ -0,0 +1,73 @@
+RSpec.shared_examples :event do |event_class|
+  it 'allows initialization' do
+    expect {
+      metadata = double(:metadata)
+      allow(metadata).to receive(:to_h).and_return({})
+      event_class.new(event_id: Object.new, data: Object.new, metadata: metadata)
+    }.not_to raise_error
+  end
+
+  it 'provides event_id as string' do
+    event = event_class.new
+    expect(event.event_id).to be_an_instance_of(String)
+    expect(event.event_id).not_to eq ''
+    expect(event.event_id).not_to eq nil
+  end
+
+  it 'provides message_id as string' do
+    event = event_class.new
+    expect(event.message_id).to be_an_instance_of(String)
+  end
+
+  it 'message_id is the same as event_id' do
+    event = event_class.new
+    expect(event.event_id).to eq event.message_id
+  end
+
+  it 'exposes given event_id to string' do
+    event = event_class.new(event_id: 1234567890)
+    expect(event.event_id).to eq '1234567890'
+  end
+
+  it 'provides type as string' do
+    event = event_class.new
+    expect(event.type).to be_an_instance_of(String)
+    expect(event.type).not_to eq ''
+    expect(event.type).not_to eq nil
+  end
+
+  it "provides data" do
+    event = event_class.new
+    expect(event).to respond_to(:data).with(0).arguments
+  end
+
+  it "metadata allows to read keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:[]).with(1).arguments
+  end
+
+  it "metadata allows to set keys value" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:[]=).with(2).argument
+  end
+
+  it "metadata allows to fetch keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:fetch).with(1).argument
+  end
+
+  it "metadata allows to check existence of keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:has_key?).with(1).argument
+  end
+
+  it "metadata allows to iterate through keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:each_with_object).with(1).argument
+  end
+
+  it "metadata must convert to hash" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:to_h).with(0).argument
+  end
+end

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -25,7 +25,7 @@ module RubyEventStore
 end
 
 module RubyEventStore
-  RSpec.shared_examples :event_repository do |repository_class|
+  RSpec.shared_examples :event_repository do |repository_class, rescuable_concurrency_test_errors = []|
     let(:repository)    { subject || repository_class.new }
     let(:mapper)        { Mappers::NullMapper.new }
     let(:specification) { Specification.new(SpecificationReader.new(repository, mapper)) }
@@ -42,65 +42,24 @@ module RubyEventStore
     let(:version_2)     { ExpectedVersion.new(2) }
     let(:version_3)     { ExpectedVersion.new(3) }
 
-    def read_stream_events_forward(repository, stream)
-      repository.read(
-        specification
-          .stream(stream.name)
-          .result
-      ).to_a
-    end
-
-    def read_stream_events_backward(repository, stream)
-      repository.read(
-        specification
-          .stream(stream.name)
-          .backward
-          .result
-      ).to_a
-    end
-
-    def read_events_forward(repository, stream, start, count)
-      repository.read(
-        specification
-          .stream(stream.name)
-          .from(start)
-          .limit(count)
-          .result
-      ).to_a
-    end
-
-    def read_events_backward(repository, stream, start, count)
-      repository.read(
-        specification
-          .stream(stream.name)
-          .from(start)
-          .limit(count)
-          .backward
-          .result
-      ).to_a
-    end
-
-    def read_all_streams_forward(repository, start, count)
-      repository.read(
-        specification
-          .from(start)
-          .limit(count)
-          .result
-      ).to_a
-    end
-
-    def read_all_streams_backward(repository, start, count)
-      repository.read(
-        specification
-          .from(start)
-          .limit(count)
-          .backward
-          .result
-      ).to_a
+    def read_events(scope, stream = nil, from: nil, to: nil, count: nil)
+      scope = scope.stream(stream.name) if stream
+      scope = scope.from(from) if from
+      scope = scope.to(to) if to
+      scope = scope.limit(count) if count
+      repository.read(scope.result).to_a
+    end
+
+    def read_events_forward(repository, stream = nil, from: nil, to: nil, count: nil)
+      read_events(specification, stream, from: from, to: to, count: count)
+    end
+
+    def read_events_backward(repository, stream = nil, from: nil, to: nil, count: nil)
+      read_events(specification.backward, stream, from: from, to: to, count: count)
     end
 
     it 'just created is empty' do
-      expect(read_all_streams_forward(repository, :head, 1)).to be_empty
+      expect(read_events_forward(repository)).to be_empty
     end
 
     specify 'append_to_stream returns self' do
@@ -110,7 +69,6 @@ module RubyEventStore
     end
 
     specify 'link_to_stream returns self' do
-      skip unless test_link_events_to_stream
       event0 = SRecord.new
       event1 = SRecord.new
       repository.
@@ -121,21 +79,20 @@ module RubyEventStore
 
     specify 'adds an initial event to a new stream' do
       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, stream).first).to eq(event)
-      expect(read_stream_events_forward(repository, stream_other)).to be_empty
+      expect(read_events_forward(repository).first).to eq(event)
+      expect(read_events_forward(repository, stream).first).to eq(event)
+      expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
     specify 'links an initial event to a new stream' do
-      skip unless test_link_events_to_stream
       repository.
         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, 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
+      expect(read_events_forward(repository, count: 1).first).to eq(event)
+      expect(read_events_forward(repository, stream).first).to eq(event)
+      expect(read_events_forward(repository, stream_flow)).to eq([event])
+      expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
     specify 'adds multiple initial events to a new stream' do
@@ -143,12 +100,11 @@ module RubyEventStore
         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, stream)).to eq([event0, event1])
+      expect(read_events_forward(repository, count: 2)).to eq([event0, event1])
+      expect(read_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,
         event1 = SRecord.new,
@@ -156,8 +112,8 @@ module RubyEventStore
         event0.event_id,
         event1.event_id,
       ], stream_flow, version_none)
-      expect(read_all_streams_forward(repository, :head, 2)).to eq([event0, event1])
-      expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1])
+      expect(read_events_forward(repository, count: 2)).to eq([event0, event1])
+      expect(read_events_forward(repository, stream_flow)).to eq([event0, event1])
     end
 
     specify 'correct expected version on second write' do
@@ -169,12 +125,11 @@ module RubyEventStore
         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, stream)).to eq([event0, event1, event2, event3])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1, event2, event3])
+      expect(read_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,
         event1 = SRecord.new,
@@ -185,8 +140,8 @@ module RubyEventStore
         event0.event_id,
         event1.event_id,
       ], stream_flow, version_1)
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-      expect(read_stream_events_forward(repository, stream_flow)).to eq([event2, event3, event0, event1])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1, event2, event3])
+      expect(read_events_forward(repository, stream_flow)).to eq([event2, event3, event0, event1])
     end
 
     specify 'incorrect expected version on second write' do
@@ -201,12 +156,11 @@ module RubyEventStore
         ], stream, version_0)
       end.to raise_error(WrongExpectedEventVersion)
 
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1])
-      expect(read_stream_events_forward(repository, stream)).to eq([event0, event1])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1])
+      expect(read_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,
         event1 = SRecord.new,
@@ -222,8 +176,8 @@ module RubyEventStore
         ], stream, version_0)
       end.to raise_error(WrongExpectedEventVersion)
 
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1, event2, event3])
-      expect(read_stream_events_forward(repository, stream)).to eq([event0, event1])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1, event2, event3])
+      expect(read_events_forward(repository, stream)).to eq([event0, event1])
     end
 
     specify ':none on first and subsequent write' do
@@ -235,12 +189,11 @@ module RubyEventStore
           eventB = SRecord.new,
         ], stream, version_none)
       end.to raise_error(WrongExpectedEventVersion)
-      expect(read_all_streams_forward(repository, :head, 1)).to eq([eventA])
-      expect(read_stream_events_forward(repository, stream)).to eq([eventA])
+      expect(read_events_forward(repository, count: 1)).to eq([eventA])
+      expect(read_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,
         eventB = SRecord.new,
@@ -251,8 +204,8 @@ module RubyEventStore
         repository.link_to_stream([eventB.event_id], stream_flow, version_none)
       end.to raise_error(WrongExpectedEventVersion)
 
-      expect(read_all_streams_forward(repository, :head, 1)).to eq([eventA])
-      expect(read_stream_events_forward(repository, stream_flow)).to eq([eventA])
+      expect(read_events_forward(repository, count: 1)).to eq([eventA])
+      expect(read_events_forward(repository, stream_flow)).to eq([eventA])
     end
 
     specify ':any allows stream with best-effort order and no guarantee' do
@@ -264,12 +217,11 @@ module RubyEventStore
         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, stream).to_set).to eq(Set.new([event0, event1, event2, event3]))
+      expect(read_events_forward(repository, count: 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
+      expect(read_events_forward(repository, stream).to_set).to eq(Set.new([event0, event1, event2, event3]))
     end
 
     specify ':any allows linking in stream with best-effort order and no guarantee' do
-      skip unless test_link_events_to_stream
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -284,12 +236,11 @@ module RubyEventStore
         event2.event_id, event3.event_id,
       ], 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, stream_flow).to_set).to eq(Set.new([event0, event1, event2, event3]))
+      expect(read_events_forward(repository, count: 4).to_set).to eq(Set.new([event0, event1, event2, event3]))
+      expect(read_events_forward(repository, stream_flow).to_set).to eq(Set.new([event0, event1, event2, event3]))
     end
 
     specify ':auto queries for last position in given stream' do
-      skip unless test_expected_version_auto
       repository.append_to_stream([
         eventA = SRecord.new,
         eventB = SRecord.new,
@@ -306,8 +257,6 @@ module RubyEventStore
     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,
         eventB = SRecord.new,
@@ -325,7 +274,6 @@ module RubyEventStore
     end
 
     specify ':auto starts from 0' do
-      skip unless test_expected_version_auto
       repository.append_to_stream([
         event0 = SRecord.new,
       ], stream, version_auto)
@@ -337,8 +285,6 @@ module RubyEventStore
     end
 
     specify ':auto linking starts from 0' do
-      skip unless test_expected_version_auto
-      skip unless test_link_events_to_stream
       repository.append_to_stream([
         event0 = SRecord.new,
       ], stream_other, version_auto)
@@ -353,7 +299,6 @@ module RubyEventStore
     end
 
     specify ':auto queries for last position and follows in incremental way' do
-      skip unless test_expected_version_auto
       # It is expected that there is higher level lock
       # So this query is safe from race conditions
       repository.append_to_stream([
@@ -364,16 +309,14 @@ module RubyEventStore
         event2 = SRecord.new,
         event3 = SRecord.new,
       ], stream, version_auto)
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([
+      expect(read_events_forward(repository, count: 4)).to eq([
         event0, event1,
         event2, event3
       ])
-      expect(read_stream_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
+      expect(read_events_forward(repository, stream)).to eq([event0, event1, event2, event3])
     end
 
     specify ':auto queries for last position and follows in incremental way when linking' do
-      skip unless test_expected_version_auto
-      skip unless test_link_events_to_stream
       repository.append_to_stream([
         event0 = SRecord.new,
         event1 = SRecord.new,
@@ -386,15 +329,14 @@ module RubyEventStore
       repository.link_to_stream([
         event2.event_id, event3.event_id,
       ], stream_flow, version_auto)
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([
+      expect(read_events_forward(repository, count: 4)).to eq([
         event0, event1,
         event2, event3
       ])
-      expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1, event2, event3])
+      expect(read_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,
         event1 = SRecord.new,
@@ -403,13 +345,11 @@ module RubyEventStore
         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, stream)).to eq([event0, event1, event2, event3])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1, event2, event3])
+      expect(read_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,
         event1 = SRecord.new,
@@ -420,12 +360,11 @@ module RubyEventStore
       repository.link_to_stream([
         event1.event_id,
       ], stream_flow, version_0)
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1,])
-      expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1,])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1,])
+      expect(read_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,
         event1 = SRecord.new,
@@ -434,13 +373,11 @@ module RubyEventStore
         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, stream)).to eq([event0, event1, event2, event3])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1, event2, event3])
+      expect(read_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,
         event1 = SRecord.new,
@@ -451,8 +388,8 @@ module RubyEventStore
       repository.link_to_stream([
         event1.event_id,
       ], stream_flow, version_auto)
-      expect(read_all_streams_forward(repository, :head, 4)).to eq([event0, event1])
-      expect(read_stream_events_forward(repository, stream_flow)).to eq([event0, event1])
+      expect(read_events_forward(repository, count: 4)).to eq([event0, event1])
+      expect(read_events_forward(repository, stream_flow)).to eq([event0, event1])
     end
 
     specify 'unlimited concurrency for :any - everything should succeed', timeout: 10, mutant: false do
@@ -460,9 +397,8 @@ module RubyEventStore
       verify_conncurency_assumptions
       begin
         concurrency_level = 4
-
-        fail_occurred = false
-        wait_for_it  = true
+        fail_occurred     = false
+        wait_for_it       = true
 
         threads = concurrency_level.times.map do |i|
           Thread.new do
@@ -482,8 +418,8 @@ module RubyEventStore
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to eq(false)
-        expect(read_stream_events_forward(repository, stream).size).to eq(400)
-        events_in_stream = read_stream_events_forward(repository, stream)
+        expect(read_events_forward(repository, stream).size).to eq(400)
+        events_in_stream = read_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-")
@@ -496,13 +432,11 @@ module RubyEventStore
 
     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
       begin
         concurrency_level = 4
-
-        fail_occurred = false
-        wait_for_it  = true
+        fail_occurred     = false
+        wait_for_it       = true
 
         concurrency_level.times.map do |i|
           100.times do |j|
@@ -529,8 +463,8 @@ module RubyEventStore
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to eq(false)
-        expect(read_stream_events_forward(repository, stream_flow).size).to eq(400)
-        events_in_stream = read_stream_events_forward(repository, stream_flow)
+        expect(read_events_forward(repository, stream_flow).size).to eq(400)
+        events_in_stream = read_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-")
@@ -541,8 +475,7 @@ module RubyEventStore
       end
     end
 
-    specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered' do
-      skip unless test_expected_version_auto
+    specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered', mutant: false do
       skip unless test_race_conditions_auto
       verify_conncurency_assumptions
       begin
@@ -561,7 +494,7 @@ module RubyEventStore
                   SRecord.new(event_id: eid),
                 ], stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion
+              rescue WrongExpectedEventVersion, *rescuable_concurrency_test_errors
                 fail_occurred +=1
               end
             end
@@ -570,7 +503,7 @@ module RubyEventStore
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to be > 0
-        events_in_stream = read_stream_events_forward(repository, stream)
+        events_in_stream = read_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|
@@ -583,11 +516,8 @@ module RubyEventStore
       end
     end
 
-    specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered' do
-      skip unless test_expected_version_auto
+    specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered', mutant: false do
       skip unless test_race_conditions_auto
-      skip unless test_link_events_to_stream
-
       verify_conncurency_assumptions
       begin
         concurrency_level = 4
@@ -612,7 +542,7 @@ module RubyEventStore
                 eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
                 repository.link_to_stream(eid, stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion
+              rescue WrongExpectedEventVersion, *rescuable_concurrency_test_errors
                 fail_occurred +=1
               end
             end
@@ -621,7 +551,7 @@ module RubyEventStore
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to be > 0
-        events_in_stream = read_stream_events_forward(repository, stream)
+        events_in_stream = read_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|
@@ -637,27 +567,26 @@ module RubyEventStore
     it 'appended event is stored in given stream' do
       expected_event = SRecord.new
       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, stream).first).to eq(expected_event)
-      expect(read_stream_events_forward(repository, stream_other)).to be_empty
+      expect(read_events_forward(repository, count: 1).first).to eq(expected_event)
+      expect(read_events_forward(repository, stream).first).to eq(expected_event)
+      expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
     it 'data attributes are retrieved' do
       event = SRecord.new(data: '{"order_id":3}')
       repository.append_to_stream(event, stream, version_any)
-      retrieved_event = read_all_streams_forward(repository, :head, 1).first
+      retrieved_event = read_events_forward(repository, count: 1).first
       expect(retrieved_event.data).to eq('{"order_id":3}')
     end
 
     it 'metadata attributes are retrieved' do
       event = SRecord.new(metadata: '{"request_id":3}')
       repository.append_to_stream(event, stream, version_any)
-      retrieved_event = read_all_streams_forward(repository, :head, 1).first
+      retrieved_event = read_events_forward(repository, count: 1).first
       expect(retrieved_event.metadata).to eq('{"request_id":3}')
     end
 
     it 'data and metadata attributes are retrieved when linking' do
-      skip unless test_link_events_to_stream
       event = SRecord.new(
         data: '{"order_id":3}',
         metadata: '{"request_id":4}',
@@ -665,7 +594,7 @@ module RubyEventStore
       repository.
         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
+      retrieved_event = read_events_forward(repository, stream_flow).first
       expect(retrieved_event.metadata).to eq('{"request_id":4}')
       expect(retrieved_event.data).to eq('{"order_id":3}')
       expect(event).to eq(retrieved_event)
@@ -676,20 +605,19 @@ module RubyEventStore
       repository.append_to_stream(e2 = SRecord.new, stream_other, version_none)
 
       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])
+      expect(read_events_forward(repository, stream)).to be_empty
+      expect(read_events_forward(repository, stream_other)).to eq([e2])
+      expect(read_events_forward(repository, count: 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, stream, version_none).
         link_to_stream(e1.event_id, stream_flow, version_none)
 
       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])
+      expect(read_events_forward(repository, stream_flow)).to be_empty
+      expect(read_events_forward(repository, count: 10)).to eq([e1])
     end
 
     it 'has or has not domain event' do
@@ -714,7 +642,6 @@ module RubyEventStore
     end
 
     it 'knows last event in stream when linked' do
-      skip unless test_link_events_to_stream
       repository.append_to_stream([
           e0 = SRecord.new(event_id: '00000000-0000-0000-0000-000000000001'),
           e1 = SRecord.new(event_id: '00000000-0000-0000-0000-000000000002'),
@@ -744,20 +671,23 @@ module RubyEventStore
       end
       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_forward(repository, stream, count: 3)).to eq(events.first(3))
+      expect(read_events_forward(repository, stream, count: 100)).to eq(events)
+      expect(read_events_forward(repository, stream, from: events[4].event_id)).to eq(events[5..9])
+      expect(read_events_forward(repository, stream, from: events[4].event_id, count: 4)).to eq(events[5..8])
+      expect(read_events_forward(repository, stream, from: events[4].event_id, count: 100)).to eq(events[5..9])
+      expect(read_events_forward(repository, stream, to: events[4].event_id, count: 3)).to eq(events[0..2])
+      expect(read_events_forward(repository, stream, to: events[4].event_id, count: 100)).to eq(events[0..3])
 
-      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)
+      expect(read_events_backward(repository, stream, count: 3)).to eq(events.last(3).reverse)
+      expect(read_events_backward(repository, stream, count: 100)).to eq(events.reverse)
+      expect(read_events_backward(repository, stream, from: events[4].event_id, count: 4)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, stream, from: events[4].event_id, count: 100)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, stream, to: events[4].event_id, count: 4)).to eq(events.last(4).reverse)
+      expect(read_events_backward(repository, stream, to: events[4].event_id, count: 100)).to eq(events.last(5).reverse)
     end
 
     it 'reads batch of linked events from stream forward & backward' do
-      skip unless test_link_events_to_stream
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
@@ -778,15 +708,19 @@ module RubyEventStore
       end
       repository.append_to_stream(SRecord.new, stream_other, version_0)
 
-      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_forward(repository, stream_flow, count: 3)).to eq(events.first(3))
+      expect(read_events_forward(repository, stream_flow, count: 100)).to eq(events)
+      expect(read_events_forward(repository, stream_flow, from: events[4].event_id, count: 4)).to eq(events[5..8])
+      expect(read_events_forward(repository, stream_flow, from: events[4].event_id, count: 100)).to eq(events[5..9])
+      expect(read_events_forward(repository, stream_flow, to: events[4].event_id, count: 3)).to eq(events[0..2])
+      expect(read_events_forward(repository, stream_flow, to: events[4].event_id, count: 100)).to eq(events[0..3])
 
-      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)
+      expect(read_events_backward(repository, stream_flow, count: 3)).to eq(events.last(3).reverse)
+      expect(read_events_backward(repository, stream_flow, count: 100)).to eq(events.reverse)
+      expect(read_events_backward(repository, stream_flow, from: events[4].event_id, count: 4)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, stream_flow, from: events[4].event_id, count: 100)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, stream_flow, to: events[4].event_id, count: 4)).to eq(events[6..9].reverse)
+      expect(read_events_backward(repository, stream_flow, to: events[4].event_id, count: 100)).to eq(events[5..9].reverse)
     end
 
     it 'reads all stream events forward & backward' do
@@ -799,12 +733,11 @@ module RubyEventStore
         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]
+      expect(read_events_forward(repository, s1)).to eq [a,c]
+      expect(read_events_backward(repository, s1)).to eq [c,a]
     end
 
     it 'reads all stream linked events forward & backward' do
-      skip unless test_link_events_to_stream
       s1, fs1, fs2 = stream, stream_flow, stream_other
       repository.
         append_to_stream(a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282'), s1, version_none).
@@ -818,8 +751,8 @@ module RubyEventStore
         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]
+      expect(read_events_forward(repository, fs1)).to eq [a,c]
+      expect(read_events_backward(repository, fs1)).to eq [c,a]
     end
 
     it 'reads batch of events from all streams forward & backward' do
@@ -839,19 +772,22 @@ module RubyEventStore
         repository.append_to_stream(ev, Stream.new(SecureRandom.uuid), version_none)
       end
 
-      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(read_events_forward(repository, count: 3)).to eq(events.first(3))
+      expect(read_events_forward(repository, count: 100)).to eq(events)
+      expect(read_events_forward(repository, from: events[4].event_id, count: 4)).to eq(events[5..8])
+      expect(read_events_forward(repository, from: events[4].event_id, count: 100)).to eq(events[5..9])
+      expect(read_events_forward(repository, to: events[4].event_id, count: 3)).to eq(events[0..2])
+      expect(read_events_forward(repository, to: events[4].event_id, count: 100)).to eq(events[0..3])
 
-      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)
+      expect(read_events_backward(repository, count: 3)).to eq(events.last(3).reverse)
+      expect(read_events_backward(repository, count: 100)).to eq(events.reverse)
+      expect(read_events_backward(repository, from: events[4].event_id, count: 4)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, from: events[4].event_id, count: 100)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, to: events[4].event_id, count: 4)).to eq(events.last(4).reverse)
+      expect(read_events_backward(repository, to: events[4].event_id, count: 100)).to eq(events.last(5).reverse)
     end
 
     it 'linked events do not affect reading from all streams - no duplicates' do
-      skip unless test_link_events_to_stream
       events = %w[
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
@@ -870,15 +806,19 @@ module RubyEventStore
           link_to_stream(ev.event_id, Stream.new(SecureRandom.uuid), version_none)
       end
 
-      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(read_events_forward(repository, count: 3)).to eq(events.first(3))
+      expect(read_events_forward(repository, count: 100)).to eq(events)
+      expect(read_events_forward(repository, from: events[4].event_id, count: 4)).to eq(events[5..8])
+      expect(read_events_forward(repository, from: events[4].event_id, count: 100)).to eq(events[5..9])
+      expect(read_events_forward(repository, to: events[4].event_id, count: 3)).to eq(events[0..2])
+      expect(read_events_forward(repository, to: events[4].event_id, count: 100)).to eq(events[0..3])
 
-      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)
+      expect(read_events_backward(repository, count: 3)).to eq(events.last(3).reverse)
+      expect(read_events_backward(repository, count: 100)).to eq(events.reverse)
+      expect(read_events_backward(repository, from: events[4].event_id, count: 4)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, from: events[4].event_id, count: 100)).to eq(events.first(4).reverse)
+      expect(read_events_backward(repository, to: events[4].event_id, count: 4)).to eq(events.last(4).reverse)
+      expect(read_events_backward(repository, to: events[4].event_id, count: 100)).to eq(events.last(5).reverse)
     end
 
     it 'reads events different uuid object but same content' do
@@ -889,11 +829,15 @@ module RubyEventStore
       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, from: "96c920b1-cdd0-40f4-907c-861b9fff7d02")).to eq([events.last])
+      expect(read_events_backward(repository, from: "56404f79-0ba0-4aa0-8524-dc3436368ca0")).to eq([events.first])
+      expect(read_events_forward(repository, to: "56404f79-0ba0-4aa0-8524-dc3436368ca0", count: 1)).to eq([events.first])
+      expect(read_events_backward(repository, to: "96c920b1-cdd0-40f4-907c-861b9fff7d02", count: 1)).to eq([events.last])
 
-      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])
+      expect(read_events_forward(repository, stream, from: "96c920b1-cdd0-40f4-907c-861b9fff7d02")).to eq([events.last])
+      expect(read_events_backward(repository, stream, from: "56404f79-0ba0-4aa0-8524-dc3436368ca0")).to eq([events.first])
+      expect(read_events_forward(repository, stream, to: "56404f79-0ba0-4aa0-8524-dc3436368ca0", count: 1)).to eq([events.first])
+      expect(read_events_backward(repository, stream, to: "96c920b1-cdd0-40f4-907c-861b9fff7d02", count: 1)).to eq([events.last])
     end
 
     it 'does not allow same event twice in a stream' do
@@ -927,7 +871,6 @@ module RubyEventStore
     end
 
     it 'does not allow linking same event twice in a stream' do
-      skip unless test_link_events_to_stream
       repository.append_to_stream([
           SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
         ], stream,
@@ -942,7 +885,7 @@ module RubyEventStore
       event = SRecord.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
       repository.append_to_stream(event, global_stream, version_any)
 
-      expect(read_all_streams_forward(repository, :head, 10)).to eq([event])
+      expect(read_events_forward(repository, count: 10)).to eq([event])
     end
 
     specify "events not persisted if append failed" do
@@ -961,7 +904,6 @@ module RubyEventStore
     end
 
     specify 'linking non-existent event' do
-      skip unless test_link_events_to_stream
       expect do
         repository.link_to_stream('72922e65-1b32-4e97-8023-03ae81dd3a27', stream_flow, version_none)
       end.to raise_error do |err|
@@ -1133,6 +1075,18 @@ module RubyEventStore
 
       expect(repository.read(specification.from(events[0].event_id).backward.read_first.result)).to be_nil
       expect(repository.read(specification.from(events[0].event_id).backward.read_last.result)).to be_nil
+
+      expect(repository.read(specification.to(events[3].event_id).read_first.result)).to eq(events[0])
+      expect(repository.read(specification.to(events[3].event_id).read_last.result)).to eq(events[2])
+
+      expect(repository.read(specification.to(events[2].event_id).backward.read_first.result)).to eq(events[4])
+      expect(repository.read(specification.to(events[2].event_id).backward.read_last.result)).to eq(events[3])
+
+      expect(repository.read(specification.to(events[0].event_id).read_first.result)).to be_nil
+      expect(repository.read(specification.to(events[0].event_id).read_last.result)).to be_nil
+
+      expect(repository.read(specification.to(events[4].event_id).backward.read_first.result)).to be_nil
+      expect(repository.read(specification.to(events[4].event_id).backward.read_last.result)).to be_nil
     end
 
     context "#update_messages" do
@@ -1173,7 +1127,6 @@ module RubyEventStore
     end
 
     specify do
-      skip unless test_link_events_to_stream
       event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea')
       event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7')
       event_3 = SRecord.new(event_id: 'd345f86d-b903-4d78-803f-38990c078d9e')
@@ -1263,6 +1216,7 @@ module RubyEventStore
       expect(repository.count(specification.from(event_id).result)).to eq(1)
       expect(repository.count(specification.stream("Dummy").from(:head).result)).to eq(2)
       expect(repository.count(specification.stream("Dummy").from(event_id).result)).to eq(1)
+      expect(repository.count(specification.stream("Dummy").to(event_id).result)).to eq(0)
 
       expect(repository.count(specification.limit(100).result)).to eq(5)
       expect(repository.count(specification.limit(2).result)).to eq(2)