mongoid-scroll 0.3.7 → 1.0.1

data/spec/mongoid/criteria_spec.rb

@@ -1,225 +1,281 @@
 require 'spec_helper'
 
 describe Mongoid::Criteria do
-  context 'with multiple sort fields' do
-    subject do
-      Feed::Item.desc(:name).asc(:value)
-    end
-    it ':scroll' do
-      expect(subject).to respond_to(:scroll)
-    end
-    it 'raises Mongoid::Scroll::Errors::MultipleSortFieldsError' do
-      expect { subject.scroll }.to raise_error Mongoid::Scroll::Errors::MultipleSortFieldsError,
-                                               /You're attempting to scroll over data with a sort order that includes multiple fields: name, value./
-    end
-  end
-
-  context 'with no sort' do
-    subject do
-      Feed::Item.all
-    end
-    it 'adds a default sort by _id' do
-      expect(subject.scroll.options[:sort]).to eq('_id' => 1)
-    end
-  end
-  context 'with data' do
-    before :each do
-      10.times do |i|
-        Feed::Item.create!(
-          a_string: i.to_s,
-          a_integer: i,
-          a_datetime: DateTime.new(2013, i + 1, 21, 1, 42, 3, 'UTC'),
-          a_date: Date.new(2013, i + 1, 21),
-          a_time: Time.at(Time.now.to_i + i)
-        )
+  [Mongoid::Scroll::Cursor, Mongoid::Scroll::Base64EncodedCursor].each do |cursor_type|
+    context cursor_type do
+      context 'with multiple sort fields' do
+        subject do
+          Feed::Item.desc(:name).asc(:value)
+        end
+        it ':scroll' do
+          expect(subject).to respond_to(:scroll)
+        end
+        it 'raises Mongoid::Scroll::Errors::MultipleSortFieldsError' do
+          expect do
+            subject.scroll(cursor_type)
+          end.to raise_error Mongoid::Scroll::Errors::MultipleSortFieldsError, /You're attempting to scroll over data with a sort order that includes multiple fields: name, value./
+        end
       end
-    end
-    context 'default' do
-      it 'scrolls all' do
-        records = []
-        Feed::Item.all.scroll do |record, _next_cursor|
-          records << record
-        end
-        expect(records.size).to eq 10
-        expect(records).to eq Feed::Item.all.to_a
+      context 'with different sort fields between the cursor and the criteria' do
+        subject do
+          Feed::Item.desc(:name)
+        end
+        it 'raises Mongoid::Scroll::Errors::MismatchedSortFieldsError' do
+          record = Feed::Item.create!
+          cursor = cursor_type.from_record(record, field: record.fields['a_string'])
+          error_string = /You're attempting to scroll over data with a sort order that differs between the cursor and the original criteria: field_name, direction./
+          expect { subject.scroll(cursor) }.to raise_error Mongoid::Scroll::Errors::MismatchedSortFieldsError, error_string
+        end
       end
-      it 'does not change original criteria' do
-        criteria = Feed::Item.where(:a_time.gt => Time.new(2013, 7, 22, 1, 2, 3))
-        original_criteria = criteria.dup
-        criteria.limit(2).scroll
-        expect(criteria).to eq original_criteria
-        cursor = nil
-        criteria.limit(2).scroll(cursor) do |_record, next_cursor|
-          cursor = next_cursor
-        end
-        criteria.scroll(cursor) do |_record, next_cursor|
-          cursor = next_cursor
-        end
-        expect(criteria).to eq original_criteria
+      context 'with no sort' do
+        subject do
+          Feed::Item.all
+        end
+        it 'adds a default sort by _id' do
+          expect(subject.scroll(cursor_type).options[:sort]).to eq('_id' => 1)
+        end
       end
