mongoid-scroll 1.0.1 → 2.0.0

data/spec/mongoid/criteria_spec.rb

@@ -7,19 +7,23 @@ describe Mongoid::Criteria 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
+
       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'])
@@ -27,16 +31,19 @@ describe Mongoid::Criteria do
           expect { subject.scroll(cursor) }.to raise_error Mongoid::Scroll::Errors::MismatchedSortFieldsError, error_string
         end
       end
+
       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
+
       context 'with data' do
-        before :each do
+        before do
           10.times do |i|
             Feed::Item.create!(
               name: i.to_s,
@@ -48,30 +55,33 @@ describe Mongoid::Criteria do
             )
           end
         end
+
         context 'default' do
           it 'scrolls all' do
             records = []
-            Feed::Item.all.scroll(cursor_type) do |record, _next_cursor|
+            Feed::Item.all.scroll(cursor_type) do |record, _iterator|
               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
+            criteria.limit(2).scroll(cursor) do |_record, iterator|
+              cursor = iterator.next_cursor
             end
-            criteria.scroll(cursor) do |_record, next_cursor|
-              cursor = next_cursor
+            criteria.scroll(cursor) do |_record, iterator|
+              cursor = iterator.next_cursor
             end
             expect(criteria).to eq original_criteria
           end
         end
+
         context 'with a foreign key' do
           it 'sorts by object id' do
             records = []
@@ -79,92 +89,144 @@ describe Mongoid::Criteria do
             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|
+              Feed::Item.asc(field_name).scroll(cursor_type) do |record, _iterator|
                 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|
+              Feed::Item.asc(field_name).limit(5).scroll(cursor_type) do |record, iterator|
                 records << record
-                cursor = next_cursor
+                cursor = iterator.next_cursor
               end
               expect(records.size).to eq 5
-              Feed::Item.asc(field_name).scroll(cursor) do |record, next_cursor|
+              Feed::Item.asc(field_name).scroll(cursor) do |record, iterator|
                 records << record
-                cursor = next_cursor
+                cursor = iterator.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|
+              Feed::Item.asc(field_name).limit(5).scroll(cursor_type) do |record, iterator|
                 last_record = record
-                cursor = next_cursor
+                cursor = iterator.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|
+              Feed::Item.asc(field_name).limit(5).scroll(cursor_type) do |record, iterator|
                 last_record = record
-                cursor = next_cursor
+                cursor = iterator.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|
+              Feed::Item.desc(field_name).limit(3).scroll(cursor_type) do |record, _iterator|
                 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
+              expect(record).not_to be_nil
               cursor = cursor_type.from_record(record, field_type: field_type, field_name: field_name)
