restpack_serializer 0.6.7 → 0.6.12

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

data/spec/serializable/resource_spec.rb

@@ -9,18 +9,18 @@ describe RestPack::Serializer::Resource do
   let(:resource) { MyApp::SongSerializer.resource(params, scope, context) }
   let(:params) { { id: @song.id } }
   let(:scope) { nil }
-  let(:context) { { } }
+  let(:context) { {} }
 
   it "returns a resource by id" do
-    resource[:songs].count.should == 1
-    resource[:songs][0][:id].should == @song.id.to_s
+    expect(resource[:songs].count).to eq(1)
+    expect(resource[:songs][0][:id]).to eq(@song.id.to_s)
   end
 
   context "with context" do
     let(:context) { { reverse_title?: true } }
 
     it "returns reversed titles" do
-      resource[:songs][0][:title].should == @song.title.reverse
+      expect(resource[:songs][0][:title]).to eq(@song.title.reverse)
     end
   end
 
@@ -28,19 +28,20 @@ describe RestPack::Serializer::Resource do
     let(:params) { { id: @song.id, include: 'albums' } }
 
     it "includes side-loaded models" do
-      resource[:linked][:albums].count.should == 1
-      resource[:linked][:albums].first[:id].should == @song.album.id.to_s
+      expect(resource[:linked][:albums].count).to eq(1)
+      expect(resource[:linked][:albums].first[:id]).to eq(@song.album.id.to_s)
     end
 
     it "includes the side-loads in the main meta data" do
-      resource[:meta][:songs][:include].should == ["albums"]
+      expect(resource[:meta][:songs][:include]).to eq(%w(albums))
     end
   end
 
   describe "missing resource" do
     let(:params) { { id: "-99" } }
+
     it "returns no resource" do
-      resource[:songs].length.should == 0
+      expect(resource[:songs].length).to eq(0)
     end
 
     #TODO: add specs for jsonapi error format when it has been standardised
@@ -49,11 +50,11 @@ describe RestPack::Serializer::Resource do
   end
 
   describe "song with no artist" do
-    let(:song) { FactoryGirl.create(:song, :artist => nil) }
+    let(:song) { FactoryGirl.create(:song, artist: nil) }
     let(:resource) { MyApp::SongSerializer.resource(id: song.id.to_s) }
 
     it "should not have an artist link" do
-      resource[:songs][0][:links].keys.should_not include(:artist)
+      expect(resource[:songs][0][:links].keys).not_to include(:artist)
     end
   end
 end

data/spec/serializable/serializer_spec.rb

@@ -27,7 +27,7 @@ describe RestPack::Serializer do
     end
 
     it ".as_json serializes to an empty hash" do
-      EmptySerializer.as_json(person).should == { }
+      expect(EmptySerializer.as_json(person)).to eq({})
     end
   end
 
@@ -71,11 +71,32 @@ describe RestPack::Serializer do
     end
 
     it ".as_json serializes" do
-      serialized = DerivedSerializer.as_json({}, { include_food?: false, name: 'Ben', age: 1 })
-      serialized.should == { #NOTE: I think this should include colour as DerivedSerializer defines it, but this would be a big breaking change
+      serialized = DerivedSerializer.as_json({}, include_food?: false, name: 'Ben', age: 1)
+      expect(serialized).to eq({ #NOTE: I think this should include colour as DerivedSerializer defines it, but this would be a big breaking change
         name: "Ben",
         age: 1
-      }
+      })
+    end
+  end
+
+  context "serializer instance variables" do
+    class MemoizingSerializer
+      include RestPack::Serializer
+
+      attributes :id, :memoized_id
+
+      def memoized_id
+        @memoized_id ||= id
+      end
+    end
+
+    it "does not reuse instance variable values" do
+      people = [Person.new(id: 123), Person.new(id: 456)]
+      serialized = MemoizingSerializer.as_json(people)
+      expect(serialized).to eq([
+        { id: "123", memoized_id: "123" },
+        { id: "456", memoized_id: "456" }
+      ])
     end
   end
 
