restpack_serializer 0.6.7 → 0.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec99f158a9e7825b3134792a1ea5ba5efb2a961f
-  data.tar.gz: a33b39771c550f179826c344af688f5d9e84392b
+  metadata.gz: 7af1bc27d7c8835c4661909c30fc9dd85db99379
+  data.tar.gz: cdd08668865b3200810f2f296a6729b5aa29a1e1
 SHA512:
-  metadata.gz: 6412ccee09177e52299f3b8bfbfcdefc5f541f18bb3e5ab95ef126ecb178fd8a7f8304e3ceda94c838d30904056727b9e9413b3175e7cfc437a8eb33214aacf7
-  data.tar.gz: 8c2f759aa5ca1fcf1fa4d927e4fb6c156fdabb0a66a1fbc4bce6f9683d944a861d1b2b79107ae9ca8a23e633a6953dc72f25a67cc7c3dbe35f23f7042262a44b
+  metadata.gz: a9186bacc0ef4f585bd8e053e2ba678f980ce263f026fb6623812076bc22f3dc0d10490ac29f4bf31fa0c397dd205e86e96a59825c5cda097516a01914612fd5
+  data.tar.gz: e7e1ab1b5d90c07c5868a106888a0079f8fa3e4ad638ec97ba2d7d5b2114f75cd9d63e6f4898563fe208625d8bac8f02496c60b2633c5582ee55dac0349784cc

data/.gitignore

@@ -3,3 +3,4 @@
 tmp
 /coverage
 Gemfile.lock
+/.idea

data/lib/restpack_serializer/version.rb

@@ -1,5 +1,5 @@
 module RestPack
   module Serializer
-    VERSION = '0.6.7'
+    VERSION = '0.6.8'
   end
 end

data/restpack_serializer.gemspec

@@ -17,17 +17,18 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'activesupport', ['>= 4.0.3', '< 5.0']
-  gem.add_dependency 'activerecord', ['>= 4.0.3', '< 5.0']
-  gem.add_dependency 'kaminari', '~> 0.16.1'
+  gem.add_dependency 'activesupport', ['>= 4.0.3', '< 6.0']
+  gem.add_dependency 'activerecord', ['>= 4.0.3', '< 6.0']
+  gem.add_dependency 'kaminari', '~> 0.17.0'
+  gem.add_dependency 'kaminari-mongoid', '~> 0.1'
 
   gem.add_development_dependency 'restpack_gem', '~> 0.0.9'
-  gem.add_development_dependency 'rake', '~> 11.1.2'
-  gem.add_development_dependency 'guard-rspec', '~> 4.6.4'
-  gem.add_development_dependency 'factory_girl', '~> 4.7.0'
-  gem.add_development_dependency 'sqlite3', '~> 1.3.7'
-  gem.add_development_dependency 'database_cleaner', '~> 1.5.3'
+  gem.add_development_dependency 'rake', '~> 11.3'
+  gem.add_development_dependency 'guard-rspec', '~> 4.7'
+  gem.add_development_dependency 'factory_girl', '~> 4.7'
+  gem.add_development_dependency 'sqlite3', '~> 1.3'
+  gem.add_development_dependency 'database_cleaner', '~> 1.5'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'bump'
-  gem.add_development_dependency 'protected_attributes', '~> 1.1.3'
+  gem.add_development_dependency 'protected_attributes_continued', '~> 1.2'
 end

data/spec/factory/factory_spec.rb

@@ -5,45 +5,52 @@ describe RestPack::Serializer::Factory do
 
   describe "single-word" do
     it "creates by string" do
-      factory.create("Song").should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create("Song")).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by lowercase string" do
-      factory.create("song").should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create("song")).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by lowercase plural string" do
-      factory.create("songs").should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create("songs")).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by symbol" do
-      factory.create(:song).should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create(:song)).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by class" do
-      factory.create(MyApp::Song).should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create(MyApp::Song)).to be_an_instance_of(MyApp::SongSerializer)
     end
 
     it "creates multiple with Array" do
       serializers = factory.create("Song", "artists", :album)