-    end
-
-    context 'with a foreign key' do
-      it 'sorts by object id' do
-        records = []
-        Feed::Item.asc('publisher_id').scroll { |r, _| records << r }
-        expect(records).not_to be_empty
+      context 'with data' do
+        before :each do
+          10.times do |i|
+            Feed::Item.create!(
+              name: i.to_s,
+              a_string: i.to_s,
+              a_integer: i,
+              a_datetime: DateTime.new(2013, i + 1, 21, 1, 42, 3, 'UTC'),
+              a_date: Date.new(2013, i + 1, 21),
+              a_time: Time.at(Time.now.to_i + i)
+            )
+          end
+        end
+        context 'default' do
+          it 'scrolls all' do
+            records = []
+            Feed::Item.all.scroll(cursor_type) do |record, _next_cursor|
+              records << record
+            end
+            expect(records.size).to eq 10
+            expect(records).to eq Feed::Item.all.to_a
+          end
+          it 'does not change original criteria' do
+            criteria = Feed::Item.where(:a_time.gt => Time.new(2013, 7, 22, 1, 2, 3))
+            original_criteria = criteria.dup
+            criteria.limit(2).scroll(cursor_type)
+            expect(criteria).to eq original_criteria
+            cursor = nil
+            criteria.limit(2).scroll(cursor) do |_record, next_cursor|
+              cursor = next_cursor
+            end
+            criteria.scroll(cursor) do |_record, next_cursor|
+              cursor = next_cursor
+            end
+            expect(criteria).to eq original_criteria
+          end
+        end
+        context 'with a foreign key' do
+          it 'sorts by object id' do
+            records = []
+            Feed::Item.asc('publisher_id').scroll(cursor_type) { |r, _| records << r }
+            expect(records).not_to be_empty
+          end
+        end
+        { a_string: String, a_integer: Integer, a_date: Date, a_datetime: DateTime }.each_pair do |field_name, field_type|
+          context field_type do
+            it 'scrolls all with a block' do
+              records = []
+              Feed::Item.asc(field_name).scroll(cursor_type) do |record, _next_cursor|
+                records << record
+              end
+              expect(records.size).to eq 10
+              expect(records).to eq Feed::Item.all.to_a
+            end
+            it 'scrolls all with a break' do
+              records = []
+              cursor = nil
+              Feed::Item.asc(field_name).limit(5).scroll(cursor_type) do |record, next_cursor|
+                records << record
+                cursor = next_cursor
+              end
+              expect(records.size).to eq 5
+              Feed::Item.asc(field_name).scroll(cursor) do |record, next_cursor|
+                records << record
+                cursor = next_cursor
+              end
+              expect(records.size).to eq 10
+              expect(records).to eq Feed::Item.all.to_a
+            end
+            it 'scrolls from a cursor' do
+              last_record = nil
+              cursor = nil
+              Feed::Item.asc(field_name).limit(5).scroll(cursor_type) do |record, next_cursor|
+                last_record = record
+                cursor = next_cursor
+              end
+              sixth_item = Feed::Item.asc(field_name).to_a[5]
+              from_item = Feed::Item.asc(field_name).scroll(cursor).to_a.first
+              expect(from_item).to eq sixth_item
+            end
+            it 'includes the current record when Mongoid::Scroll::Cursor#include_current is true' do
+              last_record = nil
+              cursor = nil
+              Feed::Item.asc(field_name).limit(5).scroll(cursor_type) do |record, next_cursor|
+                last_record = record
+                cursor = next_cursor
+              end
+              fifth_item = last_record
+              cursor.include_current = true
+              from_item = Feed::Item.asc(field_name).scroll(cursor).to_a.first
+              expect(from_item).to eq fifth_item
+            end
+            it 'scrolls in descending order' do
+              records = []
+              Feed::Item.desc(field_name).limit(3).scroll(cursor_type) do |record, _next_cursor|
+                records << record
+              end
+              expect(records.size).to eq 3
+              expect(records).to eq Feed::Item.desc(field_name).limit(3).to_a
+            end
+            it 'map' do
+              record = Feed::Item.desc(field_name).limit(3).scroll(cursor_type).map { |r| r }.last
+              expect(record).to_not be nil
+              cursor = cursor_type.from_record(record, field_type: field_type, field_name: field_name)
+              expect(cursor).to_not be nil
+              expect(cursor.tiebreak_id).to eq record.id
+              expect(cursor.value).to eq record.send(field_name)
+            end
+            it 'can be reused' do
+              ids = Feed::Item.asc(field_name).limit(2).map(&:id)
+              Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, cursor|
+                cursor.include_current = true
+                expect(Feed::Item.asc(field_name).limit(2).scroll(cursor).pluck(:id)).to eq ids
+                break
+              end
+            end
+            it 'can be re-created and reused' do
+              ids = Feed::Item.asc(field_name).limit(2).map(&:id)
+              Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, cursor|
+                new_cursor = cursor_type.new(cursor.to_s, field_type: field_type, field_name: field_name)
+                new_cursor.include_current = true
+                expect(Feed::Item.asc(field_name).limit(2).scroll(new_cursor).pluck(:id)).to eq ids
+                break
+              end
+            end
+          end
+        end
       end
