ruby_event_store 2.16.0 → 2.17.0

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -17,7 +17,7 @@ module RubyEventStore
         metadata: metadata,
         event_type: event_type,
         timestamp: timestamp.round(TIMESTAMP_PRECISION),
-        valid_at: (valid_at || timestamp).round(TIMESTAMP_PRECISION)
+        valid_at: (valid_at || timestamp).round(TIMESTAMP_PRECISION),
       )
     end
   end
@@ -33,14 +33,14 @@ module RubyEventStore
 end
 
 module RubyEventStore
-  ::RSpec.shared_examples :event_repository do |mk_repository, helper|
+  ::RSpec.shared_examples "event repository" do |mk_repository, helper|
     let(:repository) { mk_repository.call }
     let(:specification) { Specification.new(SpecificationReader.new(repository, Mappers::Default.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(:version_none) { ExpectedVersion.none }
     let(:version_auto) { ExpectedVersion.auto }
     let(:version_any) { ExpectedVersion.any }
@@ -76,9 +76,11 @@ module RubyEventStore
     end
 
     specify "append_to_stream returns self" do
-      repository
-        .append_to_stream([event = SRecord.new], stream, version_none)
-        .append_to_stream([event = SRecord.new], stream, version_0)
+      repository.append_to_stream([SRecord.new], stream, version_none).append_to_stream(
+        [SRecord.new],
+        stream,
+        version_0,
+      )
     end
 
     specify "link_to_stream returns self" do
@@ -98,9 +100,11 @@ module RubyEventStore
     end
 
     specify "links an initial event to a new stream" do
-      repository
-        .append_to_stream([event = SRecord.new], stream, version_none)
-        .link_to_stream([event.event_id], stream_flow, version_none)
+      repository.append_to_stream([event = SRecord.new], stream, version_none).link_to_stream(
+        [event.event_id],
+        stream_flow,
+        version_none,
+      )
 
       expect(read_events_forward(repository, count: 1).first).to eq(event)
       expect(read_events_forward(repository, stream).first).to eq(event)
@@ -115,9 +119,11 @@ module RubyEventStore
     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
@@ -140,9 +146,9 @@ module RubyEventStore
 
     specify "incorrect expected version on second write" do
       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)
-      end.to raise_error(WrongExpectedEventVersion)
+      expect do repository.append_to_stream([SRecord.new, SRecord.new], stream, version_0) end.to raise_error(
+        WrongExpectedEventVersion,
+      )
 
       expect(read_events_forward(repository, count: 4)).to eq([event0, event1])
       expect(read_events_forward(repository, stream)).to eq([event0, event1])
@@ -152,7 +158,7 @@ module RubyEventStore
       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
+        WrongExpectedEventVersion,
       )
 
       expect(read_events_forward(repository, count: 4)).to eq([event0, event1, event2, event3])
@@ -161,8 +167,8 @@ module RubyEventStore
 
     specify ":none on first and subsequent write" do
       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 { repository.append_to_stream([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])
@@ -173,7 +179,7 @@ module RubyEventStore
 
       repository.link_to_stream([eventA.event_id], stream_flow, version_none)
       expect { repository.link_to_stream([eventB.event_id], stream_flow, version_none) }.to raise_error(
-        WrongExpectedEventVersion
+        WrongExpectedEventVersion,
       )
 
       expect(read_events_forward(repository, count: 1)).to eq([eventA])
@@ -191,7 +197,7 @@ module RubyEventStore
       repository.append_to_stream(
         [event0 = SRecord.new, event1 = SRecord.new, event2 = SRecord.new, event3 = SRecord.new],
         stream,
-        version_any
+        version_any,
       )
 
       repository.link_to_stream([event0.event_id, event1.event_id], stream_flow, version_any)
@@ -202,37 +208,33 @@ module RubyEventStore
     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([SRecord.new, SRecord.new, SRecord.new], stream_other, version_auto)
+      repository.append_to_stream([SRecord.new, SRecord.new], stream, version_auto)
+      repository.append_to_stream([SRecord.new, 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
+        version_auto,
       )
-      repository.append_to_stream([event0 = SRecord.new, event1 = SRecord.new], stream, version_auto)
+      repository.append_to_stream([SRecord.new, 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 { repository.append_to_stream([event1 = SRecord.new], stream, version_none) }.to raise_error(
-        WrongExpectedEventVersion
+      repository.append_to_stream([SRecord.new], stream, version_auto)
+      expect { repository.append_to_stream([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 { repository.append_to_stream([event1 = SRecord.new], stream, version_none) }.to raise_error(
-        WrongExpectedEventVersion
+      expect { repository.append_to_stream([SRecord.new], stream, version_none) }.to raise_error(
+        WrongExpectedEventVersion,
       )
     end
 
@@ -249,7 +251,7 @@ module RubyEventStore
       repository.append_to_stream(
         [event0 = SRecord.new, event1 = SRecord.new, event2 = SRecord.new, event3 = SRecord.new],
         stream,
-        version_auto
+        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)
@@ -311,7 +313,7 @@ module RubyEventStore
           end
         wait_for_it = false
         threads.each(&:join)
-        expect(fail_occurred).to eq(false)
+        expect(fail_occurred).to be(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)
@@ -351,7 +353,7 @@ module RubyEventStore
           end
         wait_for_it = false
         threads.each(&:join)
-        expect(fail_occurred).to eq(false)
+        expect(fail_occurred).to be(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)
@@ -475,9 +477,11 @@ module RubyEventStore
 
     it "data and metadata attributes are retrieved when linking" do
       event = SRecord.new(data: { "order_id" => 3 }, metadata: { "request_id" => 4 })
-      repository
-        .append_to_stream([event], stream, version_any)
-        .link_to_stream([event.event_id], stream_flow, version_any)
+      repository.append_to_stream([event], stream, version_any).link_to_stream(
+        [event.event_id],
+        stream_flow,
+        version_any,
+      )
       retrieved_event = read_events_forward(repository, stream_flow).first
       expect(retrieved_event.metadata).to eq({ "request_id" => 4 })
       expect(retrieved_event.data).to eq({ "order_id" => 3 })
@@ -495,9 +499,11 @@ module RubyEventStore
     end
 
     it "does not have deleted streams with linked events" do
-      repository
-        .append_to_stream([e1 = SRecord.new], stream, version_none)
-        .link_to_stream([e1.event_id], stream_flow, version_none)
+      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_events_forward(repository, stream_flow)).to be_empty
@@ -508,13 +514,13 @@ module RubyEventStore
       just_an_id = "d5c134c2-db65-4e87-b6ea-d196f8f1a292"
       repository.append_to_stream([SRecord.new(event_id: just_an_id)], stream, version_none)
 
-      expect(repository.has_event?(just_an_id)).to be_truthy
-      expect(repository.has_event?(just_an_id.clone)).to be_truthy
+      expect(repository).to have_event(just_an_id)
+      expect(repository).to have_event(just_an_id.clone)
       expect(repository.has_event?("any other id")).to be false
 
       repository.delete_stream(stream)
-      expect(repository.has_event?(just_an_id)).to be_truthy
-      expect(repository.has_event?(just_an_id.clone)).to be_truthy
+      expect(repository).to have_event(just_an_id)
+      expect(repository).to have_event(just_an_id.clone)
     end
 
     it "#position_in_stream happy path" do
@@ -547,7 +553,7 @@ module RubyEventStore
       skip unless helper.supports_position_queries?
       repository.append_to_stream([event0 = SRecord.new], stream, version_any)
 
-      expect(repository.position_in_stream(event0.event_id, stream)).to eq(nil)
+      expect(repository.position_in_stream(event0.event_id, stream)).to be_nil
     end
 
     it "#global_position happy path" do
@@ -573,14 +579,14 @@ module RubyEventStore
       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)
+      expect(repository.event_in_stream?(just_an_id, stream)).to be(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)
+      expect(repository.event_in_stream?(event0.event_id, stream)).to be(true)
     end
 
     it "#event_in_stream? when event not linked into stream" do
@@ -588,7 +594,7 @@ module RubyEventStore
       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)
+      expect(repository.event_in_stream?(event1.event_id, stream_flow)).to be(false)
     end
 
     it "#event_in_stream? when event linked into stream" do
@@ -596,26 +602,22 @@ module RubyEventStore
       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)
+      expect(repository.event_in_stream?(event0.event_id, stream_flow)).to be(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)
+      expect(repository.event_in_stream?(just_an_id, stream)).to be(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([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
+        version_0,
       )
 
       expect(repository.last_stream_event(stream)).to eq(b)
@@ -623,16 +625,14 @@ module RubyEventStore
     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
 
@@ -667,10 +667,10 @@ 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
+        events.first(4).reverse,
       )
       expect(read_events_backward(repository, stream, from: events[4].event_id, count: 100)).to eq(
-        events.first(4).reverse
+        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)
@@ -692,9 +692,11 @@ module RubyEventStore
         ].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))
-          .link_to_stream([event.event_id], stream_flow, ExpectedVersion.new(index - 1))
+        repository.append_to_stream([event], stream, ExpectedVersion.new(index - 1)).link_to_stream(
+          [event.event_id],
+          stream_flow,
+          ExpectedVersion.new(index - 1),
+        )
       end
       repository.append_to_stream([SRecord.new], stream_other, version_0)
 
@@ -708,16 +710,16 @@ 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
+        events.first(4).reverse,
       )
       expect(read_events_backward(repository, stream_flow, from: events[4].event_id, count: 100)).to eq(
-        events.first(4).reverse
+        events.first(4).reverse,
       )
       expect(read_events_backward(repository, stream_flow, to: events[4].event_id, count: 4)).to eq(
-        events[6..9].reverse
+        events[6..9].reverse,
       )
       expect(read_events_backward(repository, stream_flow, to: events[4].event_id, count: 100)).to eq(
-        events[5..9].reverse
+        events[5..9].reverse,
       )
     end
 
@@ -726,10 +728,10 @@ module RubyEventStore
       s2 = stream_other
       repository
         .append_to_stream([a = SRecord.new(event_id: "7010d298-ab69-4bb1-9251-f3466b5d1282")], s1, version_none)
-        .append_to_stream([b = SRecord.new(event_id: "34f88aca-aaba-4ca0-9256-8017b47528c5")], s2, version_none)
+        .append_to_stream([SRecord.new(event_id: "34f88aca-aaba-4ca0-9256-8017b47528c5")], s2, version_none)
         .append_to_stream([c = SRecord.new(event_id: "8e61c864-ceae-4684-8726-97c34eb8fc4f")], s1, version_0)
-        .append_to_stream([d = SRecord.new(event_id: "30963ed9-6349-450b-ac9b-8ea50115b3bd")], s2, version_0)
-        .append_to_stream([e = SRecord.new(event_id: "5bdc58b7-e8a7-4621-afd6-ccb828d72457")], s2, version_1)
+        .append_to_stream([SRecord.new(event_id: "30963ed9-6349-450b-ac9b-8ea50115b3bd")], s2, version_0)
+        .append_to_stream([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]
@@ -739,10 +741,10 @@ module RubyEventStore
       s1, fs1, fs2 = stream, stream_flow, stream_other
       repository
         .append_to_stream([a = SRecord.new(event_id: "7010d298-ab69-4bb1-9251-f3466b5d1282")], s1, version_none)
-        .append_to_stream([b = SRecord.new(event_id: "34f88aca-aaba-4ca0-9256-8017b47528c5")], s1, version_0)
+        .append_to_stream([SRecord.new(event_id: "34f88aca-aaba-4ca0-9256-8017b47528c5")], s1, version_0)
         .append_to_stream([c = SRecord.new(event_id: "8e61c864-ceae-4684-8726-97c34eb8fc4f")], s1, version_1)
-        .append_to_stream([d = SRecord.new(event_id: "30963ed9-6349-450b-ac9b-8ea50115b3bd")], s1, version_2)
-        .append_to_stream([e = SRecord.new(event_id: "5bdc58b7-e8a7-4621-afd6-ccb828d72457")], s1, version_3)
+        .append_to_stream([SRecord.new(event_id: "30963ed9-6349-450b-ac9b-8ea50115b3bd")], s1, version_2)
+        .append_to_stream([SRecord.new(event_id: "5bdc58b7-e8a7-4621-afd6-ccb828d72457")], s1, version_3)
         .link_to_stream(["7010d298-ab69-4bb1-9251-f3466b5d1282"], fs1, version_none)
         .link_to_stream(["34f88aca-aaba-4ca0-9256-8017b47528c5"], fs2, version_none)
         .link_to_stream(["8e61c864-ceae-4684-8726-97c34eb8fc4f"], fs1, version_0)
@@ -799,9 +801,11 @@ module RubyEventStore
           868cac42-3d19-4b39-84e8-cd32d65c2445
         ].map { |id| SRecord.new(event_id: id) }
       events.each do |ev|
-        repository
-          .append_to_stream([ev], Stream.new(SecureRandom.uuid), version_none)
-          .link_to_stream([ev.event_id], Stream.new(SecureRandom.uuid), version_none)
+        repository.append_to_stream([ev], Stream.new(SecureRandom.uuid), version_none).link_to_stream(
+          [ev.event_id],
+          Stream.new(SecureRandom.uuid),
+          version_none,
+        )
       end
 
       expect(read_events_forward(repository, count: 3)).to eq(events.first(3))
@@ -830,21 +834,21 @@ module RubyEventStore
       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]
+        [events.first],
       )
       expect(read_events_backward(repository, to: "96c920b1-cdd0-40f4-907c-861b9fff7d02", count: 1)).to eq(
-        [events.last]
+        [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]
+        [events.first],
       )
       expect(read_events_forward(repository, stream, to: "56404f79-0ba0-4aa0-8524-dc3436368ca0", count: 1)).to eq(
-        [events.first]
+        [events.first],
       )
       expect(read_events_backward(repository, stream, to: "96c920b1-cdd0-40f4-907c-861b9fff7d02", count: 1)).to eq(
-        [events.last]
+        [events.last],
       )
     end
 
@@ -861,15 +865,17 @@ module RubyEventStore
         repository.append_to_stream(
           [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
           stream_other,
-          version_none
+          version_none,
         )
       end.to raise_error(EventDuplicatedInStream)
     end
 
     it "does not allow linking same event twice in a stream" do
-      repository
-        .append_to_stream([SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")], stream, 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)
@@ -889,7 +895,7 @@ module RubyEventStore
         repository.append_to_stream(
           [SRecord.new(event_id: "9bedf448-e4d0-41a3-a8cd-f94aec7aa763")],
           stream,
-          version_none
+          version_none,
         )
       end.to raise_error(WrongExpectedEventVersion)
       expect(repository.has_event?("9bedf448-e4d0-41a3-a8cd-f94aec7aa763")).to be false
@@ -906,25 +912,25 @@ module RubyEventStore
     end
 
     specify "read returns enumerator" do
-      expect(repository.read(specification.result)).to be_kind_of(Enumerator)
+      expect(repository.read(specification.result)).to be_a(Enumerator)
     end
 
     specify "can store arbitrary binary data" do
       skip unless helper.supports_binary?
-      binary = String.new("\xB0").force_encoding("binary")
+      binary = (+"\xB0").force_encoding("binary")
 
-      repository.append_to_stream([event = SRecord.new(data: binary, metadata: binary)], stream, version_none)
+      repository.append_to_stream([SRecord.new(data: binary, metadata: binary)], stream, version_none)
     end
 
     specify do
-      expect(repository.read(specification.in_batches.result)).to be_kind_of(Enumerator)
-      expect(repository.read(specification.in_batches.as_at.result)).to be_kind_of(Enumerator)
-      expect(repository.read(specification.in_batches.as_of.result)).to be_kind_of(Enumerator)
+      expect(repository.read(specification.in_batches.result)).to be_a(Enumerator)
+      expect(repository.read(specification.in_batches.as_at.result)).to be_a(Enumerator)
+      expect(repository.read(specification.in_batches.as_of.result)).to be_a(Enumerator)
       events = Array.new(10) { SRecord.new }
       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)
+      expect(repository.read(specification.in_batches.result)).to be_a(Enumerator)
+      expect(repository.read(specification.in_batches.as_at.result)).to be_a(Enumerator)
+      expect(repository.read(specification.in_batches.as_of.result)).to be_a(Enumerator)
     end
 
     specify do
@@ -972,7 +978,7 @@ module RubyEventStore
       repository.append_to_stream(
         events,
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
 
       batches = repository.read(specification.as_at.forward.limit(101).in_batches.result).to_a
@@ -1056,35 +1062,39 @@ module RubyEventStore
 
     specify do
       event = SRecord.new
-      repository.append_to_stream([event], Stream.new('dummy'), ExpectedVersion.any)
-      expect do
-        repository.read(specification.stream('another').from(event.event_id).result).to_a
-      end.to raise_error(RubyEventStore::EventNotFound, "Event not found: #{event.event_id}")
+      repository.append_to_stream([event], Stream.new("dummy"), ExpectedVersion.any)
+      expect do repository.read(specification.stream("another").from(event.event_id).result).to_a end.to raise_error(
+        RubyEventStore::EventNotFound,
+        "Event not found: #{event.event_id}",
+      )
     end
 
     specify do
       event = SRecord.new
-      repository.append_to_stream([event], Stream.new('dummy'), ExpectedVersion.any)
-      expect do
-        repository.read(specification.stream('another').to(event.event_id).result).to_a
-      end.to raise_error(RubyEventStore::EventNotFound, "Event not found: #{event.event_id}")
+      repository.append_to_stream([event], Stream.new("dummy"), ExpectedVersion.any)
+      expect do repository.read(specification.stream("another").to(event.event_id).result).to_a end.to raise_error(
+        RubyEventStore::EventNotFound,
+        "Event not found: #{event.event_id}",
+      )
     end
 
     specify do
       not_existing_uuid = SecureRandom.uuid
-      expect do
-        repository.read(specification.from(not_existing_uuid).result).to_a
-      end.to raise_error(RubyEventStore::EventNotFound, "Event not found: #{not_existing_uuid}")
+      expect do repository.read(specification.from(not_existing_uuid).result).to_a end.to raise_error(
+        RubyEventStore::EventNotFound,
+        "Event not found: #{not_existing_uuid}",
+      )
     end
 
     specify do
       not_existing_uuid = SecureRandom.uuid
-      expect do
-        repository.read(specification.to(not_existing_uuid).result).to_a
-      end.to raise_error(RubyEventStore::EventNotFound, "Event not found: #{not_existing_uuid}")
+      expect do repository.read(specification.to(not_existing_uuid).result).to_a end.to raise_error(
+        RubyEventStore::EventNotFound,
+        "Event not found: #{not_existing_uuid}",
+      )
     end
 
-    context "#update_messages" do
+    describe "#update_messages" do
       specify "changes events" do
         skip unless helper.supports_upsert?
         events = Array.new(5) { SRecord.new }
@@ -1098,27 +1108,27 @@ module RubyEventStore
                 data: events[0].data,
                 metadata: events[0].metadata,
                 event_type: events[0].event_type,
-                timestamp: events[0].timestamp
+                timestamp: events[0].timestamp,
               ),
             b =
               SRecord.new(
                 event_id: events[1].event_id.dup,
                 data: {
-                  "test" => 1
+                  "test" => 1,
                 },
                 metadata: events[1].metadata,
                 event_type: events[1].event_type,
-                timestamp: events[1].timestamp
+                timestamp: events[1].timestamp,
               ),
             c =
               SRecord.new(
                 event_id: events[2].event_id,
                 data: events[2].data,
                 metadata: {
-                  "test" => 2
+                  "test" => 2,
                 },
                 event_type: events[2].event_type,
-                timestamp: events[2].timestamp
+                timestamp: events[2].timestamp,
               ),
             d =
               SRecord.new(
@@ -1126,21 +1136,21 @@ module RubyEventStore
                 data: events[3].data,
                 metadata: events[3].metadata,
                 event_type: "event_type3",
-                timestamp: events[3].timestamp
+                timestamp: events[3].timestamp,
               ),
             e =
               SRecord.new(
                 event_id: events[4].event_id.dup,
                 data: {
-                  "test" => 4
+                  "test" => 4,
                 },
                 metadata: {
-                  "test" => 42
+                  "test" => 42,
                 },
                 event_type: "event_type4",
-                timestamp: events[4].timestamp
-              )
-          ]
+                timestamp: events[4].timestamp,
+              ),
+          ],
         )
 
         expect(repository.read(specification.result).to_a).to eq([a, b, c, d, e])
