ruby_event_store 2.3.0 → 2.4.0

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -2,52 +2,55 @@ module RubyEventStore
   # @private
   class SRecord
     def self.new(
-      event_id:   SecureRandom.uuid,
-      data:       {},
-      metadata:   {},
+      event_id: SecureRandom.uuid,
+      data: {},
+      metadata: {},
       event_type: "SRecordTestEvent",
-      timestamp:  Time.new.utc,
-      valid_at:   nil
+      timestamp: Time.new.utc,
+      valid_at: nil
     )
       Record.new(
-        event_id:   event_id,
-        data:       data,
-        metadata:   metadata,
+        event_id: event_id,
+        data: data,
+        metadata: metadata,
         event_type: event_type,
-        timestamp:  timestamp.round(TIMESTAMP_PRECISION),
-        valid_at:   (valid_at || timestamp).round(TIMESTAMP_PRECISION),
+        timestamp: timestamp.round(TIMESTAMP_PRECISION),
+        valid_at: (valid_at || timestamp).round(TIMESTAMP_PRECISION)
       )
     end
   end
 
   # @private
   Type1 = Class.new(RubyEventStore::Event)
+
   # @private
   Type2 = Class.new(RubyEventStore::Event)
+
   # @private
   Type3 = Class.new(RubyEventStore::Event)
 end
 
 module RubyEventStore
   ::RSpec.shared_examples :event_repository do |mk_repository, helper|
-    let(:repository)    { mk_repository.call }
+    let(:repository) { mk_repository.call }
     let(:specification) { Specification.new(SpecificationReader.new(repository, Mappers::NullMapper.new)) }
     let(:global_stream) { Stream.new(GLOBAL_STREAM) }
-    let(:stream)        { Stream.new(SecureRandom.uuid) }
-    let(:stream_flow)   { Stream.new("flow") }
-    let(:stream_other)  { Stream.new("other") }
-    let(:stream_test)   { Stream.new("test") }
-    let(:version_none)  { ExpectedVersion.none }
-    let(:version_auto)  { ExpectedVersion.auto }
-    let(:version_any)   { ExpectedVersion.any }
-    let(:version_0)     { ExpectedVersion.new(0) }
-    let(:version_1)     { ExpectedVersion.new(1) }
-    let(:version_2)     { ExpectedVersion.new(2) }
-    let(:version_3)     { ExpectedVersion.new(3) }
+    let(:stream) { Stream.new(SecureRandom.uuid) }
+    let(:stream_flow) { Stream.new("flow") }
+    let(:stream_other) { Stream.new("other") }
+    let(:stream_test) { Stream.new("test") }
+    let(:version_none) { ExpectedVersion.none }
+    let(:version_auto) { ExpectedVersion.auto }
+    let(:version_any) { ExpectedVersion.any }
+    let(:version_0) { ExpectedVersion.new(0) }
+    let(:version_1) { ExpectedVersion.new(1) }
+    let(:version_2) { ExpectedVersion.new(2) }
+    let(:version_3) { ExpectedVersion.new(3) }
 
     def verify_conncurency_assumptions(helper)
       return unless helper.has_connection_pooling?
-      expect(helper.connection_pool_size).to eq(5), "expected connection pool of size 5, got #{helper.connection_pool_size}"
+      expect(helper.connection_pool_size).to eq(5),
+      "expected connection pool of size 5, got #{helper.connection_pool_size}"
     end
 
     def read_events(repository, scope, stream = nil, from: nil, to: nil, count: nil)
@@ -104,64 +107,39 @@ module RubyEventStore
     end
 
     specify "adds multiple initial events to a new stream" do
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none).link_to_stream([
-        event0.event_id,
-        event1.event_id,
-      ], stream_flow, version_none)
+      repository
+        .append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
+        .link_to_stream([event0.event_id, event1.event_id], stream_flow, version_none)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_1)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_1)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none).append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream_flow, version_none).link_to_stream([
-        event0.event_id,
-        event1.event_id,
-      ], stream_flow, version_1)
+      repository
+        .append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
+        .append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream_flow, version_none)
+        .link_to_stream([event0.event_id, event1.event_id], stream_flow, version_1)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
       expect do
-        repository.append_to_stream([
-          event2 = SRecord.new,
-          event3 = SRecord.new,
-        ], stream, version_0)
+        repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_0)
       end.to raise_error(WrongExpectedEventVersion)
 
       expect(read_events_forward(repository, count: 4)).to eq([event0, event1])
@@ -169,233 +147,140 @@ module RubyEventStore
     end
 
     specify "incorrect expected version on second link" do
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream_other, version_none)
-      expect do
-        repository.link_to_stream([
-          event2.event_id,
-          event3.event_id,
-        ], stream, version_0)
-      end.to raise_error(WrongExpectedEventVersion)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream_other, version_none)
+      expect { repository.link_to_stream([event2.event_id, event3.event_id], stream, version_0) }.to raise_error(
+        WrongExpectedEventVersion
+      )
 
       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
-      repository.append_to_stream([
-        eventA = SRecord.new,
-      ], stream, version_none)
-      expect do
-        repository.append_to_stream([
-          eventB = SRecord.new,
-        ], stream, version_none)
-      end.to raise_error(WrongExpectedEventVersion)
+      repository.append_to_stream([eventA = SRecord.new], stream, version_none)
+      expect { repository.append_to_stream([eventB = SRecord.new], stream, version_none) }.to raise_error(
+        WrongExpectedEventVersion
+      )
       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
-      repository.append_to_stream([
-        eventA = SRecord.new,
-        eventB = SRecord.new,
-      ], stream, version_none)
+      repository.append_to_stream([eventA = SRecord.new, eventB = SRecord.new], stream, version_none)
 
       repository.link_to_stream([eventA.event_id], stream_flow, version_none)
