restpack_serializer 0.6.7 → 0.6.8

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,11 @@ 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
 
@@ -116,34 +116,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 +153,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 +167,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 +247,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 +258,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
@@ -291,7 +294,7 @@ describe RestPack::Serializer do
 
   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 +309,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 +317,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 +336,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

data/spec/serializable/side_loading/belongs_to_spec.rb

@@ -17,15 +17,15 @@ describe RestPack::Serializer::SideLoading do
           let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer) }
 
           it "returns a hash with no data" do
-            side_loads.should == { :meta => {} }
+            expect(side_loads).to eq(meta: {})
           end
         end
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "include" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, "include" => "albums") }
 
           it "returns a hash with no data" do
-            side_loads.should == { :meta => {} }
+            expect(side_loads).to eq(meta: {})
           end
         end
       end
@@ -34,13 +34,13 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [MyApp::Song.first] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "include" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, "include" => "albums") }
 
           it "returns side-loaded albums" do
-            side_loads.should == {
+            expect(side_loads).to eq(
               albums: [MyApp::AlbumSerializer.as_json(MyApp::Song.first.album)],
-              meta: { }
-            }
+              meta: {}
+            )
           end
         end
       end
@@ -53,16 +53,16 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [song1, song2] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "include" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, "include" => "albums") }
 
           it "returns side-loaded albums" do
-            side_loads.should == {
+            expect(side_loads).to eq(
               albums: [
                 MyApp::AlbumSerializer.as_json(song1.album),
                 MyApp::AlbumSerializer.as_json(song2.album)
               ],
-              :meta => { }
-            }
+              meta: {}
+            )
           end
         end
       end
@@ -72,10 +72,13 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [b_side] }
 
         context 'when including :albums' do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "include" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, "include" => "albums") }
 
           it 'return a hash with no data' do
-            side_loads.should == { :meta => {}, :albums => [] }
+            expect(side_loads).to eq(
+              albums: [],
+              meta: {}
+            )
           end
         end
       end

data/spec/serializable/side_loading/has_and_belongs_many_spec.rb

@@ -15,13 +15,13 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [@artist1] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "include" => "stalkers" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, "include" => "stalkers") }
           let(:stalker_count) { @artist1.stalkers.count }
 
           it "returns side-loaded albums" do
-            side_loads[:stalkers].count.should == stalker_count
-            side_loads[:meta][:stalkers][:page].should == 1
-            side_loads[:meta][:stalkers][:count].should == stalker_count
+            expect(side_loads[:stalkers].count).to eq(stalker_count)
+            expect(side_loads[:meta][:stalkers][:page]).to eq(1)
+            expect(side_loads[:meta][:stalkers][:count]).to eq(stalker_count)
           end
         end
       end
@@ -30,12 +30,12 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [@artist1, @artist2] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "include" => "stalkers" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, "include" => "stalkers") }
           let(:stalker_count) { @artist1.stalkers.count + @artist2.stalkers.count }
 
           it "returns side-loaded albums" do
-            side_loads[:stalkers].count.should == stalker_count
-            side_loads[:meta][:stalkers][:count].should == stalker_count
+            expect(side_loads[:stalkers].count).to eq(stalker_count)
+            expect(side_loads[:meta][:stalkers][:count]).to eq(stalker_count)
           end
         end
       end

data/spec/serializable/side_loading/has_many_spec.rb

@@ -15,12 +15,12 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [@artist1] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "include" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, "include" => "albums") }
 
           it "returns side-loaded albums" do
-            side_loads[:albums].count.should == @artist1.albums.count
-            side_loads[:meta][:albums][:page].should == 1
-            side_loads[:meta][:albums][:count].should == @artist1.albums.count
+            expect(side_loads[:albums].count).to eq(@artist1.albums.count)
+            expect(side_loads[:meta][:albums][:page]).to eq(1)
+            expect(side_loads[:meta][:albums][:count]).to eq(@artist1.albums.count)
           end
         end
       end
@@ -29,12 +29,12 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [@artist1, @artist2] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "include" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, "include" => "albums") }
 
           it "returns side-loaded albums" do
             expected_count = @artist1.albums.count + @artist2.albums.count
-            side_loads[:albums].count.should == expected_count
-            side_loads[:meta][:albums][:count].should == expected_count
+            expect(side_loads[:albums].count).to eq(expected_count)
+            expect(side_loads[:meta][:albums][:count]).to eq(expected_count)
           end
         end
       end
@@ -42,28 +42,27 @@ describe RestPack::Serializer::SideLoading do
 
     describe '.has_many through' do
       context 'when including :fans' do
-        let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "include" => "fans" }) }
-        let(:artist_1) {FactoryGirl.create :artist_with_fans}
-        let(:artist_2) {FactoryGirl.create :artist_with_fans}
+        let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, "include" => "fans") }
+        let(:artist_1) { FactoryGirl.create :artist_with_fans }
+        let(:artist_2) { FactoryGirl.create :artist_with_fans }
 
         context "with a single model" do
-          let(:models) {[artist_1]}
+          let(:models) { [artist_1] }
 
           it 'returns side-loaded fans' do
-            side_loads[:fans].count.should == artist_1.fans.count
-            side_loads[:meta][:fans][:page].should == 1
-            side_loads[:meta][:fans][:count].should == artist_1.fans.count
+            expect(side_loads[:fans].count).to eq(artist_1.fans.count)
+            expect(side_loads[:meta][:fans][:page]).to eq(1)
+            expect(side_loads[:meta][:fans][:count]).to eq(artist_1.fans.count)
           end
         end
         context "with a multiple models" do
-          let(:models) {[artist_1, artist_2]}
+          let(:models) { [artist_1, artist_2] }
 
           it 'returns side-loaded fans' do
-            expected_count = artist_1.fans.count  + artist_2.fans.count
-
-            side_loads[:fans].count.should == expected_count
-            side_loads[:meta][:fans][:page].should == 1
-            side_loads[:meta][:fans][:count].should == expected_count
+            expected_count = artist_1.fans.count + artist_2.fans.count
+            expect(side_loads[:fans].count).to eq(expected_count)
+            expect(side_loads[:meta][:fans][:page]).to eq(1)
+            expect(side_loads[:meta][:fans][:count]).to eq(expected_count)
           end
 
           context "when there are shared fans" do