ruby_event_store 1.3.1 → 2.0.3

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
@@ -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
@@ -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
@@ -542,7 +583,7 @@ module RubyEventStore
                 eid = "0000000#{i}-#{sprintf("%04d", j)}-0000-0000-000000000000"
                 repository.link_to_stream(eid, stream, version_auto)
                 sleep(rand(concurrency_level) / 1000.0)
-              rescue WrongExpectedEventVersion, *rescuable_concurrency_test_errors
+              rescue WrongExpectedEventVersion, *helper.rescuable_concurrency_test_errors
                 fail_occurred +=1
               end
             end
@@ -558,9 +599,9 @@ 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
 
@@ -573,30 +614,30 @@ module RubyEventStore
     end
 
     it 'data attributes are retrieved' do
-      event = SRecord.new(data: '{"order_id":3}')
+      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}')
+      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)
       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
 
@@ -918,7 +959,7 @@ 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")
@@ -1091,7 +1132,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 +1145,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 +1166,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
@@ -1228,5 +1278,119 @@ 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
   end
 end

data/lib/ruby_event_store/spec/mapper_lint.rb

@@ -1,17 +1,17 @@
 module RubyEventStore
-  RSpec.shared_examples :mapper do |mapper, domain_event|
-    specify "event_to_serialized_record returns instance of SerializedRecord" do
-      record = mapper.event_to_serialized_record(domain_event)
+  ::RSpec.shared_examples :mapper do |mapper, domain_event|
+    specify "event_to_record returns instance of Record" do
+      record = mapper.event_to_record(domain_event)
 
-      expect(record).to            be_kind_of(SerializedRecord)
+      expect(record).to            be_kind_of(Record)
       expect(record.event_id).to   eq(domain_event.event_id)
       expect(record.event_type).to eq(domain_event.event_type)
     end
 
     specify "serialize and deserialize gives equal event" do
-      record = mapper.event_to_serialized_record(domain_event)
+      record = mapper.event_to_record(domain_event)
 
-      expect(mapper.serialized_record_to_event(record)).to eq(domain_event)
+      expect(mapper.record_to_event(record)).to eq(domain_event)
     end
   end
 end

data/lib/ruby_event_store/spec/subscriptions_lint.rb

@@ -39,10 +39,16 @@ RSpec.shared_examples :subscriptions do |subscriptions_class|
     subscriptions.add_thread_subscription(handler, [Test1DomainEvent, Test3DomainEvent])
     subscriptions.add_thread_subscription(another_handler, [Test2DomainEvent])
     subscriptions.add_thread_global_subscription(global_handler)
+    t = Thread.new do
+      subscriptions.add_thread_subscription(handler, [Test2DomainEvent])
+      subscriptions.add_thread_global_subscription(another_handler)
+      expect(subscriptions.all_for('Test2DomainEvent')).to eq([another_handler, handler])
+    end
 
     expect(subscriptions.all_for('Test1DomainEvent')).to eq([global_handler, handler])
     expect(subscriptions.all_for('Test2DomainEvent')).to eq([global_handler, another_handler])
     expect(subscriptions.all_for('Test3DomainEvent')).to eq([global_handler, handler])
+    t.join
   end
 
   it 'returns lambda as an output of global subscribe methods' do

data/lib/ruby_event_store/specification.rb

@@ -35,7 +35,7 @@ module RubyEventStore
     # Limits the query to events before or after another event.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @param start [String] id of event to start reading from.
+    # @param stop [String] id of event to start reading from.
     # @return [Specification]
     def to(stop)
       raise InvalidPageStop if stop.nil? || stop.empty?
@@ -43,6 +43,99 @@ module RubyEventStore
       Specification.new(reader, result.dup { |r| r.stop = stop })
     end
 
