koala 1.8.0 → 1.9.0

data/spec/cases/graph_api_spec.rb

@@ -17,21 +17,21 @@ describe 'Koala::Facebook::GraphAPIMethods' do
     # and the other methods which do some post-processing locally
     context '#get_object' do
       it 'returns result of block' do
-        @api.stub(:api).and_return(double("other results"))
-        @api.get_object('koppel', &post_processing)["result"].should == result
+        allow(@api).to receive(:api).and_return(double("other results"))
+        expect(@api.get_object('koppel', &post_processing)["result"]).to eq(result)
       end
     end
 
     context '#get_picture' do
       it 'returns result of block' do
-        @api.stub(:api).and_return("Location" => double("other result"))
-        @api.get_picture('lukeshepard', &post_processing)["result"].should == result
+        allow(@api).to receive(:api).and_return("Location" => double("other result"))
+        expect(@api.get_picture('lukeshepard', &post_processing)["result"]).to eq(result)
       end
     end
 
     context '#fql_multiquery' do
       before do
-        @api.should_receive(:get_object).and_return([
+        expect(@api).to receive(:get_object).and_return([
           {"name" => "query1", "fql_result_set" => [{"id" => 123}]},
           {"name" => "query2", "fql_result_set" => ["id" => 456]}
         ])
@@ -43,18 +43,41 @@ describe 'Koala::Facebook::GraphAPIMethods' do
           'query2' => [{'id' => 456}]
         }
         response = @api.fql_multiquery({}, &post_processing)
-        response["args"].should == resolved_result
-        response["result"].should == result
+        expect(response["args"]).to eq(resolved_result)
+        expect(response["result"]).to eq(result)
       end
     end
 
     context '#get_page_access_token' do
       it 'returns result of block' do
         token = Koala::MockHTTPService::APP_ACCESS_TOKEN
-        @api.stub(:api).and_return("access_token" => token)
+        allow(@api).to receive(:api).and_return("access_token" => token)
         response = @api.get_page_access_token('facebook', &post_processing)
-        response["args"].should == token
-        response["result"].should == result
+        expect(response["args"]).to eq(token)
+        expect(response["result"]).to eq(result)
+      end
+    end
+  end
+
+  context '#graph_call' do
+    describe "the appsecret_proof option" do
+      let(:path) { '/path' }
+
+      it "is enabled by default if an app secret is present" do
+        api = Koala::Facebook::API.new(@token, "mysecret")
+        expect(api).to receive(:api).with(path, {}, 'get', :appsecret_proof => true)
+        api.graph_call(path)
+      end
+
+      it "can be disabled manually" do
+        api = Koala::Facebook::API.new(@token, "mysecret")
+        expect(api).to receive(:api).with(path, {}, 'get', hash_not_including(appsecret_proof: true))
+        api.graph_call(path, {}, "get", appsecret_proof: false)
+      end
+
+      it "isn't included if no app secret is present" do
+        expect(@api).to receive(:api).with(path, {}, 'get', {})
+        @api.graph_call(path)
       end
     end
   end

data/spec/cases/graph_collection_spec.rb

@@ -13,32 +13,32 @@ describe Koala::Facebook::GraphCollection do
   end
 
   it "subclasses Array" do
-    Koala::Facebook::GraphCollection.ancestors.should include(Array)
+    expect(Koala::Facebook::GraphCollection.ancestors).to include(Array)
   end
 
   it "creates an array-like object" do
-    Koala::Facebook::GraphCollection.new(@result, @api).should be_an(Array)
+    expect(Koala::Facebook::GraphCollection.new(@result, @api)).to be_an(Array)
   end
 
   it "contains the result data" do
-    @result["data"].each_with_index {|r, i| @collection[i].should == r}
+    @result["data"].each_with_index {|r, i| expect(@collection[i]).to eq(r)}
   end
 
   it "has a read-only paging attribute" do
-    @collection.methods.map(&:to_sym).should include(:paging)
-    @collection.methods.map(&:to_sym).should_not include(:paging=)
+    expect(@collection.methods.map(&:to_sym)).to include(:paging)
+    expect(@collection.methods.map(&:to_sym)).not_to include(:paging=)
   end
 
   it "sets paging to results['paging']" do
-    @collection.paging.should == @result["paging"]
+    expect(@collection.paging).to eq(@result["paging"])
   end
 
   it "sets raw_response to the original results" do
-    @collection.raw_response.should == @result
+    expect(@collection.raw_response).to eq(@result)
   end
 
   it "sets the API to the provided API" do
-    @collection.api.should == @api
+    expect(@collection.api).to eq(@api)
   end
 
   describe "when getting a whole page" do
@@ -53,24 +53,24 @@ describe Koala::Facebook::GraphCollection do
     end
 
     it "should return the previous page of results" do
-      @collection.should_receive(:previous_page_params).and_return([@base, @args])
-      @api.should_receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-      @collection.previous_page.should == @page_of_results
+      expect(@collection).to receive(:previous_page_params).and_return([@base, @args])
+      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
+      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(@collection.previous_page).to eq(@page_of_results)
     end
 
     it "should return the next page of results" do
-      @collection.should_receive(:next_page_params).and_return([@base, @args])
-      @api.should_receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(@collection).to receive(:next_page_params).and_return([@base, @args])
+      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
+      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
 
-      @collection.next_page.should == @page_of_results
+      expect(@collection.next_page).to eq(@page_of_results)
     end
 
     it "should return nil it there are no other pages" do
       %w{next previous}.each do |this|
-        @collection.should_receive("#{this}_page_params".to_sym).and_return(nil)
-        @collection.send("#{this}_page").should == nil
+        expect(@collection).to receive("#{this}_page_params".to_sym).and_return(nil)
+        expect(@collection.send("#{this}_page")).to eq(nil)
       end
     end
   end
@@ -79,38 +79,38 @@ describe Koala::Facebook::GraphCollection do
     describe "#parse_page_url" do
       it "should pass the url to the class method" do
         url = double("url")
-        Koala::Facebook::GraphCollection.should_receive(:parse_page_url).with(url)
+        expect(Koala::Facebook::GraphCollection).to receive(:parse_page_url).with(url)
         @collection.parse_page_url(url)
       end
 
       it "should return the result of the class method" do
         parsed_content = double("parsed_content")
-        Koala::Facebook::GraphCollection.stub(:parse_page_url).and_return(parsed_content)
-        @collection.parse_page_url(double("url")).should == parsed_content
+        allow(Koala::Facebook::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
+        expect(@collection.parse_page_url(double("url"))).to eq(parsed_content)
       end
     end
 
     describe ".parse_page_url" do
       it "should return the base as the first array entry" do
         base = "url_path"
-        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first.should == base
+        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first).to eq(base)
       end
 
       it "should return the arguments as a hash as the last array entry" do
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last).to eq(args_hash)
       end
 
       it "works with non-.com addresses" do
         base = "url_path"
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").should == [base, args_hash]
+        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}")).to eq([base, args_hash])
       end
 
       it "works with addresses with irregular characters" do
         access_token = "appid123a|fdcba"
         base, args_hash = Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
