ruby_event_store 1.3.0 → 2.2.0

data/lib/ruby_event_store/serialized_record.rb

@@ -3,18 +3,20 @@
 module RubyEventStore
   class SerializedRecord
     StringsRequired = Class.new(StandardError)
-    def initialize(event_id:, data:, metadata:, event_type:)
+    def initialize(event_id:, data:, metadata:, event_type:, timestamp:, valid_at:)
       raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
       @event_id   = event_id
       @data       = data
       @metadata   = metadata
       @event_type = event_type
+      @timestamp  = timestamp
+      @valid_at   = valid_at
       freeze
     end
 
-    attr_reader :event_id, :data, :metadata, :event_type
+    attr_reader :event_id, :data, :metadata, :event_type, :timestamp, :valid_at
 
-    BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110011
+    BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110111
     def hash
       [
         self.class,
@@ -22,6 +24,8 @@ module RubyEventStore
         data,
         metadata,
         event_type,
+        timestamp,
+        valid_at,
       ].hash ^ BIG_VALUE
     end
 
@@ -30,7 +34,9 @@ module RubyEventStore
         other.event_id.eql?(event_id) &&
         other.data.eql?(data) &&
         other.metadata.eql?(metadata) &&
-        other.event_type.eql?(event_type)
+        other.event_type.eql?(event_type) &&
+        other.timestamp.eql?(timestamp) &&
+        other.valid_at.eql?(valid_at)
     end
 
     def to_h
@@ -39,9 +45,22 @@ module RubyEventStore
         data: data,
         metadata: metadata,
         event_type: event_type,
+        timestamp: timestamp,
+        valid_at: valid_at,
       }
     end
 
+    def deserialize(serializer)
+      Record.new(
+        event_id:   event_id,
+        event_type: event_type,
+        data:       serializer.load(data),
+        metadata:   serializer.load(metadata),
+        timestamp:  Time.iso8601(timestamp),
+        valid_at:   Time.iso8601(valid_at),
+      )
+    end
+
     alias_method :eql?, :==
   end
 end

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -1,6 +1,6 @@
 RSpec.shared_examples :broker do |broker_klass|
   let(:event) { instance_double(::RubyEventStore::Event, event_type: 'EventType') }
-  let(:serialized_event) { instance_double(::RubyEventStore::SerializedRecord)  }
+  let(:record) { instance_double(::RubyEventStore::Record)  }
   let(:handler) { HandlerClass.new }
   let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
   let(:dispatcher) { ::RubyEventStore::Dispatcher.new }
@@ -9,26 +9,26 @@ RSpec.shared_examples :broker do |broker_klass|
   specify "no dispatch when no subscriptions" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([])
     expect(dispatcher).not_to receive(:call)
-    broker.call(event, serialized_event)
+    broker.call(event, record)
   end
 
   specify "calls subscription" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler])
-    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
-    broker.call(event, serialized_event)
+    expect(dispatcher).to receive(:call).with(handler, event, record)
+    broker.call(event, record)
   end
 
   specify "calls subscribed class" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([HandlerClass])
-    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
-    broker.call(event, serialized_event)
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
+    broker.call(event, record)
   end
 
   specify "calls all subscriptions" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler, HandlerClass])
-    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
-    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
-    broker.call(event, serialized_event)
+    expect(dispatcher).to receive(:call).with(handler, event, record)
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
+    broker.call(event, record)
   end
 
   specify 'raise error when no subscriber' do

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -3,15 +3,19 @@ module RubyEventStore
   class SRecord
     def self.new(
       event_id:   SecureRandom.uuid,
-      data:       '{}',
-      metadata:   '{}',
-      event_type: 'SRecordTestEvent'
+      data:       {},
+      metadata:   {},
+      event_type: 'SRecordTestEvent',
+      timestamp:  Time.new.utc,
+      valid_at:   nil
     )
-      SerializedRecord.new(
+      Record.new(
         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),
       )
     end
   end
@@ -22,13 +26,45 @@ module RubyEventStore
   Type2 = Class.new(RubyEventStore::Event)
   # @private
   Type3 = Class.new(RubyEventStore::Event)