-      expect do
-        repository.link_to_stream([eventB.event_id], stream_flow, version_none)
-      end.to raise_error(WrongExpectedEventVersion)
+      expect { repository.link_to_stream([eventB.event_id], stream_flow, version_none) }.to raise_error(
+        WrongExpectedEventVersion
+      )
 
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_any)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_any)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_any)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_any)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_any)
-
-      repository.link_to_stream([
-        event0.event_id, event1.event_id,
-      ], stream_flow, version_any)
-      repository.link_to_stream([
-        event2.event_id, event3.event_id,
-      ], stream_flow, version_any)
+      repository.append_to_stream(
+        [event0 = SRecord.new, event1 = SRecord.new, event2 = SRecord.new, event3 = SRecord.new],
+        stream,
+        version_any
+      )
+
+      repository.link_to_stream([event0.event_id, event1.event_id], stream_flow, version_any)
+      repository.link_to_stream([event2.event_id, event3.event_id], stream_flow, version_any)
 
       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
-      repository.append_to_stream([
-        eventA = SRecord.new,
-        eventB = SRecord.new,
-        eventC = SRecord.new,
-      ], stream_other, version_auto)
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_auto)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_1)
+      repository.append_to_stream(
+        [eventA = SRecord.new, eventB = SRecord.new, eventC = SRecord.new],
+        stream_other,
+        version_auto
+      )
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_1)
     end
 
     specify ":auto queries for last position in given stream when linking" do
-      repository.append_to_stream([
-        eventA = SRecord.new,
-        eventB = SRecord.new,
-        eventC = SRecord.new,
-      ], stream_other, version_auto)
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_auto)
-      repository.link_to_stream([
-        eventA.event_id,
-        eventB.event_id,
-        eventC.event_id,
-      ], stream, version_1)
+      repository.append_to_stream(
+        [eventA = SRecord.new, eventB = SRecord.new, eventC = SRecord.new],
+        stream_other,
+        version_auto
+      )
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.link_to_stream([eventA.event_id, eventB.event_id, eventC.event_id], stream, version_1)
     end
 
     specify ":auto starts from 0" do
-      repository.append_to_stream([
-        event0 = SRecord.new,
-      ], stream, version_auto)
-      expect do
-        repository.append_to_stream([
-          event1 = SRecord.new,
-        ], stream, version_none)
-      end.to raise_error(WrongExpectedEventVersion)
+      repository.append_to_stream([event0 = SRecord.new], stream, version_auto)
+      expect { repository.append_to_stream([event1 = SRecord.new], stream, version_none) }.to raise_error(
+        WrongExpectedEventVersion
+      )
     end
 
     specify ":auto linking starts from 0" do
-      repository.append_to_stream([
-        event0 = SRecord.new,
-      ], stream_other, version_auto)
-      repository.link_to_stream([
-        event0.event_id,
-      ], stream, version_auto)
-      expect do
-        repository.append_to_stream([
-          event1 = SRecord.new,
-        ], stream, version_none)
-      end.to raise_error(WrongExpectedEventVersion)
+      repository.append_to_stream([event0 = SRecord.new], stream_other, version_auto)
+      repository.link_to_stream([event0.event_id], stream, version_auto)
+      expect { repository.append_to_stream([event1 = SRecord.new], stream, version_none) }.to raise_error(
+        WrongExpectedEventVersion
+      )
     end
 
     specify ":auto queries for last position and follows in incremental way" do
       # It is expected that there is higher level lock
       # So this query is safe from race conditions
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_auto)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_auto)
-      expect(read_events_forward(repository, count: 4)).to eq([
-        event0, event1,
-        event2, event3
-      ])
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_auto)
+      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 queries for last position and follows in incremental way when linking" do
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_auto)
-      repository.link_to_stream([
-        event0.event_id, event1.event_id,
-      ], stream_flow, version_auto)
-      repository.link_to_stream([
-        event2.event_id, event3.event_id,
-      ], stream_flow, version_auto)
-      expect(read_events_forward(repository, count: 4)).to eq([
-        event0, event1,
-        event2, event3
-      ])
+      repository.append_to_stream(
+        [event0 = SRecord.new, event1 = SRecord.new, event2 = SRecord.new, event3 = SRecord.new],
+        stream,
+        version_auto
+      )
+      repository.link_to_stream([event0.event_id, event1.event_id], stream_flow, version_auto)
+      repository.link_to_stream([event2.event_id, event3.event_id], stream_flow, version_auto)
+      expect(read_events_forward(repository, count: 4)).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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_auto)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_1)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_1)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_auto)
-      repository.link_to_stream([
-        event0.event_id,
-      ], stream_flow, version_auto)
-      repository.link_to_stream([
-        event1.event_id,
-      ], stream_flow, version_0)
-      expect(read_events_forward(repository, count: 4)).to eq([event0, event1,])
-      expect(read_events_forward(repository, stream_flow)).to eq([event0, event1,])
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.link_to_stream([event0.event_id], stream_flow, version_auto)
+      repository.link_to_stream([event1.event_id], stream_flow, version_0)
+      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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_none)
-      repository.append_to_stream([
-        event2 = SRecord.new,
-        event3 = SRecord.new,
-      ], stream, version_auto)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_none)
+      repository.append_to_stream([event2 = SRecord.new, event3 = SRecord.new], stream, version_auto)
       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
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new,
-      ], stream, version_auto)
-      repository.link_to_stream([
-        event0.event_id,
-      ], stream_flow, version_none)
-      repository.link_to_stream([
-        event1.event_id,
-      ], stream_flow, version_auto)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.link_to_stream([event0.event_id], stream_flow, version_none)
+      repository.link_to_stream([event1.event_id], stream_flow, version_auto)
       expect(read_events_forward(repository, count: 4)).to eq([event0, event1])
       expect(read_events_forward(repository, stream_flow)).to eq([event0, event1])
     end