-              expect(cursor).to_not be nil
+              expect(cursor).not_to 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
+              Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, iterator|
+                iterator.next_cursor.include_current = true
+                expect(Feed::Item.asc(field_name).limit(2).scroll(iterator.next_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)
+              Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, iterator|
+                new_cursor = cursor_type.new(iterator.next_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
+
+            it 'can scroll back with the previous cursor' do
+              first_iterator = nil
+              second_iterator = nil
+              third_iterator = nil
+
+              Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, iterator|
+                first_iterator = iterator
+              end
+
+              Feed::Item.asc(field_name).limit(2).scroll(first_iterator.next_cursor) do |_, iterator|
+                second_iterator = iterator
+              end
+
+              Feed::Item.asc(field_name).limit(2).scroll(second_iterator.next_cursor) do |_, iterator|
+                third_iterator = iterator
+              end
+
+              records = Feed::Item.asc(field_name)
+              expect(Feed::Item.asc(field_name).limit(2).scroll(second_iterator.previous_cursor)).to eq(records.limit(2))
+              expect(Feed::Item.asc(field_name).limit(2).scroll(third_iterator.previous_cursor)).to eq(records.skip(2).limit(2))
+            end
+
+            it 'can loop over the same records with the current cursor' do
+              current_cursor = nil
+              cursor = cursor_type.from_record Feed::Item.skip(4).first, field_name: field_name, field_type: field_type, include_current: true
+
+              Feed::Item.asc(field_name).limit(2).scroll(cursor) do |_, iterator|
+                current_cursor = iterator.current_cursor
+              end
+
+              expect(Feed::Item.asc(field_name).limit(2).scroll(current_cursor).to_a).to eq(Feed::Item.asc(field_name).skip(4).limit(2).to_a)
+            end
+
+            it 'can loop over the first records with the first page cursor' do
+              first_cursor = nil
+
+              Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, it|
+                first_cursor = it.first_cursor
+              end
+
+              expect(Feed::Item.asc(field_name).limit(2).scroll(first_cursor).to_a).to eq(Feed::Item.asc(field_name).limit(2).to_a)
+            end
           end
         end
       end
+
       context 'with logic in initial criteria' do
-        before :each do
+        before do
           3.times do |i|
             Feed::Item.create!(
               name: "Feed Item #{i}",
@@ -184,63 +246,69 @@ describe Mongoid::Criteria do
             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(cursor_type) do |record, next_cursor|
+          criteria.limit(2).scroll(cursor_type) do |record, iterator|
             records << record
-            cursor = next_cursor
+            cursor = iterator.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|
+          criteria.limit(2).scroll(cursor) do |record, iterator|
             records << record
-            cursor = next_cursor
+            cursor = iterator.next_cursor
           end
           expect(records.size).to eq 1
           expect(records.map(&:name)).to eq ['Feed Item 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(cursor_type) do |record, _next_cursor|
+          criteria.scroll(cursor_type) do |record, _iterator|
             records << record
           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
+        before 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)
+          expect(Feed::Item.order_by('$natural' => 1).to_a).not_to 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|
+            Feed::Item.order_by(sort_order).limit(2).scroll(cursor_type) do |record, iterator|
               records << record
-              cursor = next_cursor
+              cursor = iterator.next_cursor
             end
             expect(records.size).to eq 2
-            Feed::Item.order_by(sort_order).scroll(cursor) do |record, _next_cursor|
+            Feed::Item.order_by(sort_order).scroll(cursor) do |record, _iterator|
               records << record
             end
             expect(records.size).to eq 3
@@ -248,10 +316,12 @@ describe Mongoid::Criteria do
           end
         end
       end
+
       context 'with several records having the same value' do
-        before :each do
+        before 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'])
@@ -260,6 +330,7 @@ describe Mongoid::Criteria do
           expect(items).to eq([second_item, third_item])
         end
       end
+
       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')) }
@@ -268,9 +339,9 @@ describe Mongoid::Criteria do
         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|
+          Feed::Item.order_by(a_datetime: 1).limit(2).scroll(cursor_type) do |record, iterator|
             records << record
-            cursor = next_cursor
+            cursor = iterator.next_cursor
           end
           expect(records).to eq [item_1, item_2]
           cursor = cursor_type.new(cursor.to_s, field: Feed::Item.fields['a_datetime'])

data/spec/mongoid/cursor_spec.rb

@@ -5,125 +5,158 @@ describe Mongoid::Scroll::Cursor do
     subject do
       Mongoid::Scroll::Cursor.new nil, field_name: 'a_string', field_type: String
     end
-    its(:tiebreak_id) { should be_nil }
-    its(:value) { should be_nil }
-    its(:criteria) { should eq({}) }
+
+    its(:tiebreak_id) { is_expected.to be_nil }
+    its(:value) { is_expected.to be_nil }
+    its(:criteria) { is_expected.to eq({}) }
   end
+
   context 'an invalid cursor' do
     it 'raises InvalidCursorError' do
       expect { Mongoid::Scroll::Cursor.new 'invalid', field_name: 'a_string', field_type: String }.to raise_error Mongoid::Scroll::Errors::InvalidCursorError,
                                                                                                                   /The cursor supplied is invalid: invalid./
     end
   end
+
   context 'an id field cursor' do
-    let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
     subject do
       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 }
-    its(:tiebreak_id) { should eq feed_item.id }
+
+    let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
+
+    its(:value) { is_expected.to eq feed_item.id }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+
     its(:criteria) do
-      should eq('$or' => [
-                  { '_id' => { '$gt' => BSON::ObjectId(feed_item.id.to_s) } }
-                ])
+      is_expected.to eq('$or' => [
+                          { '_id' => { '$gt' => BSON::ObjectId(feed_item.id.to_s) } }
+                        ])
     end
   end
+
   context 'a string field cursor' 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
     end
-    its(:value) { should eq feed_item.a_string }
-    its(:tiebreak_id) { should eq feed_item.id }
+
+    let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
+
+    its(:value) { is_expected.to eq feed_item.a_string }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+
     its(:criteria) do
-      should eq('$or' => [
-                  { 'a_string' => { '$gt' => feed_item.a_string } },
-                  { 'a_string' => feed_item.a_string, '_id' => { '$gt' => feed_item.id } }
-                ])
+      is_expected.to eq('$or' => [
+                          { 'a_string' => { '$gt' => feed_item.a_string } },
+                          { 'a_string' => feed_item.a_string, '_id' => { '$gt' => feed_item.id } }
+                        ])
     end
   end
+
   context 'an integer field cursor' do
-    let(:feed_item) { Feed::Item.create!(a_integer: 10) }
     subject do
       Mongoid::Scroll::Cursor.new "#{feed_item.a_integer}:#{feed_item.id}", field_name: 'a_integer', field_type: Integer
     end
-    its(:value) { should eq feed_item.a_integer }
-    its(:tiebreak_id) { should eq feed_item.id }
+
+    let(:feed_item) { Feed::Item.create!(a_integer: 10) }
+
+    its(:value) { is_expected.to eq feed_item.a_integer }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+
     its(:criteria) do
-      should eq('$or' => [
-                  { 'a_integer' => { '$gt' => feed_item.a_integer } },
-                  { 'a_integer' => feed_item.a_integer, '_id' => { '$gt' => feed_item.id } }
-                ])
+      is_expected.to eq('$or' => [
+                          { 'a_integer' => { '$gt' => feed_item.a_integer } },
+                          { 'a_integer' => feed_item.a_integer, '_id' => { '$gt' => feed_item.id } }
+                        ])
     end
   end
+
   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_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_f.round(3)}:#{feed_item.id}" }
+
+    let(:feed_item) { Feed::Item.create!(a_datetime: DateTime.new(2013, 12, 21, 1, 42, 3, 'UTC')) }
+
+    its(:value) { is_expected.to eq feed_item.a_datetime }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+    its(:to_s) { is_expected.to 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 } },
-                  { 'a_datetime' => feed_item.a_datetime, '_id' => { '$gt' => feed_item.id } }
-                ])
+      is_expected.to eq('$or' => [
+                          { 'a_datetime' => { '$gt' => feed_item.a_datetime } },
+                          { 'a_datetime' => feed_item.a_datetime, '_id' => { '$gt' => feed_item.id } }
+                        ])
     end
   end