@@ -1192,39 +1202,39 @@ module RubyEventStore
       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
+        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
+        e3,
       )
+      expect(
+        repository.read(specification.with_id(["c31b327c-0da1-4178-a3cd-d2f6bb5d0688"]).read_first.result),
+      ).to be_nil
       expect(
         repository.read(
           specification
             .with_id(%w[8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea d345f86d-b903-4d78-803f-38990c078d9e])
             .in_batches
-            .result
+            .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
-        )
+          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)
+          specification.stream("Stream B").with_id(["8cee1139-4f96-483a-a175-2b947283c3c7"]).read_first.result,
+        ),
+      ).to be_nil
       expect(
         repository.read(
-          specification.stream("Stream B").with_id(["c31b327c-0da1-4178-a3cd-d2f6bb5d0688"]).read_first.result
-        )
-      ).to eq(nil)
+          specification.stream("Stream B").with_id(["c31b327c-0da1-4178-a3cd-d2f6bb5d0688"]).read_first.result,
+        ),
+      ).to be_nil
       expect(repository.read(specification.with_id([]).result).to_a).to eq([])
     end
 
@@ -1295,7 +1305,7 @@ module RubyEventStore
       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]
+        [event_1],
       )
     end
 
@@ -1306,7 +1316,7 @@ module RubyEventStore
       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