@@ -405,34 +290,31 @@ module RubyEventStore
       verify_conncurency_assumptions(helper)
       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
-            true while wait_for_it
-            begin
-              100.times do |j|
-                eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.append_to_stream([
-                  SRecord.new(event_id: eid),
-                ], stream, version_any)
+        threads =
+          concurrency_level.times.map do |i|
+            Thread.new do
+              true while wait_for_it
+              begin
+                100.times do |j|
+                  eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
+                  repository.append_to_stream([SRecord.new(event_id: eid)], stream, version_any)
+                end
+              rescue WrongExpectedEventVersion
+                fail_occurred = true
               end
-            rescue WrongExpectedEventVersion
-              fail_occurred = true
             end
           end
-        end
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to eq(false)
         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-")
-        end
-        expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
+        events0 = events_in_stream.select { |ev| ev.event_id.start_with?("0-") }
+        expect(events0).to eq(events0.sort_by { |ev| ev.event_id })
       end
     end
 
@@ -441,86 +323,85 @@ module RubyEventStore
       verify_conncurency_assumptions(helper)
       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|
             eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-            repository.append_to_stream([
-              SRecord.new(event_id: eid),
-            ], stream, version_any)
+            repository.append_to_stream([SRecord.new(event_id: eid)], stream, version_any)
           end
         end
 
-        threads = concurrency_level.times.map do |i|
-          Thread.new do
-            true while wait_for_it
-            begin
-              100.times do |j|
-                eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.link_to_stream([eid], stream_flow, version_any)
+        threads =
+          concurrency_level.times.map do |i|
+            Thread.new do
+              true while wait_for_it
+              begin
+                100.times do |j|
+                  eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
+                  repository.link_to_stream([eid], stream_flow, version_any)
+                end
+              rescue WrongExpectedEventVersion
+                fail_occurred = true
               end
-            rescue WrongExpectedEventVersion
-              fail_occurred = true
             end
           end
-        end
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to eq(false)
         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-")
-        end
-        expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
+        events0 = events_in_stream.select { |ev| ev.event_id.start_with?("0-") }
+        expect(events0).to eq(events0.sort_by { |ev| ev.event_id })
       end
     end
 
-    specify "limited concurrency for :auto - some operations will fail without outside lock, stream is ordered", mutant: false do
+    specify "limited concurrency for :auto - some operations will fail without outside lock, stream is ordered",
+            mutant: false do
       skip unless helper.supports_concurrent_auto?
       verify_conncurency_assumptions(helper)
       begin
         concurrency_level = 4
 
         fail_occurred = 0
-        wait_for_it  = true
+        wait_for_it = true
 
-        threads = concurrency_level.times.map do |i|
-          Thread.new do
-            true while wait_for_it
-            100.times do |j|
-              begin
-                eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.append_to_stream([
-                  SRecord.new(event_id: eid),
-                ], stream, version_auto)
-                sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion
-                fail_occurred +=1
+        threads =
+          concurrency_level.times.map do |i|
+            Thread.new do
+              true while wait_for_it
+              100.times do |j|
+                begin
+                  eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
+                  repository.append_to_stream([SRecord.new(event_id: eid)], stream, version_auto)
+                  sleep(rand(concurrency_level) / 1000.0)
+                rescue WrongExpectedEventVersion
+                  fail_occurred += 1
+                end
               end
             end
           end
-        end
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to be > 0
         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|
-          ev.event_id.start_with?("0-")
-        end
-        expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
+        events0 = events_in_stream.select { |ev| ev.event_id.start_with?("0-") }
+        expect(events0).to eq(events0.sort_by { |ev| ev.event_id })
 
-        positions = repository.read(specification.stream(stream.name).result).map { |r| repository.position_in_stream(r.event_id, stream) }
+        positions =
+          repository
+            .read(specification.stream(stream.name).result)
+            .map { |r| repository.position_in_stream(r.event_id, stream) }
         expect(positions).to eq((0...positions.size).to_a)
       end
     end
 
-    specify "limited concurrency for :auto - some operations will fail without outside lock, stream is ordered", mutant: false do
+    specify "limited concurrency for :auto - some operations will fail without outside lock, stream is ordered",
+            mutant: false do
       skip unless helper.supports_concurrent_auto?
       verify_conncurency_assumptions(helper)
       begin
@@ -529,41 +410,41 @@ module RubyEventStore
         concurrency_level.times.map do |i|
           100.times do |j|
             eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-            repository.append_to_stream([
-              SRecord.new(event_id: eid),
-            ], stream_other, version_any)
+            repository.append_to_stream([SRecord.new(event_id: eid)], stream_other, version_any)
           end
         end
 
         fail_occurred = 0
-        wait_for_it  = true
+        wait_for_it = true
 
-        threads = concurrency_level.times.map do |i|
-          Thread.new do
-            true while wait_for_it
-            100.times do |j|
-              begin
-                eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.link_to_stream([eid], stream, version_auto)
-                sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion
-                fail_occurred +=1
+        threads =
+          concurrency_level.times.map do |i|
+            Thread.new do
+              true while wait_for_it
+              100.times do |j|
+                begin
+                  eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
+                  repository.link_to_stream([eid], stream, version_auto)
+                  sleep(rand(concurrency_level) / 1000.0)
+                rescue WrongExpectedEventVersion
+                  fail_occurred += 1
+                end
               end
             end
           end
-        end
         wait_for_it = false
         threads.each(&:join)
         expect(fail_occurred).to be > 0
         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|