+
   context 'a date field cursor' do
-    let(:feed_item) { Feed::Item.create!(a_date: Date.new(2013, 12, 21)) }
     subject do
       Mongoid::Scroll::Cursor.new "#{feed_item.a_date.to_datetime.to_i}:#{feed_item.id}", field_name: 'a_date', field_type: Date
     end
-    its(:value) { should eq feed_item.a_date }
-    its(:tiebreak_id) { should eq feed_item.id }
-    its(:to_s) { should eq "#{feed_item.a_date.to_datetime.to_i}:#{feed_item.id}" }
+
+    let(:feed_item) { Feed::Item.create!(a_date: Date.new(2013, 12, 21)) }
+
+    its(:value) { is_expected.to eq feed_item.a_date }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+    its(:to_s) { is_expected.to eq "#{feed_item.a_date.to_datetime.to_i}:#{feed_item.id}" }
+
     its(:criteria) do
-      should eq('$or' => [
-                  { 'a_date' => { '$gt' => feed_item.a_date.to_datetime } },
-                  { 'a_date' => feed_item.a_date.to_datetime, '_id' => { '$gt' => feed_item.id } }
-                ])
+      is_expected.to eq('$or' => [
+                          { 'a_date' => { '$gt' => feed_item.a_date.to_datetime } },
+                          { 'a_date' => feed_item.a_date.to_datetime, '_id' => { '$gt' => feed_item.id } }
+                        ])
     end
   end