-    end
-
-    { a_string: String, a_integer: Integer, a_date: Date, a_datetime: DateTime }.each_pair do |field_name, field_type|
-      context field_type do
-        it 'scrolls all with a block' do
-          records = []
-          Feed::Item.asc(field_name).scroll do |record, _next_cursor|
-            records << record
+      context 'with logic in initial criteria' do
+        before :each do
+          3.times do |i|
+            Feed::Item.create!(
+              name: "Feed Item #{i}",
+              a_string: i.to_s,
+              a_integer: i,
+              a_datetime: DateTime.new(2015, i + 1, 21, 1, 42, 3, 'UTC'),
+              a_date: Date.new(2016, i + 1, 21),
+              a_time: Time.new(2015, i + 1, 22, 1, 2, 3)
+            )
           end
-          expect(records.size).to eq 10
-          expect(records).to eq Feed::Item.all.to_a
+          Feed::Item.create!(
+            name: 'Feed Item 3',
+            a_string: '3',
+            a_integer: 3,
+            a_datetime: DateTime.new(2015, 3, 2, 1, 2, 3),
+            a_date: Date.new(2012, 2, 3),
+            a_time: Time.new(2014, 2, 2, 1, 2, 3)
+          )
         end
-        it 'scrolls all with a break' do
+        it 'respects original criteria with OR logic' do
+          criteria = Feed::Item.where(
+            '$or' => [{ :a_time.gt => Time.new(2015, 7, 22, 1, 2, 3) }, { :a_time.lte => Time.new(2015, 7, 22, 1, 2, 3), :a_date.gte => Date.new(2015, 7, 30) }]
+          ).asc(:a_time)
           records = []
           cursor = nil
-          Feed::Item.asc(field_name).limit(5).scroll do |record, next_cursor|
+          criteria.limit(2).scroll(cursor_type) do |record, next_cursor|
             records << record
             cursor = next_cursor
           end
-          expect(records.size).to eq 5
-          Feed::Item.asc(field_name).scroll(cursor) do |record, next_cursor|
+          expect(records.size).to eq 2
+          expect(records.map(&:name)).to eq ['Feed Item 0', 'Feed Item 1']
+          records = []
+          criteria.limit(2).scroll(cursor) do |record, next_cursor|
             records << record
             cursor = next_cursor
           end
-          expect(records.size).to eq 10
-          expect(records).to eq Feed::Item.all.to_a
+          expect(records.size).to eq 1
+          expect(records.map(&:name)).to eq ['Feed Item 2']
         end