-          ev.event_id.start_with?("0-")
-        end
-        expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
+        events0 = events_in_stream.select { |ev| ev.event_id.start_with?("0-") }
+        expect(events0).to eq(events0.sort_by { |ev| ev.event_id })
 
-        positions = repository.read(specification.stream(stream.name).result).map { |r| repository.position_in_stream(r.event_id, stream) }
+        positions =
+          repository
+            .read(specification.stream(stream.name).result)
+            .map { |r| repository.position_in_stream(r.event_id, stream) }
         expect(positions).to eq((0...positions.size).to_a)
       end
     end
@@ -591,10 +472,7 @@ module RubyEventStore
     end
 
     it "data and metadata attributes are retrieved when linking" do
-      event = SRecord.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, version_any)
         .link_to_stream([event.event_id], stream_flow, version_any)
@@ -611,7 +489,7 @@ module RubyEventStore
       repository.delete_stream(stream)
       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])
+      expect(read_events_forward(repository, count: 10)).to eq([e1, e2])
     end
 
     it "does not have deleted streams with linked events" do
@@ -639,10 +517,7 @@ module RubyEventStore
 
     it "#position_in_stream happy path" do
       skip unless helper.supports_position_queries?
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new
-      ], stream, version_auto)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
 
       expect(repository.position_in_stream(event0.event_id, stream)).to eq(0)
       expect(repository.position_in_stream(event1.event_id, stream)).to eq(1)
@@ -650,14 +525,8 @@ module RubyEventStore
 
     it "#position_in_stream happy path with linking" do
       skip unless helper.supports_position_queries?
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new
-      ], stream, version_auto)
-      repository.link_to_stream([
-        event1.event_id,
-        event0.event_id,
-      ], stream_other, version_auto)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.link_to_stream([event1.event_id, event0.event_id], stream_other, version_auto)
 
       expect(repository.position_in_stream(event0.event_id, stream)).to eq(0)
       expect(repository.position_in_stream(event1.event_id, stream)).to eq(1)
@@ -669,9 +538,7 @@ module RubyEventStore
       skip unless helper.supports_position_queries?
       just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
 
-      expect do
-        repository.position_in_stream(just_an_id, stream)
-      end.to raise_error(EventNotFoundInStream)
+      expect { repository.position_in_stream(just_an_id, stream) }.to raise_error(EventNotFoundInStream)
     end
 
     it "#position_in_stream when event is published without position" do
@@ -683,10 +550,7 @@ module RubyEventStore
 
     it "#global_position happy path" do
       skip unless helper.supports_position_queries?
-      repository.append_to_stream([
-        event0 = SRecord.new,
-        event1 = SRecord.new
-      ], stream, version_any)
+      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_any)
 
       expect(repository.global_position(event0.event_id)).to eq(0)
       expect(repository.global_position(event1.event_id)).to eq(1)
@@ -696,46 +560,94 @@ module RubyEventStore
       skip unless helper.supports_position_queries?
       just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
 
-      expect do
-        repository.global_position(just_an_id)
-      end.to raise_error do |err|
+      expect { repository.global_position(just_an_id) }.to raise_error do |err|
         expect(err).to be_a(EventNotFound)
         expect(err.event_id).to eq(just_an_id)
       end
     end
 
+    it "#event_in_stream? when event does not exist" do
+      skip unless helper.supports_event_in_stream_query?
+      repository.append_to_stream([SRecord.new], stream, version_any)
+      just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
+
+      expect(repository.event_in_stream?(just_an_id, stream)).to eq(false)
+    end
+
+    it "#event_in_stream? when event published into stream" do
+      skip unless helper.supports_event_in_stream_query?
+      repository.append_to_stream([event0 = SRecord.new], stream, version_any)
+
+      expect(repository.event_in_stream?(event0.event_id, stream)).to eq(true)
+    end
+
+    it "#event_in_stream? when event not linked into stream" do
+      skip unless helper.supports_event_in_stream_query?
+      repository.append_to_stream([SRecord.new], stream_flow, version_any)
+      repository.append_to_stream([event1 = SRecord.new], stream, version_any)
+
+      expect(repository.event_in_stream?(event1.event_id, stream_flow)).to eq(false)
+    end
+
+    it "#event_in_stream? when event linked into stream" do
+      skip unless helper.supports_event_in_stream_query?
+      repository.append_to_stream([event0 = SRecord.new], stream, version_any)
+      repository.link_to_stream([event0.event_id], stream_flow, version_any)
+
+      expect(repository.event_in_stream?(event0.event_id, stream_flow)).to eq(true)
+    end
+
+    it "#event_in_stream? when stream is empty" do
+      skip unless helper.supports_event_in_stream_query?
+      just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
+
+      expect(repository.event_in_stream?(just_an_id, stream)).to eq(false)
+    end
+
     it "knows last event in stream" do
-      repository.append_to_stream([a =SRecord.new(event_id: "00000000-0000-0000-0000-000000000001")], stream, version_none)
-      repository.append_to_stream([b = SRecord.new(event_id: "00000000-0000-0000-0000-000000000002")], stream, version_0)
+      repository.append_to_stream(
+        [a = SRecord.new(event_id: "00000000-0000-0000-0000-000000000001")],
+        stream,
+        version_none
+      )
+      repository.append_to_stream(
+        [b = SRecord.new(event_id: "00000000-0000-0000-0000-000000000002")],
+        stream,
+        version_0
+      )
 
       expect(repository.last_stream_event(stream)).to eq(b)
       expect(repository.last_stream_event(stream_other)).to be_nil
     end
 
     it "knows last event in stream when linked" do