+        repository.read(specification.stream("whatever").older_than_or_equal(Time.utc(2020, 1, 2)).result).to_a,
       ).to eq([event_1, event_2])
     end
 
@@ -1317,7 +1327,7 @@ module RubyEventStore
       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]
+        [event_3],
       )
     end
 
@@ -1328,7 +1338,7 @@ module RubyEventStore
       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
+        repository.read(specification.stream("whatever").newer_than_or_equal(Time.utc(2020, 1, 2)).result).to_a,
       ).to eq([event_2, event_3])
     end
 
@@ -1348,7 +1358,7 @@ module RubyEventStore
       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]
+        [event_1, event_2],
       )
     end
 
@@ -1368,7 +1378,7 @@ module RubyEventStore
       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]
+        [event_2, event_3],
       )
     end
 
@@ -1379,7 +1389,7 @@ module RubyEventStore
       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
+        repository.read(specification.older_than(Time.utc(2020, 1, 2)).newer_than(Time.utc(2020, 1, 2)).result).to_a,
       ).to eq([])
     end
 
@@ -1390,7 +1400,7 @@ module RubyEventStore
       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]
+        [event_1, event_2],
       )
     end
 
@@ -1400,17 +1410,21 @@ module RubyEventStore
           SRecord.new(
             event_id: e1 = SecureRandom.uuid,
             timestamp: Time.new(2020, 1, 1),
-            valid_at: Time.new(2020, 1, 9)
+            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)
+            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),
           ),