+    # Limits the query to events that later than given time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def older_than(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.older_than          = time
+          r.older_than_or_equal = nil
+        end
+      )
+    end
+
+    # Limits the query to events that occurred on given time or later.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def older_than_or_equal(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.older_than          = nil
+          r.older_than_or_equal = time
+        end
+      )
+    end
+
+    # Limits the query to events that occurred earlier than given time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def newer_than(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.newer_than_or_equal = nil
+          r.newer_than          = time
+        end
+      )
+    end
+
+    # Limits the query to events that occurred on given time or earlier.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def newer_than_or_equal(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.newer_than_or_equal = time
+          r.newer_than          = nil
+        end
+      )
+    end
+
+    # Limits the query to events within given time range.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time_range [Range]
+    # @return [Specification]
+    def between(time_range)
+      if time_range.exclude_end?
+        newer_than_or_equal(time_range.first).older_than(time_range.last)
+      else
+        newer_than_or_equal(time_range.first).older_than_or_equal(time_range.last)
+      end
+    end
+
+    # Sets the order of time sorting using transaction time
+    # {http://railseventstore.org/docs/read/ Find out more}
+    #
+    # @return [Specification]
+    def as_at
+      Specification.new(reader, result.dup { |r| r.time_sort_by = :as_at})
+    end
+
+    # Sets the order of time sorting using validity time
+    # {http://railseventstore.org/docs/read/ Find out more}
+    #
+    # @return [Specification]
+    def as_of
+      Specification.new(reader, result.dup { |r| r.time_sort_by = :as_of })
+    end
+
     # Sets the order of reading events to ascending (forward from the start).
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
@@ -73,7 +166,7 @@ module RubyEventStore
     # Yields each batch of records that was retrieved from the store.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @yield [Array<Event, Proto>] batch of events
+    # @yield [Array<Event>] batch of events
     # @return [Enumerator, nil] Enumerator is returned when block not given
     def each_batch
       return to_enum(:each_batch) unless block_given?
@@ -87,7 +180,7 @@ module RubyEventStore
     # Yields events read from the store if block given. Otherwise, returns enumerable collection.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @yield [Event, Proto] event
+    # @yield [Event] event
     # @return [Enumerator, nil] Enumerator is returned when block not given
     def each
       return to_enum unless block_given?
@@ -111,7 +204,7 @@ module RubyEventStore
     # built up to this point result using provided block.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @accumulator starting state for reduce operation
+    # @param accumulator starting state for reduce operation
     # @return reduce result as defined by block given
     def reduce(accumulator = nil, &block)
       raise ArgumentError.new("Block must be given") unless block_given?
@@ -130,7 +223,7 @@ module RubyEventStore
     # Returns array of domain events.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @return [Array<Event, Proto>]
+    # @return [Array<Event>]
     def to_a
       each.to_a
     end
@@ -200,7 +293,7 @@ module RubyEventStore
     # Limits the query to certain events by given even ids.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @param even_ids [Array(String)] ids of event to look for.
+    # @param event_ids [Array(String)] ids of event to look for.
     # @return [Specification]
     def with_id(event_ids)
       Specification.new(reader, result.dup{ |r| r.with_ids = event_ids })
@@ -231,7 +324,7 @@ module RubyEventStore
     # read from the store if block given. Otherwise, returns enumerable collection.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @yield [Event, Proto] event
+    # @yield [Event] event
     # @return [Enumerator] Enumerator is returned when block not given
     def events(event_ids)
       with_id(event_ids).each

data/lib/ruby_event_store/specification_reader.rb

@@ -14,14 +14,14 @@ module RubyEventStore
     # @private
     def one(specification_result)
       record = repository.read(specification_result)
-      mapper.serialized_record_to_event(record) if record
+      mapper.record_to_event(record) if record
     end
 
     # @api private
     # @private
     def each(specification_result)
       repository.read(specification_result).each do |batch|
-        yield batch.map { |serialized_record| mapper.serialized_record_to_event(serialized_record) }
+        yield batch.map { |record| mapper.record_to_event(record) }
       end
     end