-        args_hash["token"].should == access_token
+        expect(args_hash["token"]).to eq(access_token)
       end
     end
   end
@@ -118,29 +118,29 @@ describe Koala::Facebook::GraphCollection do
   describe ".evaluate" do
     it "returns the original result if it's provided a non-hash result" do
       result = []
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if it's provided a nil result" do
       result = nil
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if the result doesn't have a data key" do
       result = {"paging" => {}}
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if the result's data key isn't an array" do
       result = {"data" => {}, "paging" => {}}
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
       result = {"data" => [], "paging" => {}}
       expected = :foo
-      Koala::Facebook::GraphCollection.should_receive(:new).with(result, @api).and_return(expected)
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == expected
+      expect(Koala::Facebook::GraphCollection).to receive(:new).with(result, @api).and_return(expected)
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(expected)
     end
   end
 
@@ -148,12 +148,12 @@ describe Koala::Facebook::GraphCollection do
     let(:paging){ {"next" => "http://example.com/?a=2&b=3"} }
 
     it "should get next page" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
       @collection.next_page
     end
 
     it "should get next page with extra parameters" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
       @collection.next_page("c" => "4")
     end
   end
@@ -162,12 +162,12 @@ describe Koala::Facebook::GraphCollection do
     let(:paging){ {"previous" => "http://example.com/?a=2&b=3"} }
 
     it "should get previous page" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
       @collection.previous_page
     end
 
     it "should get previous page with extra parameters" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
       @collection.previous_page("c" => "4")
     end
   end