kippt 3.0.1 → 3.1.0

data/spec/kippt/comment_spec.rb

@@ -4,7 +4,7 @@ require "kippt/comment"
 describe Kippt::Comment do
   subject { Kippt::Comment.new(data, clip, client) }
   let(:client) { Kippt::Client.new(valid_user_credentials) }
-  let(:clip) { stub(:clip) }
+  let(:clip) { double(:clip) }
   let(:collection_resource_class) { Kippt::Comments }
 
   let(:data) { MultiJson.load(fixture("comment.json").read) }
@@ -19,7 +19,7 @@ describe Kippt::Comment do
 
   describe "#clip" do
     it "returns the clip passed to it" do
-      subject.clip.should eq clip
+      expect(subject.clip).to eq clip
     end
   end
 end

data/spec/kippt/comments_spec.rb

@@ -3,7 +3,7 @@ require "kippt/comments"
 
 describe Kippt::Comments do
   let(:client) { Kippt::Client.new(valid_user_credentials) }
-  let(:clip) { stub :clip, :id => 100, :all_comments_embedded? => false }
+  let(:clip) { double :clip, :id => 100, :all_comments_embedded? => false }
   subject { Kippt::Comments.new(client, clip) }
   let(:base_uri) { "clips/#{clip.id}/comments" }
   let(:singular_fixture) { "comment" }
@@ -18,11 +18,11 @@ describe Kippt::Comments do
 
   describe "#build" do
     it "returns new resource" do
-      subject.build.should be_a(resource_class)
+      expect(subject.build).to be_a(resource_class)
     end
 
     it "accepts parameters" do
-      subject.object_class.should_receive(:new).with({:an => "attribute"}, client, clip)
+      expect(subject.object_class).to receive(:new).with({:an => "attribute"}, client, clip)
       subject.build({:an => "attribute"})
     end
   end
@@ -43,22 +43,22 @@ describe Kippt::Comments do
     end
 
     context "when comments are embedded" do
-      let(:clip) { stub :clip,
-                        id: 100,
-                        all_comments_embedded?: true,
-                        comments_data: [{body: "Embedded body"}] }
+      let(:clip) { double :clip,
+                          id: 100,
+                          all_comments_embedded?: true,
+                          comments_data: [{body: "Embedded body"}] }
 
       it "uses the embedded data to create comments" do
         comments = subject.fetch
-        comments.first.body.should eq "Embedded body"
+        expect(comments.first.body).to eq "Embedded body"
       end
     end
 
     context "when passed unrecognized arguments" do
       it "raises error" do