-        it 'scrolls from a cursor' do
-          last_record = nil
-          cursor = nil
-          Feed::Item.asc(field_name).limit(5).scroll do |record, next_cursor|
-            last_record = record
-            cursor = next_cursor
-          end
-          sixth_item = Feed::Item.asc(field_name).to_a[5]
-          from_item = Feed::Item.asc(field_name).scroll(cursor).to_a.first
-          expect(from_item).to eq sixth_item
+      end
+      context 'with embeddable objects' do
+        before do
+          @item = Feed::Item.create! a_integer: 1, name: 'item'
+          @embedded_item = Feed::EmbeddedItem.create! name: 'embedded', item: @item
         end
-        it 'scrolls in descending order' do
+        it 'respects embedded queries' do
           records = []
-          Feed::Item.desc(field_name).limit(3).scroll do |record, _next_cursor|
+          criteria = @item.embedded_items.limit(2)
+          criteria.scroll(cursor_type) do |record, _next_cursor|
             records << record
           end
-          expect(records.size).to eq 3
-          expect(records).to eq Feed::Item.desc(field_name).limit(3).to_a
-        end
-        it 'map' do
-          record = Feed::Item.desc(field_name).limit(3).scroll.map { |r| r }.last
-          expect(record).to_not be nil
-          cursor = Mongoid::Scroll::Cursor.from_record(record, field_type: field_type, field_name: field_name)
-          expect(cursor).to_not be nil
-          expect(cursor.to_s.split(':')).to eq [
-            Mongoid::Scroll::Cursor.transform_field_value(field_type, field_name, record.send(field_name)).to_s,
-            record.id.to_s
-          ]
+          expect(records.size).to eq 1
+          expect(records.map(&:name)).to eq ['embedded']
         end
       end