+
+  # @private
+  class EventRepositoryHelper
+    def supports_concurrent_auto?
+      true
+    end
+
+    def supports_concurrent_any?
+      true
+    end
+
+    def supports_binary?
+      true
+    end
+
+    def supports_upsert?
+      true
+    end
+
+    def has_connection_pooling?
+      false
+    end
+
+    def connection_pool_size
+    end
+
+    def cleanup_concurrency_test
+    end
+
+    def rescuable_concurrency_test_errors
+      []
+    end
+  end
 end
 
 module RubyEventStore
-  RSpec.shared_examples :event_repository do |repository_class, rescuable_concurrency_test_errors = []|
-    let(:repository)    { subject || repository_class.new }
-    let(:mapper)        { Mappers::NullMapper.new }
-    let(:specification) { Specification.new(SpecificationReader.new(repository, mapper)) }
+  ::RSpec.shared_examples :event_repository do
+    let(:helper)        { EventRepositoryHelper.new }
+    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') }
@@ -42,6 +78,11 @@ module RubyEventStore
     let(:version_2)     { ExpectedVersion.new(2) }
     let(:version_3)     { ExpectedVersion.new(3) }
 
+    def verify_conncurency_assumptions
+      return unless helper.has_connection_pooling?
+      expect(helper.connection_pool_size).to eq(5)
+    end
+
     def read_events(scope, stream = nil, from: nil, to: nil, count: nil)
       scope = scope.stream(stream.name) if stream
       scope = scope.from(from) if from
@@ -64,8 +105,8 @@ module RubyEventStore
 
     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)
+        .append_to_stream([event = SRecord.new], stream, version_none)
+        .append_to_stream([event = SRecord.new], stream, version_0)
     end
 
     specify 'link_to_stream returns self' do
@@ -73,12 +114,12 @@ module RubyEventStore
       event1 = SRecord.new
       repository
         .append_to_stream([event0, event1], stream, version_none)
-        .link_to_stream(event0.event_id, stream_flow, version_none)
-        .link_to_stream(event1.event_id, stream_flow, version_0)
+        .link_to_stream([event0.event_id], stream_flow, version_none)
+        .link_to_stream([event1.event_id], stream_flow, version_0)
     end
 
     specify 'adds an initial event to a new stream' do
-      repository.append_to_stream(event = SRecord.new, stream, version_none)
+      repository.append_to_stream([event = SRecord.new], stream, version_none)
       expect(read_events_forward(repository).first).to eq(event)
       expect(read_events_forward(repository, stream).first).to eq(event)
       expect(read_events_forward(repository, stream_other)).to be_empty
@@ -86,8 +127,8 @@ module RubyEventStore
 
     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)
+        .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)
@@ -393,7 +434,7 @@ module RubyEventStore
     end
 
     specify 'unlimited concurrency for :any - everything should succeed', timeout: 10, mutant: false do
-      skip unless test_race_conditions_any
+      skip unless helper.supports_concurrent_any?
       verify_conncurency_assumptions
       begin
         concurrency_level = 4
@@ -426,12 +467,12 @@ module RubyEventStore
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
       ensure
-        cleanup_concurrency_test
+        helper.cleanup_concurrency_test
       end
     end
 
     specify 'unlimited concurrency for :any - everything should succeed when linking', timeout: 10, mutant: false do
-      skip unless test_race_conditions_any
+      skip unless helper.supports_concurrent_any?
       verify_conncurency_assumptions
       begin
         concurrency_level = 4
@@ -453,7 +494,7 @@ module RubyEventStore
             begin
               100.times do |j|
                 eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.link_to_stream(eid, stream_flow, version_any)
+                repository.link_to_stream([eid], stream_flow, version_any)
               end
             rescue WrongExpectedEventVersion
               fail_occurred = true
@@ -471,12 +512,12 @@ module RubyEventStore
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
       ensure
-        cleanup_concurrency_test
+        helper.cleanup_concurrency_test
       end
     end
 
     specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered', mutant: false do
-      skip unless test_race_conditions_auto
+      skip unless helper.supports_concurrent_auto?
       verify_conncurency_assumptions
       begin
         concurrency_level = 4
@@ -494,7 +535,7 @@ module RubyEventStore
                   SRecord.new(event_id: eid),
                 ], stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion, *rescuable_concurrency_test_errors
+              rescue WrongExpectedEventVersion, *helper.rescuable_concurrency_test_errors
                 fail_occurred +=1
               end
             end