-      repository.append_to_stream([
-          e0 = SRecord.new(event_id: "00000000-0000-0000-0000-000000000001"),
-          e1 = SRecord.new(event_id: "00000000-0000-0000-0000-000000000002"),
-        ],
-        stream,
-        version_none
-      ).link_to_stream([e1.event_id, e0.event_id], stream_flow, version_none)
+      repository
+        .append_to_stream(
+          [
+            e0 = SRecord.new(event_id: "00000000-0000-0000-0000-000000000001"),
+            e1 = SRecord.new(event_id: "00000000-0000-0000-0000-000000000002")
+          ],
+          stream,
+          version_none
+        )
+        .link_to_stream([e1.event_id, e0.event_id], stream_flow, version_none)
       expect(repository.last_stream_event(stream_flow)).to eq(e0)
     end
 
     it "reads batch of events from stream forward & backward" do
-      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 =
+        %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], stream_other, version_none)
       events.each.with_index do |event, index|
         repository.append_to_stream([event], stream, ExpectedVersion.new(index - 1))
@@ -752,25 +664,30 @@ module RubyEventStore
 
       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, 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
-      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 =
+        %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], stream_other, version_none)
       events.each.with_index do |event, index|
         repository
@@ -788,10 +705,18 @@ module RubyEventStore
 
       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)
+      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
@@ -804,8 +729,8 @@ 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_events_forward(repository, s1)).to eq [a,c]
-      expect(read_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
@@ -822,26 +747,25 @@ 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_events_forward(repository, fs1)).to eq [a,c]
-      expect(read_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
-      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], Stream.new(SecureRandom.uuid), version_none)
-      end
+      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 { |ev| repository.append_to_stream([ev], Stream.new(SecureRandom.uuid), version_none) }
 
       expect(read_events_forward(repository, count: 3)).to eq(events.first(3))
       expect(read_events_forward(repository, count: 100)).to eq(events)
@@ -859,18 +783,19 @@ module RubyEventStore
     end
 
     it "linked events do not affect reading from all streams - no duplicates" do
-      events = %w[
-        96c920b1-cdd0-40f4-907c-861b9fff7d02
-        56404f79-0ba0-4aa0-8524-dc3436368ca0
-        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 =
+        %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], Stream.new(SecureRandom.uuid), version_none)
@@ -893,45 +818,43 @@ module RubyEventStore
     end
 
     it "reads events different uuid object but same content" do
-      events = %w[
-        96c920b1-cdd0-40f4-907c-861b9fff7d02
-        56404f79-0ba0-4aa0-8524-dc3436368ca0
-      ].map{|id| SRecord.new(event_id: id) }
+      events =
+        %w[96c920b1-cdd0-40f4-907c-861b9fff7d02 56404f79-0ba0-4aa0-8524-dc3436368ca0].map do |id|
+          SRecord.new(event_id: id)
+        end
       repository.append_to_stream([events.first], stream, version_none)
-      repository.append_to_stream([events.last],  stream,  version_0)
+      repository.append_to_stream([events.last], stream, version_0)
 
       expect(read_events_forward(repository, from: "96c920b1-cdd0-40f4-907c-861b9fff7d02")).to eq([events.last])
       expect(read_events_backward(repository, from: "56404f79-0ba0-4aa0-8524-dc3436368ca0")).to eq([events.first])