-    end
-  end
-  context 'with logic in initial criteria' do
-    before :each do
-      3.times do |i|
-        Feed::Item.create!(
-          name: "Feed Item #{i}",
-          a_string: i.to_s,
-          a_integer: i,
-          a_datetime: DateTime.new(2015, i + 1, 21, 1, 42, 3, 'UTC'),
-          a_date: Date.new(2016, i + 1, 21),
-          a_time: Time.new(2015, i + 1, 22, 1, 2, 3)
-        )
-      end
-      Feed::Item.create!(
-        name: 'Feed Item 3',
-        a_string: '3',
-        a_integer: 3,
-        a_datetime: DateTime.new(2015, 3, 2, 1, 2, 3),
-        a_date: Date.new(2012, 2, 3),
-        a_time: Time.new(2014, 2, 2, 1, 2, 3)
-      )
-    end
-    it 'respects original criteria with OR logic' do
-      criteria = Feed::Item.where(
-        '$or' => [{ :a_time.gt => Time.new(2015, 7, 22, 1, 2, 3) }, { :a_time.lte => Time.new(2015, 7, 22, 1, 2, 3), :a_date.gte => Date.new(2015, 7, 30) }]
-      ).asc(:a_time)
-      records = []
-      cursor = nil
-      criteria.limit(2).scroll do |record, next_cursor|
-        records << record
-        cursor = next_cursor
-      end
-      expect(records.size).to eq 2
-      expect(records.map(&:name)).to eq ['Feed Item 0', 'Feed Item 1']
-      records = []
-      criteria.limit(2).scroll(cursor) do |record, next_cursor|
-        records << record
-        cursor = next_cursor
-      end
-      expect(records.size).to eq 1
-      expect(records.map(&:name)).to eq ['Feed Item 2']
-    end
-    it 'merges cursor criteria when no sort field is given' do
-      criteria = Feed::Item.where(:a_time.gt => Time.new(2013, 7, 22, 1, 2, 3))
-      feed_item = Feed::Item.where(name: 'Feed Item 1').first
-      cursor_input = "#{feed_item.id}:#{feed_item.id}"
-      field_type = Mongoid::Compatibility::Version.mongoid3? ? Moped::BSON::ObjectId : BSON::ObjectId
-      cursor_options = { field_type: field_type, field_name: '_id', direction: 1 }
-      cursor = Mongoid::Scroll::Cursor.new(cursor_input, cursor_options)
-      records = []
-      criteria.limit(2).scroll(cursor) do |record, next_cursor|
-        records << record
-        cursor = next_cursor
+      context 'with overlapping data', if: MongoDB.mmapv1? do
+        before :each do
+          3.times { Feed::Item.create! a_integer: 5 }
+          Feed::Item.first.update_attributes!(name: Array(1000).join('a'))
+        end
+        it 'natural order is different from order by id' do
+          # natural order isn't necessarily going to be the same as _id order
+          # if a document is updated and grows in size, it may need to be relocated and
+          # thus cause the natural order to change
+          expect(Feed::Item.order_by('$natural' => 1).to_a).to_not eq(Feed::Item.order_by(_id: 1).to_a)
+        end
+        [{ a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
+          it "scrolls by #{sort_order}" do
+            records = []
+            cursor = nil
+            Feed::Item.order_by(sort_order).limit(2).scroll(cursor_type) do |record, next_cursor|
+              records << record
+              cursor = next_cursor
+            end
+            expect(records.size).to eq 2
+            Feed::Item.order_by(sort_order).scroll(cursor) do |record, _next_cursor|
+              records << record
+            end
+            expect(records.size).to eq 3
+            expect(records).to eq Feed::Item.all.sort(_id: sort_order[:a_integer]).to_a
+          end
+        end
       end
-      expect(records.size).to eq 2
-    end
-  end
-  context 'with embeddable objects' do
-    before do
-      @item = Feed::Item.create! a_integer: 1, name: 'item'
-      @embedded_item = Feed::EmbeddedItem.create! name: 'embedded', item: @item
-    end
-    it 'respects embedded queries' do
-      records = []
-      criteria = @item.embedded_items.limit(2)
-      criteria.scroll do |record, _next_cursor|
-        records << record
+      context 'with several records having the same value' do
+        before :each do
+          3.times { Feed::Item.create! a_integer: 5 }
+        end
+        it 'returns records from the current one when Mongoid::Scroll::Cursor#include_current is true' do
+          _first_item, second_item, third_item = Feed::Item.asc(:a_integer).to_a
+          cursor = Mongoid::Scroll::Cursor.from_record(second_item, field: Feed::Item.fields['a_integer'])
+          cursor.include_current = true
+          items = Feed::Item.asc(:a_integer).limit(2).scroll(cursor).to_a
+          expect(items).to eq([second_item, third_item])
+        end
       end
-      expect(records.size).to eq 1
-      expect(records.map(&:name)).to eq ['embedded']
-    end
-  end
-  context 'with overlapping data', if: MongoDB.mmapv1? do
-    before :each do
-      3.times { Feed::Item.create! a_integer: 5 }
-      Feed::Item.first.update_attributes!(name: Array(1000).join('a'))
-    end
-    it 'natural order is different from order by id' do
-      # natural order isn't necessarily going to be the same as _id order
-      # if a document is updated and grows in size, it may need to be relocated and
-      # thus cause the natural order to change
-      expect(Feed::Item.order_by('$natural' => 1).to_a).to_not eq(Feed::Item.order_by(_id: 1).to_a)
-    end
-    [{ a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
-      it "scrolls by #{sort_order}" do
-        records = []
-        cursor = nil
-        Feed::Item.order_by(sort_order).limit(2).scroll do |record, next_cursor|
-          records << record
-          cursor = next_cursor
-        end
-        expect(records.size).to eq 2
-        Feed::Item.order_by(sort_order).scroll(cursor) do |record, _next_cursor|
-          records << record
-        end
-        expect(records.size).to eq 3
-        expect(records).to eq Feed::Item.all.sort(_id: sort_order[:a_integer]).to_a
+      context 'with DateTime with a milisecond precision' do
+        let!(:item_1) { Feed::Item.create!(a_datetime: DateTime.new(2013, 1, 21, 1, 42, 3.1, 'UTC')) }
+        let!(:item_2) { Feed::Item.create!(a_datetime: DateTime.new(2013, 1, 21, 1, 42, 3.2, 'UTC')) }
+        let!(:item_3) { Feed::Item.create!(a_datetime: DateTime.new(2013, 1, 21, 1, 42, 3.3, 'UTC')) }
+
+        it 'doesn\'t lose the precision when rebuilding the cursor' do
+          records = []
+          cursor = nil
+          Feed::Item.order_by(a_datetime: 1).limit(2).scroll(cursor_type) do |record, next_cursor|
+            records << record
+            cursor = next_cursor
+          end
+          expect(records).to eq [item_1, item_2]
+          cursor = cursor_type.new(cursor.to_s, field: Feed::Item.fields['a_datetime'])
+          expect(Feed::Item.order_by(a_datetime: 1).limit(2).scroll(cursor).to_a).to eq([item_3])
+        end
       end
     end
   end

data/spec/mongoid/{scroll_cursor_spec.rb → cursor_spec.rb}

@@ -17,22 +17,15 @@ describe Mongoid::Scroll::Cursor do
   end
   context 'an id field cursor' do
     let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
-    field_type = Mongoid::Compatibility::Version.mongoid3? ? Moped::BSON::ObjectId : BSON::ObjectId
     subject do
-      Mongoid::Scroll::Cursor.new "#{feed_item.id}:#{feed_item.id}", field_name: '_id', field_type: field_type, direction: 1
+      Mongoid::Scroll::Cursor.new "#{feed_item.id}:#{feed_item.id}", field_name: '_id', field_type: BSON::ObjectId, direction: 1
     end
-    its(:value) { should eq feed_item.id.to_s }
+    its(:value) { should eq feed_item.id }
     its(:tiebreak_id) { should eq feed_item.id }
     its(:criteria) do
-      if Mongoid::Compatibility::Version.mongoid3?
-        should eq('$or' => [
-                    { '_id' => { '$gt' => Moped::BSON::ObjectId(feed_item.id.to_s) } }
-                  ])
-      else
-        should eq('$or' => [
-                    { '_id' => { '$gt' => BSON::ObjectId(feed_item.id.to_s) } }
-                  ])
-      end
+      should eq('$or' => [
+                  { '_id' => { '$gt' => BSON::ObjectId(feed_item.id.to_s) } }
+                ])
     end
   end
   context 'a string field cursor' do
@@ -66,11 +59,11 @@ describe Mongoid::Scroll::Cursor do
   context 'a date/time field cursor' do
     let(:feed_item) { Feed::Item.create!(a_datetime: DateTime.new(2013, 12, 21, 1, 42, 3, 'UTC')) }
     subject do
-      Mongoid::Scroll::Cursor.new "#{feed_item.a_datetime.utc.to_i}:#{feed_item.id}", field_name: 'a_datetime', field_type: DateTime
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_datetime.utc.to_f.round(3)}:#{feed_item.id}", field_name: 'a_datetime', field_type: DateTime
     end
     its(:value) { should eq feed_item.a_datetime }
     its(:tiebreak_id) { should eq feed_item.id }
-    its(:to_s) { should eq "#{feed_item.a_datetime.utc.to_i}:#{feed_item.id}" }
+    its(:to_s) { should eq "#{feed_item.a_datetime.utc.to_f.round(3)}:#{feed_item.id}" }
     its(:criteria) do
       should eq('$or' => [
                   { 'a_datetime' => { '$gt' => feed_item.a_datetime } },
@@ -96,11 +89,11 @@ describe Mongoid::Scroll::Cursor do
   context 'a time field cursor' do
     let(:feed_item) { Feed::Item.create!(a_time: Time.new(2013, 12, 21, 1, 2, 3)) }
     subject do
-      Mongoid::Scroll::Cursor.new "#{feed_item.a_time.to_i}:#{feed_item.id}", field_name: 'a_time', field_type: Time
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_time.to_f.round(3)}:#{feed_item.id}", field_name: 'a_time', field_type: Time
     end
     its(:value) { should eq feed_item.a_time }
     its(:tiebreak_id) { should eq feed_item.id }
-    its(:to_s) { should eq "#{feed_item.a_time.to_i}:#{feed_item.id}" }
+    its(:to_s) { should eq "#{feed_item.a_time.to_f.round(3)}:#{feed_item.id}" }
     its(:criteria) do
       should eq('$or' => [
                   { 'a_time' => { '$gt' => feed_item.a_time } },
@@ -111,11 +104,11 @@ describe Mongoid::Scroll::Cursor do
   context 'a time field cursor with a field option' do
     let(:feed_item) { Feed::Item.create!(a_time: Time.new(2013, 12, 21, 1, 2, 3)) }
     subject do
-      Mongoid::Scroll::Cursor.new "#{feed_item.a_time.to_i}:#{feed_item.id}", field: Feed::Item.fields['a_time']
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_time.to_f.round(3)}:#{feed_item.id}", field: Feed::Item.fields['a_time']
     end
     its(:value) { should eq feed_item.a_time }
     its(:tiebreak_id) { should eq feed_item.id }
-    its(:to_s) { should eq "#{feed_item.a_time.to_i}:#{feed_item.id}" }
+    its(:to_s) { should eq "#{feed_item.a_time.to_f.round(3)}:#{feed_item.id}" }
     its(:criteria) do
       should eq('$or' => [
                   { 'a_time' => { '$gt' => feed_item.a_time } },
@@ -138,4 +131,47 @@ describe Mongoid::Scroll::Cursor do
       end.to raise_error ArgumentError
     end
   end
+  context 'a cursor with include_current set to true' do
+    let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
+    subject do
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_string}:#{feed_item.id}", field_name: 'a_string', field_type: String, include_current: true
+    end
+    its(:value) { should eq 'astring' }
+    its(:tiebreak_id) { should eq feed_item.id }
+    its(:criteria) do
+      should eq('$or' => [
+                  { 'a_string' => { '$gt' => 'astring' } },
+                  { '_id' => { '$gte' => BSON::ObjectId(feed_item.id.to_s) }, 'a_string' => 'astring' }
+                ])
+    end
+  end
+  context 'criteria' do
+    context 'with data' do
+      before :each do
+        3.times do |i|
+          Feed::Item.create!(
+            name: "Feed Item #{i}",
+            a_time: Time.new(2015, i + 1, 22, 1, 2, 3)
+          )
+        end
+        Feed::Item.create!(
+          name: 'Feed Item 3',
+          a_time: Time.new(2014, 2, 2, 1, 2, 3)
+        )
+      end
+      it 'merges cursor criteria when no sort field is given' do
+        criteria = Feed::Item.where(:a_time.gt => Time.new(2013, 7, 22, 1, 2, 3))
+        feed_item = Feed::Item.where(name: 'Feed Item 1').first
+        cursor_input = "#{feed_item.id}:#{feed_item.id}"
+        cursor_options = { field_type: BSON::ObjectId, field_name: '_id', direction: 1 }
+        cursor = Mongoid::Scroll::Cursor.new(cursor_input, cursor_options)
+        records = []
+        criteria.limit(2).scroll(cursor) do |record, next_cursor|
+          records << record
+          cursor = next_cursor
+        end
+        expect(records.size).to eq 2
+      end
+    end
+  end
 end

data/spec/support/feed/item.rb

@@ -13,7 +13,7 @@ module Feed
     embeds_many :embedded_items, class_name: 'Feed::EmbeddedItem'
 
     publisher_options = { class_name: 'Feed::Publisher' }
-    publisher_options[:optional] = true if Mongoid::Compatibility::Version.mongoid6? || Mongoid::Compatibility::Version.mongoid7?
+    publisher_options[:optional] = true if Mongoid::Compatibility::Version.mongoid6_or_newer?
     belongs_to :publisher, publisher_options
   end
 end