@@ -510,14 +551,14 @@ module RubyEventStore
           ev.event_id.start_with?("0-")
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
-        additional_limited_concurrency_for_auto_check
+        additional_limited_concurrency_for_auto_check if defined? additional_limited_concurrency_for_auto_check
       ensure
-        cleanup_concurrency_test
+        helper.cleanup_concurrency_test
       end
     end
 
     specify 'limited concurrency for :auto - some operations will fail without outside lock, stream is ordered', mutant: false do
-      skip unless test_race_conditions_auto
+      skip unless helper.supports_concurrent_auto?
       verify_conncurency_assumptions
       begin
         concurrency_level = 4
@@ -540,9 +581,9 @@ module RubyEventStore
             100.times do |j|
               begin
                 eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
-                repository.link_to_stream(eid, stream, version_auto)
+                repository.link_to_stream([eid], stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion, *rescuable_concurrency_test_errors
+              rescue WrongExpectedEventVersion, *helper.rescuable_concurrency_test_errors
                 fail_occurred +=1
               end
             end
@@ -558,51 +599,51 @@ module RubyEventStore
           ev.event_id.start_with?("0-")
         end
         expect(events0).to eq(events0.sort_by{|ev| ev.event_id })
-        additional_limited_concurrency_for_auto_check
+        additional_limited_concurrency_for_auto_check if defined? additional_limited_concurrency_for_auto_check
       ensure
-        cleanup_concurrency_test
+        helper.cleanup_concurrency_test
       end
     end
 
     it 'appended event is stored in given stream' do
       expected_event = SRecord.new
-      repository.append_to_stream(expected_event, stream, version_any)
+      repository.append_to_stream([expected_event], stream, version_any)
       expect(read_events_forward(repository, count: 1).first).to eq(expected_event)
       expect(read_events_forward(repository, stream).first).to eq(expected_event)
       expect(read_events_forward(repository, stream_other)).to be_empty
     end
 
     it 'data attributes are retrieved' do
-      event = SRecord.new(data: '{"order_id":3}')
-      repository.append_to_stream(event, stream, version_any)
+      event = SRecord.new(data: { "order_id" => 3 })
+      repository.append_to_stream([event], stream, version_any)
       retrieved_event = read_events_forward(repository, count: 1).first
-      expect(retrieved_event.data).to eq('{"order_id":3}')
+      expect(retrieved_event.data).to eq({ "order_id" => 3 })
     end
 
     it 'metadata attributes are retrieved' do
-      event = SRecord.new(metadata: '{"request_id":3}')
-      repository.append_to_stream(event, stream, version_any)
+      event = SRecord.new(metadata: { "request_id" => 3 })
+      repository.append_to_stream([event], stream, version_any)
       retrieved_event = read_events_forward(repository, count: 1).first
-      expect(retrieved_event.metadata).to eq('{"request_id":3}')
+      expect(retrieved_event.metadata).to eq({ "request_id" => 3 })
     end
 
     it 'data and metadata attributes are retrieved when linking' do
       event = SRecord.new(
-        data: '{"order_id":3}',
-        metadata: '{"request_id":4}',
+        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)
+        .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}')
+      expect(retrieved_event.metadata).to eq({ "request_id" => 4 })
+      expect(retrieved_event.data).to eq({ "order_id" => 3 })
       expect(event).to eq(retrieved_event)
     end
 
     it 'does not have deleted streams' do
-      repository.append_to_stream(e1 = SRecord.new, stream, version_none)
-      repository.append_to_stream(e2 = SRecord.new, stream_other, version_none)
+      repository.append_to_stream([e1 = SRecord.new], stream, version_none)
+      repository.append_to_stream([e2 = SRecord.new], stream_other, version_none)
 
       repository.delete_stream(stream)
       expect(read_events_forward(repository, stream)).to be_empty
@@ -612,8 +653,8 @@ module RubyEventStore
 
     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)
+        .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
@@ -622,7 +663,7 @@ module RubyEventStore
 
     it 'has or has not domain event' do
       just_an_id = 'd5c134c2-db65-4e87-b6ea-d196f8f1a292'
-      repository.append_to_stream(SRecord.new(event_id: just_an_id), stream, version_none)
+      repository.append_to_stream([SRecord.new(event_id: just_an_id)], stream, version_none)
 
       expect(repository.has_event?(just_an_id)).to be_truthy
       expect(repository.has_event?(just_an_id.clone)).to be_truthy