-      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, 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, 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])
+      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
-      repository.append_to_stream(
-        [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
-        stream,
-        version_none
-      )
+      repository.append_to_stream([SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")], stream, version_none)
       expect do
-        repository.append_to_stream(
-          [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
-          stream,
-          version_0
-        )
+        repository.append_to_stream([SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")], stream, version_0)
       end.to raise_error(EventDuplicatedInStream)
     end
 
     it "does not allow same event twice" do
-      repository.append_to_stream(
-        [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
-        stream,
-        version_none
-      )
+      repository.append_to_stream([SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")], stream, version_none)
       expect do
         repository.append_to_stream(
           [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
@@ -942,11 +865,9 @@ module RubyEventStore
     end
 
     it "does not allow linking same event twice in a stream" do
-      repository.append_to_stream(
-        [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
-        stream,
-        version_none
-      ).link_to_stream(["a1b49edb-7636-416f-874a-88f94b859bef"], stream_flow, version_none)
+      repository
+        .append_to_stream([SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")], stream, version_none)
+        .link_to_stream(["a1b49edb-7636-416f-874a-88f94b859bef"], stream_flow, version_none)
       expect do
         repository.link_to_stream(["a1b49edb-7636-416f-874a-88f94b859bef"], stream_flow, version_0)
       end.to raise_error(EventDuplicatedInStream)
@@ -993,11 +914,7 @@ module RubyEventStore
       binary.force_encoding("binary")
       expect(binary.valid_encoding?).to eq(true)
 
-      repository.append_to_stream(
-        [event = SRecord.new(data: binary, metadata: binary)],
-        stream,
-        version_none
-      )
+      repository.append_to_stream([event = SRecord.new(data: binary, metadata: binary)], stream, version_none)
     end
 
     specify do
@@ -1005,29 +922,16 @@ module RubyEventStore
       expect(repository.read(specification.in_batches.as_at.result)).to be_kind_of(Enumerator)
       expect(repository.read(specification.in_batches.as_of.result)).to be_kind_of(Enumerator)
       events = Array.new(10) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new("Dummy"),
-        ExpectedVersion.none
-      )
+      repository.append_to_stream(events, Stream.new("Dummy"), ExpectedVersion.none)
       expect(repository.read(specification.in_batches.result)).to be_kind_of(Enumerator)
       expect(repository.read(specification.in_batches.as_at.result)).to be_kind_of(Enumerator)
       expect(repository.read(specification.in_batches.as_of.result)).to be_kind_of(Enumerator)
-
     end
 
     specify do
       events = Array.new(400) { SRecord.new }
-      repository.append_to_stream(
-        events[200...400],
-        Stream.new("Foo"),
-        ExpectedVersion.none
-      )
-      repository.append_to_stream(
-        events[0...200],
-        Stream.new("Dummy"),
-        ExpectedVersion.none
-      )
+      repository.append_to_stream(events[200...400], Stream.new("Foo"), ExpectedVersion.none)
+      repository.append_to_stream(events[0...200], Stream.new("Dummy"), ExpectedVersion.none)
 
       batches = repository.read(specification.stream("Dummy").in_batches.result).to_a
       expect(batches.size).to eq(2)
@@ -1037,11 +941,7 @@ module RubyEventStore
 
     specify do
       events = Array.new(200) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       batches = repository.read(specification.in_batches.result).to_a
       expect(batches.size).to eq(2)
@@ -1051,22 +951,14 @@ module RubyEventStore
 
     specify do
       events = Array.new(200) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       expect(repository.read(specification.in_batches(200).result).to_a.size).to eq(1)
     end
 
     specify do
       events = Array.new(200) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       batches = repository.read(specification.limit(199).in_batches.result).to_a
       expect(batches.size).to eq(2)
@@ -1078,11 +970,7 @@ module RubyEventStore
 
     specify do
       events = Array.new(200) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       batches = repository.read(specification.limit(99).in_batches.result).to_a
       expect(batches.size).to eq(1)
@@ -1092,11 +980,7 @@ module RubyEventStore
 
     specify do
       events = Array.new(200) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       batches = repository.read(specification.backward.limit(99).in_batches.result).to_a
       expect(batches.size).to eq(1)
@@ -1106,11 +990,7 @@ module RubyEventStore
 
     specify do
       events = Array.new(200) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       batches = repository.read(specification.from(events[100].event_id).limit(99).in_batches.result).to_a
       expect(batches.size).to eq(1)
@@ -1123,11 +1003,7 @@ module RubyEventStore
       expect(repository.read(specification.read_last.result)).to be_nil
 
       events = Array.new(5) { SRecord.new }
-      repository.append_to_stream(
-        events,
-        Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
-      )
+      repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
 
       expect(repository.read(specification.stream("Any").read_first.result)).to be_nil
       expect(repository.read(specification.stream("Any").read_last.result)).to be_nil
@@ -1167,33 +1043,70 @@ module RubyEventStore
       specify "changes events" do
         skip unless helper.supports_upsert?
         events = Array.new(5) { SRecord.new }
-        repository.append_to_stream(
-          events[0..2],
-          Stream.new("whatever"),
-          ExpectedVersion.any
+        repository.append_to_stream(events[0..2], Stream.new("whatever"), ExpectedVersion.any)
+        repository.append_to_stream(events[3..4], Stream.new("elo"), ExpectedVersion.any)
+        repository.update_messages(
+          [
+            a =
+              SRecord.new(
+                event_id: events[0].event_id.clone,
+                data: events[0].data,
+                metadata: events[0].metadata,
+                event_type: events[0].event_type,
+                timestamp: events[0].timestamp
+              ),
+            b =
+              SRecord.new(
+                event_id: events[1].event_id.dup,
+                data: {
+                  "test" => 1
+                },
+                metadata: events[1].metadata,
+                event_type: events[1].event_type,
+                timestamp: events[1].timestamp
+              ),
+            c =
+              SRecord.new(
+                event_id: events[2].event_id,
+                data: events[2].data,
+                metadata: {
+                  "test" => 2
+                },
+                event_type: events[2].event_type,
+                timestamp: events[2].timestamp
+              ),
+            d =
+              SRecord.new(
+                event_id: events[3].event_id.clone,
+                data: events[3].data,
+                metadata: events[3].metadata,
+                event_type: "event_type3",
+                timestamp: events[3].timestamp
+              ),
+            e =
+              SRecord.new(
+                event_id: events[4].event_id.dup,
+                data: {
+                  "test" => 4
+                },
+                metadata: {
+                  "test" => 42
+                },
+                event_type: "event_type4",
+                timestamp: events[4].timestamp
+              )
+          ]
         )
-        repository.append_to_stream(
-          events[3..4],
-          Stream.new("elo"),
-          ExpectedVersion.any
-        )
-        repository.update_messages([
-          a = SRecord.new(event_id: events[0].event_id.clone, data: events[0].data,  metadata: events[0].metadata, event_type: events[0].event_type, timestamp: events[0].timestamp),
-          b = SRecord.new(event_id: events[1].event_id.dup,   data: { "test" => 1 }, metadata: events[1].metadata, event_type: events[1].event_type, timestamp: events[1].timestamp),
-          c = SRecord.new(event_id: events[2].event_id,       data: events[2].data,  metadata: { "test" => 2 },    event_type: events[2].event_type, timestamp: events[2].timestamp),
-          d = SRecord.new(event_id: events[3].event_id.clone, data: events[3].data,  metadata: events[3].metadata, event_type: "event_type3",        timestamp: events[3].timestamp),
-          e = SRecord.new(event_id: events[4].event_id.dup,   data: { "test" => 4 }, metadata: { "test" => 42 },   event_type: "event_type4",        timestamp: events[4].timestamp),
-        ])
-
-        expect(repository.read(specification.result).to_a).to eq([a,b,c,d,e])
-        expect(repository.read(specification.stream("whatever").result).to_a).to eq([a,b,c])
-        expect(repository.read(specification.stream("elo").result).to_a).to eq([d,e])
+
+        expect(repository.read(specification.result).to_a).to eq([a, b, c, d, e])
+        expect(repository.read(specification.stream("whatever").result).to_a).to eq([a, b, c])
+        expect(repository.read(specification.stream("elo").result).to_a).to eq([d, e])
       end
 
       specify "cannot change unexisting event" do
         skip unless helper.supports_upsert?
         e = SRecord.new
-        expect{ repository.update_messages([e]) }.to raise_error do |err|
+        expect { repository.update_messages([e]) }.to raise_error do |err|
           expect(err).to be_a(EventNotFound)
           expect(err.event_id).to eq(e.event_id)
           expect(err.message).to eq("Event not found: #{e.event_id}")
@@ -1233,28 +1146,40 @@ module RubyEventStore
       stream = Stream.new("Stream A")
       repository.append_to_stream([e1, e2, e3], stream, version_any)
 
-      expect(repository.read(specification.with_id([
-        "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea"
-      ]).read_first.result)).to eq(e1)
-      expect(repository.read(specification.with_id([
-        "d345f86d-b903-4d78-803f-38990c078d9e"
-      ]).read_first.result)).to eq(e3)
-      expect(repository.read(specification.with_id([
-        "c31b327c-0da1-4178-a3cd-d2f6bb5d0688"
-      ]).read_first.result)).to eq(nil)
-      expect(repository.read(specification.with_id([
-        "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea",
-        "d345f86d-b903-4d78-803f-38990c078d9e"
-      ]).in_batches.result).to_a[0]).to eq([e1,e3])
-      expect(repository.read(specification.stream("Stream A").with_id([
-        "8cee1139-4f96-483a-a175-2b947283c3c7"
-      ]).read_first.result)).to eq(e2)
-      expect(repository.read(specification.stream("Stream B").with_id([
-        "8cee1139-4f96-483a-a175-2b947283c3c7"
-      ]).read_first.result)).to eq(nil)
-      expect(repository.read(specification.stream("Stream B").with_id([
-        "c31b327c-0da1-4178-a3cd-d2f6bb5d0688"
-      ]).read_first.result)).to eq(nil)
+      expect(repository.read(specification.with_id(["8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea"]).read_first.result)).to eq(
+        e1
+      )
+      expect(repository.read(specification.with_id(["d345f86d-b903-4d78-803f-38990c078d9e"]).read_first.result)).to eq(
+        e3
+      )
+      expect(repository.read(specification.with_id(["c31b327c-0da1-4178-a3cd-d2f6bb5d0688"]).read_first.result)).to eq(
+        nil
+      )
+      expect(
+        repository.read(
+          specification
+            .with_id(%w[8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea d345f86d-b903-4d78-803f-38990c078d9e])
+            .in_batches
+            .result
+        ).to_a[
+          0
+        ]
+      ).to eq([e1, e3])
+      expect(
+        repository.read(
+          specification.stream("Stream A").with_id(["8cee1139-4f96-483a-a175-2b947283c3c7"]).read_first.result
+        )
+      ).to eq(e2)
+      expect(
+        repository.read(
+          specification.stream("Stream B").with_id(["8cee1139-4f96-483a-a175-2b947283c3c7"]).read_first.result
+        )
+      ).to eq(nil)
+      expect(
+        repository.read(
+          specification.stream("Stream B").with_id(["c31b327c-0da1-4178-a3cd-d2f6bb5d0688"]).read_first.result
+        )
+      ).to eq(nil)
       expect(repository.read(specification.with_id([]).result).to_a).to eq([])
     end
 
@@ -1265,20 +1190,18 @@ module RubyEventStore
       stream = Stream.new("Stream A")
       repository.append_to_stream([e1, e2, e3], stream, version_any)
 
-      expect(repository.read(specification.of_type([Type1]).result).to_a).to eq([e1,e3])
+      expect(repository.read(specification.of_type([Type1]).result).to_a).to eq([e1, e3])
       expect(repository.read(specification.of_type([Type2]).result).to_a).to eq([e2])
       expect(repository.read(specification.of_type([Type3]).result).to_a).to eq([])
-      expect(repository.read(specification.of_type([Type1, Type2, Type3]).result).to_a).to eq([e1,e2,e3])
+      expect(repository.read(specification.of_type([Type1, Type2, Type3]).result).to_a).to eq([e1, e2, e3])
     end
 
     specify do
       stream = Stream.new("Stream A")
-      dummy  = Stream.new("Dummy")
+      dummy = Stream.new("Dummy")
 
       expect(repository.count(specification.result)).to eq(0)
-      (1..3).each do
-        repository.append_to_stream([SRecord.new(event_type: Type1.to_s)], stream, version_any)
-      end
+      (1..3).each { repository.append_to_stream([SRecord.new(event_type: Type1.to_s)], stream, version_any) }
       expect(repository.count(specification.result)).to eq(3)
       event_id = SecureRandom.uuid
       repository.append_to_stream([SRecord.new(event_type: Type1.to_s, event_id: event_id)], dummy, version_any)
@@ -1313,7 +1236,7 @@ module RubyEventStore
     end
 
     specify "timestamp precision" do
-      time = Time.utc(2020, 9, 11, 12, 26, 0, 123456)
+      time = Time.utc(2020, 9, 11, 12, 26, 0, 123_456)
       repository.append_to_stream([SRecord.new(timestamp: time)], stream, version_none)
       event = read_events_forward(repository, count: 1).first
 
@@ -1326,7 +1249,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream("whatever").older_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1])
+      expect(repository.read(specification.stream("whatever").older_than(Time.utc(2020, 1, 2)).result).to_a).to eq(
+        [event_1]
+      )
     end
 
     specify "fetching records older than or equal to specified date in stream" do
@@ -1335,7 +1260,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream("whatever").older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1, event_2])
+      expect(
+        repository.read(specification.stream("whatever").older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a
+      ).to eq([event_1, event_2])
     end
 
     specify "fetching records newer than specified date in stream" do
@@ -1344,7 +1271,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream("whatever").newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq([event_3])
+      expect(repository.read(specification.stream("whatever").newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq(
+        [event_3]
+      )
     end
 
     specify "fetching records newer than or equal to specified date in stream" do
@@ -1353,7 +1282,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.stream("whatever").newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_2, event_3])
+      expect(
+        repository.read(specification.stream("whatever").newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a
+      ).to eq([event_2, event_3])
     end
 
     specify "fetching records older than specified date" do
@@ -1371,7 +1302,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_1, event_2])
+      expect(repository.read(specification.older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq(
+        [event_1, event_2]
+      )
     end
 
     specify "fetching records newer than specified date" do
@@ -1389,7 +1322,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq([event_2, event_3])
+      expect(repository.read(specification.newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a).to eq(
+        [event_2, event_3]
+      )
     end
 
     specify "fetching records from disjoint periods" do
@@ -1398,7 +1333,9 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.older_than(Time.utc(2020, 1, 2)).newer_than(Time.utc(2020, 1, 2)).result).to_a).to eq([])
+      expect(
+        repository.read(specification.older_than(Time.utc(2020, 1, 2)).newer_than(Time.utc(2020, 1, 2)).result).to_a
+      ).to eq([])
     end
 
     specify "fetching records within time range" do
@@ -1407,38 +1344,58 @@ module RubyEventStore
       event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
       repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
 
-      expect(repository.read(specification.between(Time.utc(2020, 1, 1)...Time.utc(2020, 1, 3)).result).to_a).to eq([event_1, event_2])
+      expect(repository.read(specification.between(Time.utc(2020, 1, 1)...Time.utc(2020, 1, 3)).result).to_a).to eq(
+        [event_1, event_2]
+      )
     end
 
     specify "time order is respected" do
-      repository.append_to_stream([
-          SRecord.new(event_id: e1 = SecureRandom.uuid, timestamp: Time.new(2020,1,1), valid_at: Time.new(2020,1,9)),
-          SRecord.new(event_id: e2 = SecureRandom.uuid, timestamp: Time.new(2020,1,3), valid_at: Time.new(2020,1,6)),
-          SRecord.new(event_id: e3 = SecureRandom.uuid, timestamp: Time.new(2020,1,2), valid_at: Time.new(2020,1,3)),
+      repository.append_to_stream(
+        [
+          SRecord.new(
+            event_id: e1 = SecureRandom.uuid,
+            timestamp: Time.new(2020, 1, 1),
+            valid_at: Time.new(2020, 1, 9)
+          ),
+          SRecord.new(
+            event_id: e2 = SecureRandom.uuid,
+            timestamp: Time.new(2020, 1, 3),
+            valid_at: Time.new(2020, 1, 6)
+          ),
+          SRecord.new(event_id: e3 = SecureRandom.uuid, timestamp: Time.new(2020, 1, 2), valid_at: Time.new(2020, 1, 3))
         ],
         Stream.new("Dummy"),
         ExpectedVersion.any
       )
-      expect(repository.read(specification.result)).to                eq_ids([e1, e2, e3])
-      expect(repository.read(specification.as_at.result)).to          eq_ids([e1, e3, e2])
+      expect(repository.read(specification.result)).to eq_ids([e1, e2, e3])
+      expect(repository.read(specification.as_at.result)).to eq_ids([e1, e3, e2])
       expect(repository.read(specification.as_at.backward.result)).to eq_ids([e2, e3, e1])
-      expect(repository.read(specification.as_of.result)).to          eq_ids([e3, e2, e1])
+      expect(repository.read(specification.as_of.result)).to eq_ids([e3, e2, e1])
       expect(repository.read(specification.as_of.backward.result)).to eq_ids([e1, e2, e3])
     end
 
     specify "time order is respected with batches" do
-      repository.append_to_stream([
-        SRecord.new(event_id: e1 = SecureRandom.uuid, timestamp: Time.new(2020,1,1), valid_at: Time.new(2020,1,9)),
-        SRecord.new(event_id: e2 = SecureRandom.uuid, timestamp: Time.new(2020,1,3), valid_at: Time.new(2020,1,6)),
-        SRecord.new(event_id: e3 = SecureRandom.uuid, timestamp: Time.new(2020,1,2), valid_at: Time.new(2020,1,3)),
-      ],
+      repository.append_to_stream(
+        [
+          SRecord.new(
+            event_id: e1 = SecureRandom.uuid,
+            timestamp: Time.new(2020, 1, 1),
+            valid_at: Time.new(2020, 1, 9)
+          ),
+          SRecord.new(
+            event_id: e2 = SecureRandom.uuid,
+            timestamp: Time.new(2020, 1, 3),
+            valid_at: Time.new(2020, 1, 6)
+          ),
+          SRecord.new(event_id: e3 = SecureRandom.uuid, timestamp: Time.new(2020, 1, 2), valid_at: Time.new(2020, 1, 3))
+        ],
         Stream.new("Dummy"),
         ExpectedVersion.any
       )
-      expect(repository.read(specification.in_batches.result).to_a.flatten).to                eq_ids([e1, e2, e3])
-      expect(repository.read(specification.in_batches.as_at.result).to_a.flatten).to          eq_ids([e1, e3, e2])
+      expect(repository.read(specification.in_batches.result).to_a.flatten).to eq_ids([e1, e2, e3])
+      expect(repository.read(specification.in_batches.as_at.result).to_a.flatten).to eq_ids([e1, e3, e2])
       expect(repository.read(specification.in_batches.as_at.backward.result).to_a.flatten).to eq_ids([e2, e3, e1])
-      expect(repository.read(specification.in_batches.as_of.result).to_a.flatten).to          eq_ids([e3, e2, e1])
+      expect(repository.read(specification.in_batches.as_of.result).to_a.flatten).to eq_ids([e3, e2, e1])
       expect(repository.read(specification.in_batches.as_of.backward.result).to_a.flatten).to eq_ids([e1, e2, e3])
     end
   end