+
   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_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_f.round(3)}:#{feed_item.id}" }
+
+    let(:feed_item) { Feed::Item.create!(a_time: Time.new(2013, 12, 21, 1, 2, 3)) }
+
+    its(:value) { is_expected.to eq feed_item.a_time }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+    its(:to_s) { is_expected.to 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 } },
-                  { 'a_time' => feed_item.a_time, '_id' => { '$gt' => feed_item.id } }
-                ])
+      is_expected.to eq('$or' => [
+                          { 'a_time' => { '$gt' => feed_item.a_time } },
+                          { 'a_time' => feed_item.a_time, '_id' => { '$gt' => feed_item.id } }
+                        ])
     end
   end
+
   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_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_f.round(3)}:#{feed_item.id}" }
+
+    let(:feed_item) { Feed::Item.create!(a_time: Time.new(2013, 12, 21, 1, 2, 3)) }
+
+    its(:value) { is_expected.to eq feed_item.a_time }
+    its(:tiebreak_id) { is_expected.to eq feed_item.id }
+    its(:to_s) { is_expected.to 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 } },
-                  { 'a_time' => feed_item.a_time, '_id' => { '$gt' => feed_item.id } }
-                ])
+      is_expected.to eq('$or' => [
+                          { 'a_time' => { '$gt' => feed_item.a_time } },
+                          { 'a_time' => feed_item.a_time, '_id' => { '$gt' => feed_item.id } }
+                        ])
     end
   end
+
   context 'an array field cursor' do
     let(:feed_item) { Feed::Item.create!(a_array: %w[x y]) }
+
     it 'is not supported' do
       expect do
         Mongoid::Scroll::Cursor.from_record feed_item, field_name: 'a_array', field_type: Array
       end.to raise_error Mongoid::Scroll::Errors::UnsupportedFieldTypeError, /The type of the field 'a_array' is not supported: Array./
     end
   end
+
   context 'an invalid field cursor' do
     it 'raises ArgumentError' do
       expect do
@@ -131,23 +164,38 @@ describe Mongoid::Scroll::Cursor do
       end.to raise_error ArgumentError
     end
   end
-  context 'a cursor with include_current set to true' do
+
+  context 'an invalid type cursor' do
     let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
+
+    it 'raises Mongoid::Scroll::Errors::UnsupportedTypeError' do
+      expect do
+        Mongoid::Scroll::Cursor.new "#{feed_item.a_string}:#{feed_item.id}", field_name: 'a_string', field_type: String, include_current: true, type: :invalid
+      end.to raise_error Mongoid::Scroll::Errors::UnsupportedTypeError, /The type supplied in the cursor is not supported: invalid./
+    end
+  end
+
+  context 'a cursor with include_current set to true' do
     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 }
+
+    let(:feed_item) { Feed::Item.create!(a_string: 'astring') }
+
+    its(:value) { is_expected.to eq 'astring' }
+    its(:tiebreak_id) { is_expected.to 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' }
-                ])
+      is_expected.to 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
+      before do
         3.times do |i|
           Feed::Item.create!(
             name: "Feed Item #{i}",
@@ -159,6 +207,7 @@ describe Mongoid::Scroll::Cursor do
           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

data/spec/mongoid/scroll_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe Mongoid::Scroll::VERSION do
-  it { should_not be_nil }
+  it { is_expected.not_to be_nil }
 end

data/spec/spec_helper.rb

@@ -1,12 +1,19 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+require 'coveralls'
+Coveralls.wear! do
+  add_filter 'spec'
+end
+
 require 'rubygems'
 require 'rspec'
 require 'rspec/its'
 require 'database_cleaner'
 require 'mongoid-scroll'
 
+Time.zone ||= 'EST'
+
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
   require f
 end
@@ -18,9 +25,9 @@ end
 RSpec.configure do |config|
   config.before :all do
     Mongoid.logger.level = Logger::INFO
-    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5_or_newer?
+    Mongo::Logger.logger.level = Logger::INFO
   end
-  config.before :each do
+  config.before do
     DatabaseCleaner.clean
   end
 end