@@ -634,8 +675,8 @@ module RubyEventStore
     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
@@ -665,11 +706,11 @@ module RubyEventStore
         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)
+      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))
+        repository.append_to_stream([event], stream, ExpectedVersion.new(index - 1))
       end
-      repository.append_to_stream(SRecord.new, stream_other, version_0)
+      repository.append_to_stream([SRecord.new], stream_other, version_0)
 
       expect(read_events_forward(repository, stream, count: 3)).to eq(events.first(3))
       expect(read_events_forward(repository, stream, count: 100)).to eq(events)
@@ -700,13 +741,13 @@ module RubyEventStore
         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)
+      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))
+          .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)
+      repository.append_to_stream([SRecord.new], stream_other, version_0)
 
       expect(read_events_forward(repository, stream_flow, count: 3)).to eq(events.first(3))
       expect(read_events_forward(repository, stream_flow, count: 100)).to eq(events)
@@ -727,11 +768,11 @@ module RubyEventStore
       s1 = stream
       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(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([a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282')], s1, version_none)
+        .append_to_stream([b = SRecord.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5')], s2, version_none)
+        .append_to_stream([c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f')], s1, version_0)
+        .append_to_stream([d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd')], s2, version_0)
+        .append_to_stream([e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457')], s2, version_1)
 
       expect(read_events_forward(repository, s1)).to eq [a,c]
       expect(read_events_backward(repository, s1)).to eq [c,a]
@@ -740,16 +781,16 @@ module RubyEventStore
     it 'reads all stream linked events forward & backward' do
       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(c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f'), s1, version_1)
-        .append_to_stream(d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd'), s1, version_2)
-        .append_to_stream(e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457'), s1, version_3)
-        .link_to_stream('7010d298-ab69-4bb1-9251-f3466b5d1282', fs1, version_none)
-        .link_to_stream('34f88aca-aaba-4ca0-9256-8017b47528c5', fs2, version_none)
-        .link_to_stream('8e61c864-ceae-4684-8726-97c34eb8fc4f', fs1, version_0)
-        .link_to_stream('30963ed9-6349-450b-ac9b-8ea50115b3bd', fs2, version_0)
-        .link_to_stream('5bdc58b7-e8a7-4621-afd6-ccb828d72457', fs2, version_1)
+        .append_to_stream([a = SRecord.new(event_id: '7010d298-ab69-4bb1-9251-f3466b5d1282')], s1, version_none)
+        .append_to_stream([b = SRecord.new(event_id: '34f88aca-aaba-4ca0-9256-8017b47528c5')], s1, version_0)
+        .append_to_stream([c = SRecord.new(event_id: '8e61c864-ceae-4684-8726-97c34eb8fc4f')], s1, version_1)
+        .append_to_stream([d = SRecord.new(event_id: '30963ed9-6349-450b-ac9b-8ea50115b3bd')], s1, version_2)
+        .append_to_stream([e = SRecord.new(event_id: '5bdc58b7-e8a7-4621-afd6-ccb828d72457')], s1, version_3)
+        .link_to_stream(['7010d298-ab69-4bb1-9251-f3466b5d1282'], fs1, version_none)
+        .link_to_stream(['34f88aca-aaba-4ca0-9256-8017b47528c5'], fs2, version_none)
+        .link_to_stream(['8e61c864-ceae-4684-8726-97c34eb8fc4f'], fs1, version_0)
+        .link_to_stream(['30963ed9-6349-450b-ac9b-8ea50115b3bd'], fs2, version_0)
+        .link_to_stream(['5bdc58b7-e8a7-4621-afd6-ccb828d72457'], fs2, version_1)
 
       expect(read_events_forward(repository, fs1)).to eq [a,c]
       expect(read_events_backward(repository, fs1)).to eq [c,a]
@@ -769,7 +810,7 @@ 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)
+        repository.append_to_stream([ev], Stream.new(SecureRandom.uuid), version_none)
       end
 
       expect(read_events_forward(repository, count: 3)).to eq(events.first(3))
@@ -802,8 +843,8 @@ module RubyEventStore
       ].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)
+          .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))
@@ -826,8 +867,8 @@ module RubyEventStore
         96c920b1-cdd0-40f4-907c-861b9fff7d02
         56404f79-0ba0-4aa0-8524-dc3436368ca0
       ].map{|id| SRecord.new(event_id: id) }
-      repository.append_to_stream(events.first, stream, version_none)
-      repository.append_to_stream(events.last,  stream,  version_0)
+      repository.append_to_stream([events.first], stream, version_none)
+      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])
@@ -842,13 +883,13 @@ module RubyEventStore
 
     it 'does not allow same event twice in a stream' do
       repository.append_to_stream(
-        SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        [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"),
+          [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
           stream,
           version_0
         )
@@ -857,13 +898,13 @@ module RubyEventStore
 
     it 'does not allow same event twice' do
       repository.append_to_stream(
-        SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef"),
+        [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"),
+          [SRecord.new(event_id: "a1b49edb-7636-416f-874a-88f94b859bef")],
           stream_other,
           version_none
         )
@@ -871,41 +912,39 @@ 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,
+      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)
+      ).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)
+        repository.link_to_stream(["a1b49edb-7636-416f-874a-88f94b859bef"], stream_flow, version_0)
       end.to raise_error(EventDuplicatedInStream)
     end
 
     it 'allows appending to GLOBAL_STREAM explicitly' do
       event = SRecord.new(event_id: "df8b2ba3-4e2c-4888-8d14-4364855fa80e")
-      repository.append_to_stream(event, global_stream, version_any)
+      repository.append_to_stream([event], global_stream, version_any)
 
       expect(read_events_forward(repository, count: 10)).to eq([event])
     end
 
     specify "events not persisted if append failed" do
-      repository.append_to_stream([
-        SRecord.new,
-      ], stream, version_none)
+      repository.append_to_stream([SRecord.new], stream, version_none)
 
       expect do
-        repository.append_to_stream([
-          SRecord.new(
-            event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
-          ),
-        ], stream, version_none)
+        repository.append_to_stream(
+          [SRecord.new(event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763')],
+          stream,
+          version_none
+        )
       end.to raise_error(WrongExpectedEventVersion)
       expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
     end
 
     specify 'linking non-existent event' do
       expect do
-        repository.link_to_stream('72922e65-1b32-4e97-8023-03ae81dd3a27', stream_flow, version_none)
+        repository.link_to_stream(['72922e65-1b32-4e97-8023-03ae81dd3a27'], stream_flow, version_none)
       end.to raise_error do |err|
         expect(err).to be_a(EventNotFound)
         expect(err.event_id).to eq('72922e65-1b32-4e97-8023-03ae81dd3a27')
@@ -918,14 +957,14 @@ module RubyEventStore
     end
 
     specify 'can store arbitrary binary data' do
-      skip unless test_binary
+      skip unless helper.supports_binary?
       binary = "\xB0"
       expect(binary.valid_encoding?).to eq(false)
       binary.force_encoding("binary")
       expect(binary.valid_encoding?).to eq(true)
 
       repository.append_to_stream(
-        event = SRecord.new(data: binary, metadata: binary),
+        [event = SRecord.new(data: binary, metadata: binary)],
         stream,
         version_none
       )
@@ -933,6 +972,8 @@ module RubyEventStore
 
     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)
       events = Array.new(10) { SRecord.new }
       repository.append_to_stream(
         events,
@@ -940,6 +981,9 @@ module RubyEventStore
         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
@@ -1091,7 +1135,7 @@ module RubyEventStore
 
     context "#update_messages" do
       specify "changes events" do
-        skip unless test_change
+        skip unless helper.supports_upsert?
         events = Array.new(5) { SRecord.new }
         repository.append_to_stream(
           events[0..2],
@@ -1104,19 +1148,20 @@ module RubyEventStore
           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),
-          b = SRecord.new(event_id: events[1].event_id.dup, data: '{"test":1}', metadata: events[1].metadata, event_type: events[1].event_type),
-          c = SRecord.new(event_id: events[2].event_id, data: events[2].data, metadata: '{"test":2}', event_type: events[2].event_type),
-          d = SRecord.new(event_id: events[3].event_id.clone, data: events[3].data, metadata: events[3].metadata, event_type: "event_type3"),
-          e = SRecord.new(event_id: events[4].event_id.dup, data: '{"test":4}', metadata: '{"test":42}', event_type: "event_type4"),
+          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])
       end
 
       specify "cannot change unexisting event" do
-        skip unless test_change
+        skip unless helper.supports_upsert?
         e = SRecord.new
         expect{ repository.update_messages([e]) }.to raise_error do |err|
           expect(err).to be_a(EventNotFound)
@@ -1124,6 +1169,14 @@ module RubyEventStore
           expect(err.message).to eq("Event not found: #{e.event_id}")
         end
       end
+
+      specify "does not change timestamp" do
+        r = SRecord.new(timestamp: Time.utc(2020, 1, 1))
+        repository.append_to_stream([r], Stream.new("whatever"), ExpectedVersion.any)
+        repository.update_messages([SRecord.new(event_id: r.event_id, timestamp: Time.utc(2020, 1, 20))])
+
+        expect(repository.read(specification.result).first.timestamp).to eq(Time.utc(2020, 1, 1))
+      end
     end
 
     specify do
@@ -1135,7 +1188,7 @@ module RubyEventStore
       stream_c = Stream.new('Stream C')
       repository.append_to_stream([event_1, event_2], stream_a, version_any)
       repository.append_to_stream([event_3], stream_b, version_any)
-      repository.link_to_stream(event_1.event_id, stream_c, version_none)
+      repository.link_to_stream([event_1.event_id], stream_c, version_none)
 
       expect(repository.streams_of('8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea')).to eq [stream_a, stream_c]
       expect(repository.streams_of('8cee1139-4f96-483a-a175-2b947283c3c7')).to eq [stream_a]
@@ -1228,5 +1281,135 @@ module RubyEventStore
       expect(repository.count(specification.stream("Dummy").of_type([Type3]).result)).to eq(2)
       expect(repository.count(specification.stream(stream.name).of_type([Type3]).result)).to eq(0)
     end
+
+    specify 'timestamp precision' do
+      time = Time.utc(2020, 9, 11, 12, 26, 0, 123456)
+      repository.append_to_stream([SRecord.new(timestamp: time)], stream, version_none)
+      event = read_events_forward(repository, count: 1).first
+
+      expect(event.timestamp).to eq(time)
+    end
+
+    specify 'fetching records older than specified date in stream' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    end
+
+    specify 'fetching records older than or equal to specified date in stream' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    end
+
+    specify 'fetching records newer than specified date in stream' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    end
+
+    specify 'fetching records newer than or equal to specified date in stream' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    end
+
+    specify 'fetching records older than specified date' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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)).result).to_a).to eq([event_1])
+    end
+
+    specify 'fetching records older than or equal to specified date' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    end
+
+    specify 'fetching records newer than specified date' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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(Time.utc(2020, 1, 2)).result).to_a).to eq([event_3])
+    end
+
+    specify 'fetching records newer than or equal to specified date' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    end
+
+    specify 'fetching records from disjoint periods' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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([])
+    end
+
+    specify 'fetching records within time range' do
+      event_1 = SRecord.new(event_id: '8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea', timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: '8cee1139-4f96-483a-a175-2b947283c3c7', timestamp: Time.utc(2020, 1, 2))
+      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])
+    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)),
+        ],
+        Stream.new("Dummy"),
+        ExpectedVersion.any
+      )
+      expect(repository.read(specification.result).map(&:event_id)).to eq [e1, e2, e3]
+      expect(repository.read(specification.as_at.result).map(&:event_id)).to eq [e1, e3, e2]
+      expect(repository.read(specification.as_at.backward.result).map(&:event_id)).to eq [e2, e3, e1]
+      expect(repository.read(specification.as_of.result).map(&:event_id)).to eq [e3, e2, e1]
+      expect(repository.read(specification.as_of.backward.result).map(&:event_id)).to eq [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)),
+      ],
+        Stream.new("Dummy"),
+        ExpectedVersion.any
+      )
+      expect(repository.read(specification.in_batches.result).to_a.flatten.map(&:event_id)).to eq [e1, e2, e3]
+      expect(repository.read(specification.in_batches.as_at.result).to_a.flatten.map(&:event_id)).to eq [e1, e3, e2]
+      expect(repository.read(specification.in_batches.as_at.backward.result).to_a.flatten.map(&:event_id)).to eq [e2, e3, e1]
+      expect(repository.read(specification.in_batches.as_of.result).to_a.flatten.map(&:event_id)).to eq [e3, e2, e1]
+      expect(repository.read(specification.in_batches.as_of.backward.result).to_a.flatten.map(&:event_id)).to eq [e1, e2, e3]
+    end
   end
 end