-          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
+        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])
@@ -1425,17 +1439,21 @@ module RubyEventStore
           SRecord.new(
             event_id: e1 = SecureRandom.uuid,
             timestamp: Time.new(2020, 1, 1),
-            valid_at: Time.new(2020, 1, 9)
+            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)
+            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),
           ),
-          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
+        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])
@@ -1448,7 +1466,7 @@ module RubyEventStore
       repository.append_to_stream(
         [],
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
       expect(repository.read(specification.result).count).to eq(0)
     end
@@ -1457,7 +1475,7 @@ module RubyEventStore
       repository.link_to_stream(
         [],
         RubyEventStore::Stream.new("whatever-non-globa"),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
       expect(repository.read(specification.result).count).to eq(0)
     end
@@ -1467,7 +1485,7 @@ module RubyEventStore
       repository.append_to_stream(
         events,
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
 
       batches = repository.read(specification.backward.limit(101).in_batches.result).to_a
@@ -1483,7 +1501,7 @@ module RubyEventStore
       repository.append_to_stream(
         events,
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
 
       batches = repository.read(specification.forward.limit(101).in_batches.result).to_a
@@ -1497,15 +1515,11 @@ module RubyEventStore
     specify "read in batches forward from named stream" do
       all_events = Array.new(400) { RubyEventStore::SRecord.new }
       all_events.each_slice(2) do |(first, second)|
-        repository.append_to_stream(
-          [first],
-          RubyEventStore::Stream.new("bazinga"),
-          RubyEventStore::ExpectedVersion.any
-        )
+        repository.append_to_stream([first], RubyEventStore::Stream.new("bazinga"), RubyEventStore::ExpectedVersion.any)
         repository.append_to_stream(
           [second],
           RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-          RubyEventStore::ExpectedVersion.any
+          RubyEventStore::ExpectedVersion.any,
         )
       end
       stream_events =
@@ -1524,10 +1538,13 @@ module RubyEventStore
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 29, 0))),
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 28, 0))),
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 27, 0))),
-          RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)), valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0))),
+          RubyEventStore::SRecord.new(
+            timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)),
+            valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0)),
+          ),
         ],
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
 
       expect(repository.read(specification.result).to_a).to eq([records[0], records[1], records[2], records[3]])