@@ -116,34 +137,35 @@ describe RestPack::Serializer do
 
     def custom_attributes
       {
-        :custom_key => "custom value for model id #{@model.id}"
+        custom_key: "custom value for model id #{@model.id}"
       }
     end
   end
 
   describe ".serialize" do
     it "serializes to an array" do
-      serializer.class.serialize(person).should == {
+      expect(serializer.class.serialize(person)).to eq(
         people: [{
           id: '123', name: 'Gavin', description: 'This is person #123',
           href: '/people/123', custom_key: 'custom value for model id 123'
         }]
-      }
+      )
     end
   end
 
   describe ".as_json" do
     it "serializes specified attributes" do
-      serializer.as_json(person).should == {
+      expect(serializer.as_json(person)).to eq(
         id: '123', name: 'Gavin', description: 'This is person #123',
         href: '/people/123', custom_key: 'custom value for model id 123'
-      }
+      )
     end
 
     context "an array" do
       let(:people) { [person, person] }
+
       it "results in a serialized array" do
-        serializer.as_json(people).should == [
+        expect(serializer.as_json(people)).to eq([
           {
             id: '123', name: 'Gavin', description: 'This is person #123',
             href: '/people/123', custom_key: 'custom value for model id 123'
@@ -152,11 +174,12 @@ describe RestPack::Serializer do
             id: '123', name: 'Gavin', description: 'This is person #123',
             href: '/people/123', custom_key: 'custom value for model id 123'
           }
-        ]
+        ])
       end
+
       context "#array_as_json" do
         it "results in a serialized array" do
-          serializer.class.array_as_json(people).should == [
+          expect(serializer.class.array_as_json(people)).to eq([
             {
               id: '123', name: 'Gavin', description: 'This is person #123',
               href: '/people/123', custom_key: 'custom value for model id 123'
@@ -165,75 +188,75 @@ describe RestPack::Serializer do
               id: '123', name: 'Gavin', description: 'This is person #123',
               href: '/people/123', custom_key: 'custom value for model id 123'
             }
-          ]
+          ])
         end
       end
     end
 
     context "nil" do
       it "results in nil" do
-        serializer.as_json(nil).should == nil
+        expect(serializer.as_json(nil)).to eq(nil)
       end
     end
 
     context "with options" do
       it "excludes specified attributes" do
-        serializer.as_json(person, { include_description?: false }).should == {
+        expect(serializer.as_json(person, include_description?: false)).to eq(
           id: '123', name: 'Gavin', href: '/people/123',
           custom_key: 'custom value for model id 123'
-        }
+        )
       end
 
       it "excludes custom attributes if specified" do
-        hash = serializer.as_json(person, { is_admin?: false })
-        hash[:admin_info].should == nil
+        hash = serializer.as_json(person, is_admin?: false)
+        expect(hash[:admin_info]).to eq(nil)
       end
 
       it "includes custom attributes if specified" do
-        hash = serializer.as_json(person, { is_admin?: true })
-        hash[:admin_info].should == {
+        hash = serializer.as_json(person, is_admin?: true)
+        expect(hash[:admin_info]).to eq(
           key: "super_secret_sauce",
           array: [
             name: 'Alex'
           ]
-        }
+        )
       end
 
       it "excludes a blacklist of attributes if specified as an array" do
-        serializer.as_json(person, { attribute_blacklist: [:name, :description] }).should == {
+        expect(serializer.as_json(person, attribute_blacklist: [:name, :description])).to eq(
           id: '123',
           href: '/people/123',
           custom_key: 'custom value for model id 123'
-        }
+        )
       end
 
       it "excludes a blacklist of attributes if specified as a string" do
-        serializer.as_json(person, { attribute_blacklist: 'name, description' }).should == {
+        expect(serializer.as_json(person, attribute_blacklist: 'name, description')).to eq(
           id: '123',
           href: '/people/123',
           custom_key: 'custom value for model id 123'
-        }
+        )
       end
 
       it "includes a whitelist of attributes if specified as an array" do
-        serializer.as_json(person, { attribute_whitelist: [:name, :description] }).should == {
+        expect(serializer.as_json(person, attribute_whitelist: [:name, :description])).to eq(
           name: 'Gavin',
           description: 'This is person #123',
           custom_key: 'custom value for model id 123'
-        }
+        )
       end
 
       it "includes a whitelist of attributes if specified as a string" do