-        lambda {
+        expect {
           subject.fetch(:foobar => true)
-        }.should raise_error(
+        }.to raise_error(
           ArgumentError, "Unrecognized argument: foobar")
       end
     end
@@ -68,22 +68,22 @@ describe Kippt::Comments do
     it "fetches single resource" do
       stub_get("/#{base_uri}/10").
         to_return(:status => 200, :body => fixture("#{singular_fixture}.json"))
-      subject[10].id.should eq 10
+      expect(subject[10].id).to eq 10
     end
 
     it "returns resource" do
       stub_get("/#{base_uri}/10").
         to_return(:status => 200, :body => fixture("#{singular_fixture}.json"))
-      subject[10].should be_a(resource_class)
+      expect(subject[10]).to be_a(resource_class)
     end
 
     context "when resource is not found" do
       it "raises exception" do
         stub_get("/#{base_uri}/10").
-          to_return(:status => 404, :body => {"message" => "Resource not found."})
-        lambda {
+          to_return(:status => 404, :body => {"message" => "Resource not found."}.to_json)
+        expect {
           subject[10]
-        }.should raise_error(
+        }.to raise_error(
           Kippt::APIError, "Resource could not be loaded: Resource not found.")
       end
     end
@@ -91,37 +91,17 @@ describe Kippt::Comments do
 
   describe "#find" do
     it "exists" do
-      subject.respond_to?(:find).should be_true
-    end
-  end
-
-  describe "#collection_from_url" do
-    it "returns a new collection" do
-      stub_get("/#{base_uri}/?limit=20&offset=20").
-        to_return(:status => 200, :body => fixture("#{collection_fixture}.json"))
-      collection = subject.collection_from_url("/api/#{base_uri}/?limit=20&offset=20")
-      collection.should be_a(collection_class)
-    end
-
-    context "when passed URL is blank" do
-      it "raises ArgumentError" do
-        lambda {
-          subject.collection_from_url("")
-        }.should raise_error(ArgumentError, "The parameter URL can't be blank")
-        lambda {
-          subject.collection_from_url(nil)
-        }.should raise_error(ArgumentError, "The parameter URL can't be blank")
-      end
+      expect(subject.respond_to?(:find)).to be_truthy
     end
   end
 
   describe "#build" do
     it "returns new resource" do
-      subject.build.should be_a(resource_class)
+      expect(subject.build).to be_a(resource_class)
     end
 
     it "accepts parameters" do
-      subject.object_class.should_receive(:new).with({:an => "attribute"}, client, clip)
+      expect(subject.object_class).to receive(:new).with({:an => "attribute"}, client, clip)
       subject.build(:an => "attribute")
     end
   end

data/spec/kippt/favorite_spec.rb

@@ -8,18 +8,18 @@ describe Kippt::Favorite do
     let(:favorite) { Kippt::Favorite.new(clip, client) }
 
     it "tells collection resource to save itself" do
-      collection.should_receive(:save_resource).with(favorite).and_return({success: true})
-      client.should_receive(:collection_resource_for).with(Kippt::Favorites, clip).and_return(collection)
+      expect(collection).to receive(:save_resource).with(favorite).and_return({success: true})
+      expect(client).to receive(:collection_resource_for).with(Kippt::Favorites, clip).and_return(collection)
 
-      favorite.save.should be_true
+      expect(favorite.save).to be_truthy
     end
 
     it "sets errors if there is any" do
-      collection.stub(:save_resource).and_return({success: false, error_message: "PROBLEM"})
-      client.stub(:collection_resource_for).and_return(collection)
+      allow(collection).to receive(:save_resource).and_return({success: false, error_message: "PROBLEM"})
+      allow(client).to receive(:collection_resource_for).and_return(collection)
 
-      favorite.save.should be_false
-      favorite.errors.should eq ["PROBLEM"]
+      expect(favorite.save).to be_falsey
+      expect(favorite.errors).to eq ["PROBLEM"]
     end
   end
 
@@ -30,9 +30,9 @@ describe Kippt::Favorite do
     let(:favorite) { Kippt::Favorite.new(clip, client) }
 
     it "tells collection resource to destroy itself" do
-      client.stub(:collection_resource_for).and_return(collection)
-      collection.should_receive(:destroy_resource).with(favorite).and_return(true)
-      favorite.destroy.should be_true
+      allow(client).to receive(:collection_resource_for).and_return(collection)
+      expect(collection).to receive(:destroy_resource).with(favorite).and_return(true)
+      expect(favorite.destroy).to be_truthy
     end
   end
 end

data/spec/kippt/favorites_spec.rb

@@ -3,7 +3,7 @@ require "kippt/favorites"
 
 describe Kippt::Favorites do
   let(:client) { Kippt::Client.new(valid_user_credentials) }
-  let(:clip) { stub :user, :id => 100, :all_favorites_embedded? => false }
+  let(:clip) { double :user, :id => 100, :all_favorites_embedded? => false }
   subject { Kippt::Favorites.new(client, clip) }
   let(:base_uri) { "clips/#{clip.id}/favorites" }
 
@@ -11,8 +11,8 @@ describe Kippt::Favorites do
     it "uses only the base_uri" do
       favorite = double :favorite
       response = double :response, success?: true
-      client.should_receive(:delete).with("clips/100/favorites").and_return(response)
-      subject.destroy_resource(favorite).should be_true
+      expect(client).to receive(:delete).with("clips/100/favorites").and_return(response)
+      expect(subject.destroy_resource(favorite)).to be_truthy
     end
   end
 end

data/spec/kippt/follow_relationship_spec.rb

@@ -3,20 +3,20 @@ require "kippt/follow_relationship"
 
 describe Kippt::FollowRelationship do
   let(:client) { Kippt::Client.new(valid_user_credentials) }
-  let(:user) { stub :user, :id => 10 }
+  let(:user) { double :user, :id => 10 }
   subject { Kippt::FollowRelationship.new(client, user) }
 
   describe "#following?" do
     it "returns boolean" do
       stub_get("/users/10/relationship/").
         to_return(:status => 200, :body => '{"following": true}')
-      subject.following?.should be_true
+      expect(subject.following?).to be_truthy
     end
 
     context "when request is not successful" do
       it "raises an exception" do
         fail_response = double :fail_response, success?: false, body: {"message" => "NOT FOUND"}
-        client.stub(:get).and_return(fail_response)
+        allow(client).to receive(:get).and_return(fail_response)
         expect {
           subject.following?
         }.to raise_exception Kippt::APIError, "Resource could not be loaded: NOT FOUND"
@@ -29,13 +29,13 @@ describe Kippt::FollowRelationship do
       stub_post("/users/10/relationship/").
          with(:body => "{\"action\":\"follow\"}").
          to_return(:status => 200, :body => "", :headers => {})
-      subject.follow.should be_true
+      expect(subject.follow).to be_truthy
     end
 
     context "when request is not successful" do
       it "raises an exception" do
         fail_response = double :fail_response, success?: false, body: {"message" => "NOT FOUND"}
-        client.stub(:post).and_return(fail_response)
+        allow(client).to receive(:post).and_return(fail_response)
         expect {
           subject.follow
         }.to raise_exception Kippt::APIError, "Problem with following: NOT FOUND"
@@ -48,13 +48,13 @@ describe Kippt::FollowRelationship do
       stub_post("/users/10/relationship/").
          with(:body => "{\"action\":\"unfollow\"}").
          to_return(:status => 200, :body => "", :headers => {})
-      subject.unfollow.should be_true
+      expect(subject.unfollow).to be_truthy
     end
 
     context "when request is not successful" do
       it "raises an exception" do
         fail_response = double :fail_response, success?: false, body: {"message" => "NOT FOUND"}
-        client.stub(:post).and_return(fail_response)
+        allow(client).to receive(:post).and_return(fail_response)
         expect {
           subject.unfollow
         }.to raise_exception Kippt::APIError, "Problem with unfollowing: NOT FOUND"

data/spec/kippt/like_spec.rb

@@ -8,18 +8,18 @@ describe Kippt::Like do
     let(:like) { Kippt::Like.new(clip, client) }
 
     it "tells collection resource to save itself" do
-      collection.should_receive(:save_resource).with(like).and_return({success: true})
-      client.should_receive(:collection_resource_for).with(Kippt::Likes, clip).and_return(collection)
+      expect(collection).to receive(:save_resource).with(like).and_return({success: true})
+      expect(client).to receive(:collection_resource_for).with(Kippt::Likes, clip).and_return(collection)
 
-      like.save.should be_true
+      expect(like.save).to be_truthy
     end
 
     it "sets errors if there is any" do
-      collection.stub(:save_resource).and_return({success: false, error_message: "PROBLEM"})
-      client.stub(:collection_resource_for).and_return(collection)
+      allow(collection).to receive(:save_resource).and_return({success: false, error_message: "PROBLEM"})
+      allow(client).to receive(:collection_resource_for).and_return(collection)
 
-      like.save.should be_false
-      like.errors.should eq ["PROBLEM"]
+      expect(like.save).to be_falsey
+      expect(like.errors).to eq ["PROBLEM"]
     end
   end
 
@@ -30,9 +30,9 @@ describe Kippt::Like do
     let(:like) { Kippt::Like.new(clip, client) }
 
     it "tells collection resource to destroy itself" do
-      client.stub(:collection_resource_for).and_return(collection)
-      collection.should_receive(:destroy_resource).with(like).and_return(true)
-      like.destroy.should be_true
+      allow(client).to receive(:collection_resource_for).and_return(collection)
+      expect(collection).to receive(:destroy_resource).with(like).and_return(true)
+      expect(like.destroy).to be_truthy
     end
   end
 end

data/spec/kippt/likes_spec.rb

@@ -3,7 +3,7 @@ require "kippt/likes"
 
 describe Kippt::Likes do
   let(:client) { Kippt::Client.new(valid_user_credentials) }
-  let(:clip) { stub :user, :id => 100, :all_likes_embedded? => false }
+  let(:clip) { double :user, :id => 100, :all_likes_embedded? => false }
   subject { Kippt::Likes.new(client, clip) }
   let(:base_uri) { "clips/#{clip.id}/likes" }
   let(:singular_fixture) { "user" }
@@ -14,8 +14,8 @@ describe Kippt::Likes do
     it "uses only the base_uri" do
       like = double :like
       response = double :response, success?: true
-      client.should_receive(:delete).with("clips/100/likes").and_return(response)
-      subject.destroy_resource(like).should be_true
+      expect(client).to receive(:delete).with("clips/100/likes").and_return(response)
+      expect(subject.destroy_resource(like)).to be_truthy
     end
   end
 end

data/spec/kippt/list_collection_spec.rb

@@ -5,9 +5,10 @@ describe Kippt::ListCollection do
   let(:data_with_multiple_pages) {
     MultiJson.load(fixture("lists_with_multiple_pages.json").read)
   }
-  let(:client) { stub }
+  let(:client) { double(:client) }
   subject { Kippt::ListCollection.new(data, client) }
   let(:subject_with_multiple_pages) { Kippt::ListCollection.new(data_with_multiple_pages, client) }
+  let(:collection_resource_class) { Kippt::Lists }
 
   it_behaves_like "collection"
 end

data/spec/kippt/list_spec.rb

@@ -21,15 +21,15 @@ describe Kippt::List do
   describe "#private?" do
     it "gets data from is_private" do
       list = Kippt::List.new({"is_private" => true}, nil)
-      list.private?.should be_true
+      expect(list.private?).to be_truthy
     end
   end
 
   describe "#collaborators" do
     it "returns the users generated from the data" do
       list = Kippt::List.new({"collaborators" => {"count" => 1, "data" => [json_fixture("user.json")]}}, nil)
-      list.collaborators.size.should eq 1
-      list.collaborators.first.should be_a Kippt::User
+      expect(list.collaborators.size).to eq 1
+      expect(list.collaborators.first).to be_a Kippt::User
     end
   end
 
@@ -39,8 +39,8 @@ describe Kippt::List do
     it "returns the clips for the list" do
       stub_get("/lists/10/clips").
         to_return(:status => 200, :body => fixture("clips.json"))
-      subject.should be_a Kippt::Clips
-      subject.base_uri.should eq "lists/10/clips"
+      expect(subject).to be_a Kippt::Clips
+      expect(subject.base_uri).to eq "lists/10/clips"
     end
   end
 
@@ -49,10 +49,10 @@ describe Kippt::List do
       let(:client) { Kippt::Client.new(valid_user_credentials) }
 
       it "returns value from the response" do
-        response = stub(:success? => true, body: {"following" => false})
-        client.should_receive(:get).with("/api/lists/10/relationship").and_return(response)
+        response = double(:response, :success? => true, body: {"following" => false})
+        expect(client).to receive(:get).with("/api/lists/10/relationship").and_return(response)
         list = Kippt::List.new(json_fixture("list.json"), client)
-        list.following?.should be_false
+        expect(list.following?).to be_falsey
       end
 
       it "makes a request" do
@@ -65,8 +65,8 @@ describe Kippt::List do
 
     context "when request is unsuccessful" do
       it "raises an exception" do
-        response = stub(:success? => false, :body => {"message" => "Weird issue going on."})
-        client.should_receive(:get).with("/api/lists/10/relationship").and_return(response)
+        response = double(:response, :success? => false, :body => {"message" => "Weird issue going on."})
+        expect(client).to receive(:get).with("/api/lists/10/relationship").and_return(response)
         list = Kippt::List.new(json_fixture("list.json"), client)
 
         expect {
@@ -81,10 +81,10 @@ describe Kippt::List do
       let(:client) { Kippt::Client.new(valid_user_credentials) }
 
       it "returns true" do
-        response = stub(:success? => true)
-        client.should_receive(:post).with("/api/lists/10/relationship", :data => {:action => "follow"}).and_return(response)
+        response = double(:response, :success? => true)
+        expect(client).to receive(:post).with("/api/lists/10/relationship", :data => {:action => "follow"}).and_return(response)
         list = Kippt::List.new(json_fixture("list.json"), client)
-        list.follow.should eq true
+        expect(list.follow).to eq true
       end
 
       it "makes a request" do
@@ -98,8 +98,8 @@ describe Kippt::List do
 
     context "when request is unsuccessful" do
       it "raises an exception" do
-        response = stub(:success? => false, :body => {"message" => "Weird issue going on."})
-        client.should_receive(:post).with("/api/lists/10/relationship", :data => {:action => "follow"}).and_return(response)
+        response = double(:response, :success? => false, :body => {"message" => "Weird issue going on."})
+        expect(client).to receive(:post).with("/api/lists/10/relationship", :data => {:action => "follow"}).and_return(response)
         list = Kippt::List.new(json_fixture("list.json"), client)
 
         expect {
@@ -114,10 +114,10 @@ describe Kippt::List do
       let(:client) { Kippt::Client.new(valid_user_credentials) }
 
       it "returns true" do
-        response = stub(:success? => true)
-        client.should_receive(:post).with("/api/lists/10/relationship", :data => {:action => "unfollow"}).and_return(response)
+        response = double(:response, :success? => true)
+        expect(client).to receive(:post).with("/api/lists/10/relationship", :data => {:action => "unfollow"}).and_return(response)
         list = Kippt::List.new(json_fixture("list.json"), client)
-        list.unfollow.should eq true
+        expect(list.unfollow).to eq true
       end
 
       it "makes a request" do
@@ -131,8 +131,8 @@ describe Kippt::List do
 
     context "when request is unsuccessful" do
       it "raises an exception" do
-        response = stub(:success? => false, :body => {"message" => "Weird issue going on."})
-        client.should_receive(:post).with("/api/lists/10/relationship", :data => {:action => "unfollow"}).and_return(response)
+        response = double(:response, :success? => false, :body => {"message" => "Weird issue going on."})
+        expect(client).to receive(:post).with("/api/lists/10/relationship", :data => {:action => "unfollow"}).and_return(response)
         list = Kippt::List.new(json_fixture("list.json"), client)
 
         expect {

data/spec/kippt/lists_spec.rb

@@ -14,11 +14,11 @@ describe Kippt::Lists do
 
   describe "#build" do
     it "returns new resource" do
-      subject.build.should be_a(resource_class)
+      expect(subject.build).to be_a(resource_class)
     end
 
     it "accepts parameters" do
-      subject.object_class.should_receive(:new).with({:an => "attribute"}, client)
+      expect(subject.object_class).to receive(:new).with({:an => "attribute"}, client)
       subject.build(:an => "attribute")
     end
   end

data/spec/kippt/saves_spec.rb

@@ -3,7 +3,7 @@ require "kippt/saves"
 
 describe Kippt::Saves do
   let(:client) { Kippt::Client.new(valid_user_credentials) }
-  let(:clip) { stub :clip, :saves_data => fixture("users.json") }
+  let(:clip) { double :clip, :saves_data => fixture("users.json") }
   subject { Kippt::Saves.new(client, clip) }
 
   describe "#fetch" do
@@ -13,7 +13,7 @@ describe Kippt::Saves do
     end
 
     it "uses the clip saves data" do
-      Kippt::UserCollection.should_receive(:new).with({"objects" => clip.saves_data}, client)
+      expect(Kippt::UserCollection).to receive(:new).with({"objects" => clip.saves_data}, client)
       subject.fetch
     end
   end