@@ -1541,15 +1558,24 @@ module RubyEventStore
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 29, 0))),
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 28, 0))),
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 27, 0))),
-          RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)), valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0))),
+          RubyEventStore::SRecord.new(
+            timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)),
+            valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0)),
+          ),
         ],
         RubyEventStore::Stream.new("stream"),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
 
-      expect(repository.read(specification.stream("stream").result).to_a).to eq([records[0], records[1], records[2], records[3]])
-      expect(repository.read(specification.stream("stream").as_at.result).to_a).to eq([records[3], records[2], records[1], records[0]])
-      expect(repository.read(specification.stream("stream").as_of.result).to_a).to eq([records[2], records[1], records[0], records[3]])
+      expect(repository.read(specification.stream("stream").result).to_a).to eq(
+        [records[0], records[1], records[2], records[3]],
+      )
+      expect(repository.read(specification.stream("stream").as_at.result).to_a).to eq(
+        [records[3], records[2], records[1], records[0]],
+      )
+      expect(repository.read(specification.stream("stream").as_of.result).to_a).to eq(
+        [records[2], records[1], records[0], records[3]],
+      )
     end
 
     specify "reading last event sorted by valid_at" do
@@ -1558,10 +1584,13 @@ module RubyEventStore
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 29, 0))),
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 28, 0))),
           RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 27, 0))),