-        serializer.as_json(person, { attribute_whitelist: 'name, description' }).should == {
+        expect(serializer.as_json(person, attribute_whitelist: 'name, description')).to eq(
           name: 'Gavin',
           description: 'This is person #123',
           custom_key: 'custom value for model id 123'
-        }
+        )
       end
 
       it "raises an exception if both the whitelist and blacklist are provided" do
         expect do
-          serializer.as_json(person, { attribute_whitelist: [:name], attribute_blacklist: [:id] })
+          serializer.as_json(person, attribute_whitelist: [:name], attribute_blacklist: [:id])
         end.to raise_error(ArgumentError, "the context can't define both an `attribute_whitelist` and an `attribute_blacklist`")
       end
     end
@@ -245,10 +268,10 @@ describe RestPack::Serializer do
         it "includes 'links' data for :belongs_to associations" do
           @album1 = FactoryGirl.create(:album_with_songs, song_count: 11)
           json = serializer.as_json(@album1.songs.first)
-          json[:links].should == {
+          expect(json[:links]).to eq(
             artist: @album1.artist_id.to_s,
             album: @album1.id.to_s
-          }
+          )
         end
       end
 
@@ -256,12 +279,13 @@ describe RestPack::Serializer do
         let(:artist_factory) { FactoryGirl.create :artist_with_fans }
         let(:artist_serializer) { MyApp::ArtistSerializer.new }
         let(:json) { artist_serializer.as_json(artist_factory) }
-        let(:side_load_ids) { artist_has_association.map {|obj| obj.id.to_s } }
+        let(:side_load_ids) { artist_has_association.map { |obj| obj.id.to_s } }
 
         context "when the association has been eager loaded" do
           before do
-            artist_factory.fans.stub(:loaded?) { true }
+            allow(artist_factory.fans).to receive(:loaded?).and_return(true)
           end
+
           it "does not make a query to retrieve id values" do
             expect(artist_factory.fans).not_to receive(:pluck)
             json
@@ -289,9 +313,23 @@ describe RestPack::Serializer do
     end
   end
 
+  describe "to_json" do
+    context "class method" do
+      it "delegates to as_json" do
+        expect(PersonSerializer.as_json(person).to_json).to eq(PersonSerializer.to_json(person))
+      end
+    end
+
+    context "instance method" do
+      it "delegates to as_json" do
+        expect(serializer.as_json(person).to_json).to eq(serializer.to_json(person))
+      end
+    end
+  end
+
   describe "#model_class" do
     it "extracts the Model name from the Serializer name" do
-      PersonSerializer.model_class.should == Person
+      expect(PersonSerializer.model_class).to eq(Person)
     end
 
     context "with namespaced model class" do
@@ -306,7 +344,7 @@ describe RestPack::Serializer do
       end
 
       it "returns the correct class" do
-        NamespacedSerializer.model_class.should == SomeNamespace::Model
+        expect(NamespacedSerializer.model_class).to eq(SomeNamespace::Model)
       end
     end
   end
@@ -314,15 +352,15 @@ describe RestPack::Serializer do
   describe "#key" do
     context "with default key" do
       it "returns the correct key" do
-        PersonSerializer.key.should == :people
+        expect(PersonSerializer.key).to eq(:people)
       end
 
       it "has correct #singular_key" do
-        PersonSerializer.singular_key.should == :person
+        expect(PersonSerializer.singular_key).to eq(:person)
       end
 
       it "has correct #plural_key" do
-        PersonSerializer.plural_key.should == :people
+        expect(PersonSerializer.plural_key).to eq(:people)
       end
     end
 
@@ -333,11 +371,11 @@ describe RestPack::Serializer do
       end
 
       it "returns the correct key" do
-        SerializerWithCustomKey.key.should == :customers
+        expect(SerializerWithCustomKey.key).to eq(:customers)
       end
 
       it "has correct #singular_key" do
-        SerializerWithCustomKey.singular_key.should == :customer
+        expect(SerializerWithCustomKey.singular_key).to eq(:customer)
       end
     end
   end