-      serializers[0].should be_an_instance_of(MyApp::SongSerializer)
-      serializers[1].should be_an_instance_of(MyApp::ArtistSerializer)
-      serializers[2].should be_an_instance_of(MyApp::AlbumSerializer)
+      expect(serializers[0]).to be_an_instance_of(MyApp::SongSerializer)
+      expect(serializers[1]).to be_an_instance_of(MyApp::ArtistSerializer)
+      expect(serializers[2]).to be_an_instance_of(MyApp::AlbumSerializer)
     end
   end
 
   describe "multi-word" do
     it "creates multi-word string" do
-      factory.create("AlbumReview").should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create("AlbumReview")).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word lowercase string" do
-      factory.create("album_review").should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create("album_review")).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word lowercase plural string" do
-      factory.create("album_reviews").should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create("album_reviews")).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word symbol" do
-      factory.create(:album_review).should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create(:album_review)).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word class" do
-      factory.create(MyApp::AlbumReview).should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create(MyApp::AlbumReview)).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
   end
-
 end

data/spec/fixtures/db.rb

@@ -1,6 +1,6 @@
 require 'sqlite3'
 require 'active_record'
-require 'protected_attributes'
+require 'protected_attributes_continued'
 
 ActiveRecord::Base.establish_connection(
   :adapter => 'sqlite3',

data/spec/restpack_serializer_spec.rb

@@ -6,8 +6,8 @@ describe RestPack::Serializer do
 
   context "#setup" do
     it "has defaults" do
-      subject.config.href_prefix.should == ''
-      subject.config.page_size.should == 10
+      expect(subject.config.href_prefix).to eq('')
+      expect(subject.config.page_size).to eq(10)
     end
 
     it "can be configured" do
@@ -16,8 +16,8 @@ describe RestPack::Serializer do
         config.page_size = 50
       end
 
-      subject.config.href_prefix.should == '/api/v1'
-      subject.config.page_size.should == 50
+      expect(subject.config.href_prefix).to eq('/api/v1')
+      expect(subject.config.page_size).to eq(50)
     end
   end
 end

data/spec/result_spec.rb

@@ -3,18 +3,19 @@ require 'spec_helper'
 describe RestPack::Serializer::Result do
   context 'a new instance' do
     it 'has defaults' do
-      subject.resources.should == {}
-      subject.meta.should == {}
-      subject.links.should == {}
+      expect(subject.resources).to eq({})
+      expect(subject.meta).to eq({})
+      expect(subject.links).to eq({})
     end
   end
 
   context 'when serializing' do
     let(:result) { subject.serialize }
+
     context 'in jsonapi.org format' do
       context 'an empty result' do
         it 'returns an empty result' do
-          result.should == {}
+          expect(result).to eq({})
         end
       end
 
@@ -26,9 +27,9 @@ describe RestPack::Serializer::Result do
         end
 
         it 'returns correct jsonapi.org format' do
-          result[:albums].should == subject.resources[:albums]
-          result[:meta].should == subject.meta
-          result[:links].should == subject.links
+          expect(result[:albums]).to eq(subject.resources[:albums])
+          expect(result[:meta]).to eq(subject.meta)
+          expect(result[:links]).to eq(subject.links)
         end
       end
 
@@ -43,16 +44,16 @@ describe RestPack::Serializer::Result do
         end
 
         it 'returns correct jsonapi.org format, including injected has_many links' do
-          result[:albums].should == [{ id: '1', name: 'AMOK', links: { songs: ['91'] } }]
-          result[:links].should == subject.links
-          result[:linked][:songs].should == subject.resources[:songs]
+          expect(result[:albums]).to eq([{ id: '1', name: 'AMOK', links: { songs: ['91'] } }])
+          expect(result[:links]).to eq(subject.links)
+          expect(result[:linked][:songs]).to eq(subject.resources[:songs])
         end
 
         it 'includes resources in correct order' do
-          result.keys[0].should == :albums
-          result.keys[1].should == :linked
-          result.keys[2].should == :links
-          result.keys[3].should == :meta
+          expect(result.keys[0]).to eq(:albums)
+          expect(result.keys[1]).to eq(:linked)
+          expect(result.keys[2]).to eq(:links)
+          expect(result.keys[3]).to eq(:meta)
         end
 
         context 'with multiple calls to serialize' do
@@ -62,7 +63,7 @@ describe RestPack::Serializer::Result do
           end
 
           it 'does not create duplicate has_many links' do
-            result[:albums].first[:links][:songs].count.should == 1
+            expect(result[:albums].first[:links][:songs].count).to eq(1)
           end
         end
       end

data/spec/serializable/filterable_spec.rb

@@ -9,6 +9,6 @@ describe RestPack::Serializer::Filterable do
   end
 
   it "captures the specified filters" do
-    CustomSerializer.serializable_filters.should == [:a, :c]
+    expect(CustomSerializer.serializable_filters).to eq([:a, :c])
   end
 end

data/spec/serializable/options_spec.rb

@@ -6,94 +6,99 @@ describe RestPack::Serializer::Options do
   let(:scope) { nil }
 
   describe 'default values' do
-    it { subject.model_class.should == MyApp::Song }
-    it { subject.include.should == [] }
-    it { subject.page.should == 1 }
-    it { subject.page_size.should == 10 }
-    it { subject.filters.should == {} }
-    it { subject.scope.should == MyApp::Song.all }
-    it { subject.default_page_size?.should == true }
-    it { subject.filters_as_url_params.should == '' }
+    it { expect(subject.model_class).to eq(MyApp::Song) }
+    it { expect(subject.include).to eq([]) }
+    it { expect(subject.page).to eq(1) }
+    it { expect(subject.page_size).to eq(10) }
+    it { expect(subject.filters).to eq({}) }
+    it { expect(subject.scope).to eq(MyApp::Song.all) }
+    it { expect(subject.default_page_size?).to eq(true) }
+    it { expect(subject.filters_as_url_params).to eq('') }
   end
 
   describe 'with paging params' do
     let(:params) { { 'page' => '2', 'page_size' => '8' } }
-    it { subject.page.should == 2 }
-    it { subject.page_size.should == 8 }
+    it { expect(subject.page).to eq(2) }
+    it { expect(subject.page_size).to eq(8) }
   end
 
   describe 'with include' do
     let(:params) { { 'include' => 'model1,model2' } }
-    it { subject.include.should == ["model1", "model2"] }
+    it { expect(subject.include).to eq(%w(model1 model2)) }
   end
 
   context 'with filters' do
     describe 'with no filter params' do
-      let(:params) { { } }
-      it { subject.filters.should == {} }
+      let(:params) { {} }
+      it { expect(subject.filters).to eq({}) }
     end
+
     describe 'with a primary key with a single value' do
       let(:params) { { 'id' => '142857' } }
-      it { subject.filters.should == { id: ['142857'] } }
-      it { subject.filters_as_url_params.should == 'id=142857' }
+      it { expect(subject.filters).to eq(id: %w(142857)) }
+      it { expect(subject.filters_as_url_params).to eq('id=142857') }
     end
+
     describe 'with a primary key with multiple values' do
       let(:params) { { 'ids' => '42,142857' } }
-      it { subject.filters.should == { id: ['42', '142857'] } }
-      it { subject.filters_as_url_params.should == 'id=42,142857' }
+      it { expect(subject.filters).to eq(id: %w(42 142857)) }
+      it { expect(subject.filters_as_url_params).to eq('id=42,142857') }
     end
+
     describe 'with a foreign key with a single value' do
       let(:params) { { 'album_id' => '789' } }
-      it { subject.filters.should == { album_id: ['789'] } }
-      it { subject.filters_as_url_params.should == 'album_id=789' }
+      it { expect(subject.filters).to eq(album_id: %w(789)) }
+      it { expect(subject.filters_as_url_params).to eq('album_id=789') }
     end
+
     describe 'with a foreign key with multiple values' do
       let(:params) { { 'album_id' => '789,678,567' } }
-      it { subject.filters.should == { album_id: ['789', '678', '567'] } }
-      it { subject.filters_as_url_params.should == 'album_id=789,678,567' }
+      it { expect(subject.filters).to eq(album_id: %w(789 678 567)) }
+      it { expect(subject.filters_as_url_params).to eq('album_id=789,678,567') }
     end
+
     describe 'with multiple foreign keys' do
       let(:params) { { 'album_id' => '111,222', 'artist_id' => '888,999' } }
-      it { subject.filters.should == { album_id: ['111', '222'], artist_id: ['888', '999'] } }
-      it { subject.filters_as_url_params.should == 'album_id=111,222&artist_id=888,999' }
+      it { expect(subject.filters).to eq(album_id: %w(111 222), artist_id: %w(888 999)) }
+      it { expect(subject.filters_as_url_params).to eq('album_id=111,222&artist_id=888,999') }
     end
   end
 
   context 'with sorting parameters' do
     describe 'with no params' do
-      let(:params) { { } }
-      it { subject.sorting.should == {} }
+      let(:params) { {} }
+      it { expect(subject.sorting).to eq({}) }
     end
     describe 'with a sorting value' do
       let(:params) { { 'sort' => 'Title' } }
-      it { subject.sorting.should == { title: :asc } }
-      it { subject.sorting_as_url_params.should == 'sort=title' }
+      it { expect(subject.sorting).to eq(title: :asc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=title') }
     end
     describe 'with a descending sorting value' do
       let(:params) { { 'sort' => '-title' } }
-      it { subject.sorting.should == { title: :desc } }
-      it { subject.sorting_as_url_params.should == 'sort=-title' }
+      it { expect(subject.sorting).to eq(title: :desc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=-title') }
     end
     describe 'with multiple sorting values' do
       let(:params) { { 'sort' => '-Title,ID' } }
-      it { subject.sorting.should == { title: :desc, id: :asc } }
-      it { subject.sorting_as_url_params.should == 'sort=-title,id' }
+      it { expect(subject.sorting).to eq(title: :desc, id: :asc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=-title,id') }
     end
     describe 'with a not allowed sorting value' do
       let(:params) { { 'sort' => '-title,album_id,id' } }
-      it { subject.sorting.should == { title: :desc, id: :asc } }
-      it { subject.sorting_as_url_params.should == 'sort=-title,id' }
+      it { expect(subject.sorting).to eq(title: :desc, id: :asc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=-title,id') }
     end
   end
 
   context 'scopes' do
     describe 'with default scope' do
-      it { subject.scope.should == MyApp::Song.all }
+      it { expect(subject.scope).to eq(MyApp::Song.all) }
     end
 
     describe 'with custom scope' do
       let(:scope) { MyApp::Song.where("id >= 100") }
-      it { subject.scope.should == scope }
+      it { expect(subject.scope).to eq(scope) }
     end
   end
 end

data/spec/serializable/paging_spec.rb

@@ -8,32 +8,35 @@ describe RestPack::Serializer::Paging do
 
   context "#page" do
     let(:page) { MyApp::SongSerializer.page(params, scope, context) }
-    let(:params) { { } }
+    let(:params) { {} }
     let(:scope) { nil }
-    let(:context) { { } }
+    let(:context) { {} }
 
     context "with defaults" do
       it "page defaults to 1" do
-        page[:meta][:songs][:page].should == 1
+        expect(page[:meta][:songs][:page]).to eq(1)
       end
+
       it "page_size defaults to 10" do
-        page[:meta][:songs][:page_size].should == 10
+        expect(page[:meta][:songs][:page_size]).to eq(10)
       end
+
       it "includes valid paging meta data" do
-        page[:meta][:songs][:count].should == 18
-        page[:meta][:songs][:page_count].should == 2
-        page[:meta][:songs][:first_href].should == '/songs'
-        page[:meta][:songs][:previous_page].should == nil
-        page[:meta][:songs][:previous_href].should == nil
-        page[:meta][:songs][:next_page].should == 2
-        page[:meta][:songs][:next_href].should == '/songs?page=2'
-        page[:meta][:songs][:last_href].should == '/songs?page=2'
+        expect(page[:meta][:songs][:count]).to eq(18)
+        expect(page[:meta][:songs][:page_count]).to eq(2)
+        expect(page[:meta][:songs][:first_href]).to eq('/songs')
+        expect(page[:meta][:songs][:previous_page]).to eq(nil)
+        expect(page[:meta][:songs][:previous_href]).to eq(nil)
+        expect(page[:meta][:songs][:next_page]).to eq(2)
+        expect(page[:meta][:songs][:next_href]).to eq('/songs?page=2')
+        expect(page[:meta][:songs][:last_href]).to eq('/songs?page=2')
       end
+
       it "includes links" do
-        page[:links].should == {
-          'songs.album' => { :href => "/albums/{songs.album}", :type => :albums },
-          'songs.artist' => { :href => "/artists/{songs.artist}", :type => :artists }
-        }
+        expect(page[:links]).to eq(
+          'songs.album' => { href: "/albums/{songs.album}", type: :albums },
+          'songs.artist' => { href: "/artists/{songs.artist}", type: :artists }
+        )
       end
     end
 
@@ -42,42 +45,44 @@ describe RestPack::Serializer::Paging do
         @original_prefix = MyApp::SongSerializer.href_prefix
         MyApp::SongSerializer.href_prefix = '/api/v3'
       end
-      after do
-        MyApp::SongSerializer.href_prefix = @original_prefix
-      end
-      let(:page) do
-        MyApp::SongSerializer.page(params, scope, context)
-      end
+      after { MyApp::SongSerializer.href_prefix = @original_prefix }
+
+      let(:page) { MyApp::SongSerializer.page(params, scope, context) }
+
       it 'should use prefixed links' do
-        page[:meta][:songs][:next_href].should == '/api/v3/songs?page=2'
+        expect(page[:meta][:songs][:next_href]).to eq('/api/v3/songs?page=2')
       end
     end
 
     context "with custom page size" do
       let(:params) { { page_size: '3' } }
+
       it "returns custom page sizes" do
-        page[:meta][:songs][:page_size].should == 3
-        page[:meta][:songs][:page_count].should == 6
+        expect(page[:meta][:songs][:page_size]).to eq(3)
+        expect(page[:meta][:songs][:page_count]).to eq(6)
       end
+
       it "includes the custom page size in the page hrefs" do
-        page[:meta][:songs][:next_page].should == 2
-        page[:meta][:songs][:next_href].should == '/songs?page=2&page_size=3'
-        page[:meta][:songs][:last_href].should == '/songs?page=6&page_size=3'
+        expect(page[:meta][:songs][:next_page]).to eq(2)
+        expect(page[:meta][:songs][:next_href]).to eq('/songs?page=2&page_size=3')
+        expect(page[:meta][:songs][:last_href]).to eq('/songs?page=6&page_size=3')
       end
     end
 
     context "with custom filter" do
       context "valid :title" do
         let(:params) { { title: @album1.songs[0].title } }
+
         it "returns the album" do
-          page[:meta][:songs][:count].should == 1
+          expect(page[:meta][:songs][:count]).to eq(1)
         end
       end
 
       context "invalid :title" do
         let(:params) { { title: "this doesn't exist" } }
+
         it "returns the album" do
-          page[:meta][:songs][:count].should == 0
+          expect(page[:meta][:songs][:count]).to eq(0)
         end
       end
     end
@@ -87,13 +92,13 @@ describe RestPack::Serializer::Paging do
 
       it "returns reversed titles" do
         first = MyApp::Song.first
-        page[:songs].first[:title].should == first.title.reverse
+        expect(page[:songs].first[:title]).to eq(first.title.reverse)
       end
     end
 
     it "serializes results" do
       first = MyApp::Song.first
-      page[:songs].first.should == {
+      expect(page[:songs].first).to eq(
         id: first.id.to_s,
         title: first.title,
         album_id: first.album_id,
@@ -101,17 +106,17 @@ describe RestPack::Serializer::Paging do
           album: first.album_id.to_s,
           artist: first.artist_id.to_s
         }
-      }
+      )
     end
 
     context "first page" do
       let(:params) { { page: '1' } }
 
       it "returns first page" do
-        page[:meta][:songs][:page].should == 1
-        page[:meta][:songs][:page_size].should == 10
-        page[:meta][:songs][:previous_page].should == nil
-        page[:meta][:songs][:next_page].should == 2
+        expect(page[:meta][:songs][:page]).to eq(1)
+        expect(page[:meta][:songs][:page_size]).to eq(10)
+        expect(page[:meta][:songs][:previous_page]).to eq(nil)
+        expect(page[:meta][:songs][:next_page]).to eq(2)
       end
     end
 
@@ -119,11 +124,11 @@ describe RestPack::Serializer::Paging do
       let(:params) { { page: '2' } }
 
       it "returns second page" do
-        page[:songs].length.should == 8
-        page[:meta][:songs][:page].should == 2
-        page[:meta][:songs][:previous_page].should == 1
-        page[:meta][:songs][:next_page].should == nil
-        page[:meta][:songs][:previous_href].should == '/songs'
+        expect(page[:songs].length).to eq(8)
+        expect(page[:meta][:songs][:page]).to eq(2)
+        expect(page[:meta][:songs][:previous_page]).to eq(1)
+        expect(page[:meta][:songs][:next_page]).to eq(nil)
+        expect(page[:meta][:songs][:previous_href]).to eq('/songs')
       end
     end
 
@@ -131,48 +136,49 @@ describe RestPack::Serializer::Paging do
       let(:params) { { include: 'albums' } }
 
       it "includes side-loaded models" do
-        page[:linked][:albums].should_not == nil
+        expect(page[:linked][:albums]).not_to eq(nil)
       end
 
       it "includes the side-loads in the main meta data" do
-        page[:meta][:songs][:include].should == ["albums"]
+        expect(page[:meta][:songs][:include]).to eq(%w(albums))
       end
 
       it "includes the side-loads in page hrefs" do
-        page[:meta][:songs][:next_href].should == '/songs?page=2&include=albums'
+        expect(page[:meta][:songs][:next_href]).to eq('/songs?page=2&include=albums')
       end
 
       it "includes links between documents" do
         song = page[:songs].first
         song_model = MyApp::Song.find(song[:id])
-        song[:links][:album].should == song_model.album_id.to_s
-        song[:links][:artist].should == song_model.artist_id.to_s
+        expect(song[:links][:album]).to eq(song_model.album_id.to_s)
+        expect(song[:links][:artist]).to eq(song_model.artist_id.to_s)
 
         album = page[:linked][:albums].first
         album_model = MyApp::Album.find(album[:id])
 
-        album[:links][:artist].should == album_model.artist_id.to_s
-        (page[:songs].map { |song| song[:id] } - album[:links][:songs]).empty?.should be_truthy
+        expect(album[:links][:artist]).to eq(album_model.artist_id.to_s)
+        expect((page[:songs].map { |song| song[:id] } - album[:links][:songs]).empty?).to eq(true)
       end
 
       context "with includes as comma delimited string" do
         let(:params) { { include: "albums,artists" } }
+
         it "includes side-loaded models" do
-          page[:linked][:albums].should_not == nil
-          page[:linked][:artists].should_not == nil
+          expect(page[:linked][:albums]).not_to eq(nil)
+          expect(page[:linked][:artists]).not_to eq(nil)
         end
 
         it "includes the side-loads in page hrefs" do
-          page[:meta][:songs][:next_href].should == '/songs?page=2&include=albums,artists'
+          expect(page[:meta][:songs][:next_href]).to eq('/songs?page=2&include=albums,artists')
         end
 
         it "includes links" do
-          page[:links]['songs.album'].should_not == nil
-          page[:links]['songs.artist'].should_not == nil
-          page[:links]['albums.songs'].should_not == nil
-          page[:links]['albums.artist'].should_not == nil
-          page[:links]['artists.songs'].should_not == nil
-          page[:links]['artists.albums'].should_not == nil
+          expect(page[:links]['songs.album']).not_to eq(nil)
+          expect(page[:links]['songs.artist']).not_to eq(nil)
+          expect(page[:links]['albums.songs']).not_to eq(nil)
+          expect(page[:links]['albums.artist']).not_to eq(nil)
+          expect(page[:links]['artists.songs']).not_to eq(nil)
+          expect(page[:links]['artists.albums']).not_to eq(nil)
         end
       end
     end
@@ -182,7 +188,7 @@ describe RestPack::Serializer::Paging do
         let(:params) { {} }
 
         it "returns a page of all data" do
-          page[:meta][:songs][:count].should == 18
+          expect(page[:meta][:songs][:count]).to eq(18)
         end
       end
 
@@ -190,11 +196,11 @@ describe RestPack::Serializer::Paging do
         let(:params) { { album_id: @album1.id.to_s } }
 
         it "returns a page with songs from album1" do
-          page[:meta][:songs][:count].should == @album1.songs.length
+          expect(page[:meta][:songs][:count]).to eq(@album1.songs.length)
         end
 
         it "includes the filter in page hrefs" do
-          page[:meta][:songs][:next_href].should == "/songs?page=2&album_id=#{@album1.id}"
+          expect(page[:meta][:songs][:next_href]).to eq("/songs?page=2&album_id=#{@album1.id}")
         end
       end
     end
@@ -204,7 +210,7 @@ describe RestPack::Serializer::Paging do
         let(:params) { {} }
 
         it "uses the model's sorting" do
-          page[:songs].first[:id].to_i.should < page[:songs].last[:id].to_i
+          expect(page[:songs].first[:id].to_i < page[:songs].last[:id].to_i).to eq(true)
         end
       end
 
@@ -212,11 +218,11 @@ describe RestPack::Serializer::Paging do
         let(:params) { { sort: '-title' } }
 
         it 'returns a page with sorted songs' do
-          page[:songs].first[:title].should > page[:songs].last[:title]
+          expect(page[:songs].first[:title] > page[:songs].last[:title]).to eq(true)
         end
 
         it 'includes the sorting in page hrefs' do
-          page[:meta][:songs][:next_href].should == '/songs?page=2&sort=-title'
+          expect(page[:meta][:songs][:next_href]).to eq('/songs?page=2&sort=-title')
         end
       end
     end
@@ -230,7 +236,7 @@ describe RestPack::Serializer::Paging do
       let(:scope) { MyApp::Album.classic }
 
       it "returns a page of scoped data" do
-        page[:meta][:albums][:count].should == 2
+        expect(page[:meta][:albums][:count]).to eq(2)
       end
     end
   end
@@ -242,43 +248,44 @@ describe RestPack::Serializer::Paging do
 
     context "with defaults" do
       it "includes valid paging meta data" do
-        page[:meta][:songs][:count].should == 18
-        page[:meta][:songs][:page_count].should == 2
-        page[:meta][:songs][:previous_page].should == nil
-        page[:meta][:songs][:next_page].should == 2
+        expect(page[:meta][:songs][:count]).to eq(18)
+        expect(page[:meta][:songs][:page_count]).to eq(2)
+        expect(page[:meta][:songs][:previous_page]).to eq(nil)
+        expect(page[:meta][:songs][:next_page]).to eq(2)
       end
     end
 
     context "with custom page size" do
       let(:params) { { page_size: '3' } }
+
       it "returns custom page sizes" do
-        page[:meta][:songs][:page_size].should == 3
-        page[:meta][:songs][:page_count].should == 6
+        expect(page[:meta][:songs][:page_size]).to eq(3)
+        expect(page[:meta][:songs][:page_count]).to eq(6)
       end
     end
   end
 
   context "paging with paged side-load" do
     let(:page) { MyApp::AlbumSerializer.page_with_options(options) }
-    let(:options) { RestPack::Serializer::Options.new(MyApp::AlbumSerializer, { include: 'songs' }) }
+    let(:options) { RestPack::Serializer::Options.new(MyApp::AlbumSerializer, include: 'songs') }
 
     it "includes side-loaded paging data in meta data" do
-      page[:meta][:albums].should_not == nil
-      page[:meta][:albums][:page].should == 1
-      page[:meta][:songs].should_not == nil
-      page[:meta][:songs][:page].should == 1
+      expect(page[:meta][:albums]).not_to eq(nil)
+      expect(page[:meta][:albums][:page]).to eq(1)
+      expect(page[:meta][:songs]).not_to eq(nil)
+      expect(page[:meta][:songs][:page]).to eq(1)
     end
   end
 
   context "paging with two paged side-loads" do
     let(:page) { MyApp::ArtistSerializer.page_with_options(options) }
-    let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { include: 'albums,songs' }) }
+    let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, include: 'albums,songs') }
 
     it "includes side-loaded paging data in meta data" do
-      page[:meta][:albums].should_not == nil
-      page[:meta][:albums][:page].should == 1
-      page[:meta][:songs].should_not == nil
-      page[:meta][:songs][:page].should == 1
+      expect(page[:meta][:albums]).not_to eq(nil)
+      expect(page[:meta][:albums][:page]).to eq(1)
+      expect(page[:meta][:songs]).not_to eq(nil)
+      expect(page[:meta][:songs][:page]).to eq(1)
     end
   end
 end