-          RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)), valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0))),
+          RubyEventStore::SRecord.new(
+            timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)),
+            valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0)),
+          ),
         ],
         RubyEventStore::Stream.new("stream"),
-        RubyEventStore::ExpectedVersion.any
+        RubyEventStore::ExpectedVersion.any,
       )
 
       expect(repository.read(specification.stream("stream").as_of.read_last.result)).to eq(records[3])
@@ -1573,10 +1602,13 @@ module RubyEventStore
           SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 29, 0))),
           SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 28, 0))),
           SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 27, 0))),
-          SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)), valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0))),
+          SRecord.new(
+            timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)),
+            valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0)),
+          ),
         ],
         Stream.new(GLOBAL_STREAM),
-        ExpectedVersion.any
+        ExpectedVersion.any,
       )
 
       expect(repository.read(specification.as_of.read_last.result)).to eq(records[3])
@@ -1588,14 +1620,21 @@ module RubyEventStore
           SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 29))),
           SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 28))),
           SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 27))),
-          SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 26)), valid_at: with_precision(Time.utc(2023, 1, 1, 12, 30))),
+          SRecord.new(
+            timestamp: with_precision(Time.utc(2023, 1, 1, 12, 26)),
+            valid_at: with_precision(Time.utc(2023, 1, 1, 12, 30)),
+          ),
         ],
         Stream.new("stream"),
-        ExpectedVersion.any
+        ExpectedVersion.any,
       )
 
-      expect(repository.read(specification.older_than(Time.utc(2023,1,1,12,28,1)).stream("stream").as_at.result).to_a).to eq([records[3], records[2], records[1]])
-      expect(repository.read(specification.older_than(Time.utc(2023,1,1,12,28,1)).stream("stream").as_of.result).to_a).to eq([records[2], records[1]])
+      expect(
+        repository.read(specification.older_than(Time.utc(2023, 1, 1, 12, 28, 1)).stream("stream").as_at.result).to_a,
+      ).to eq([records[3], records[2], records[1]])
+      expect(
+        repository.read(specification.older_than(Time.utc(2023, 1, 1, 12, 28, 1)).stream("stream").as_of.result).to_a,
+      ).to eq([records[2], records[1]])
     end
 
     private