koala 1.2.0beta1 → 1.2.0

data/spec/cases/graph_collection_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Koala::Facebook::GraphCollection do
+  before(:each) do
+    @result = {
+      "data" => [1, 2, :three],
+      "paging" => {:paging => true}
+    }
+    @api = Koala::Facebook::API.new("123")
+    @collection = Koala::Facebook::GraphCollection.new(@result, @api)
+  end
+
+  it "subclasses Array" do
+    Koala::Facebook::GraphCollection.ancestors.should include(Array)
+  end
+  
+  it "creates an array-like object" do
+    Koala::Facebook::GraphCollection.new(@result, @api).should be_an(Array)
+  end
+  
+  it "contains the result data" do
+    @result["data"].each_with_index {|r, i| @collection[i].should == 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=)
+  end
+  
+  it "sets paging to results['paging']" do
+    @collection.paging.should == @result["paging"]
+  end
+  
+  it "sets raw_response to the original results" do
+    @collection.raw_response.should == @result
+  end
+  
+  it "sets the API to the provided API" do
+    @collection.api.should == @api
+  end
+    
+  describe "when getting a whole page" do
+    before(:each) do
+      @second_page = {
+        "data" => [:second, :page, :data],
+        "paging" => {}
+      }
+      @base = stub("base")
+      @args = stub("args")
+      @page_of_results = stub("page of results")
+    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
+    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)
+
+      @collection.next_page.should == @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
+      end
+    end
+  end
+
+  describe "when parsing page paramters" do
+    it "should return the base as the first array entry" do
+      base = "url_path"
+      @collection.parse_page_url("anything.com/#{base}?anything").first.should == base
+    end
+
+    it "should return the arguments as a hash as the last array entry" do
+      args_hash = {"one" => "val_one", "two" => "val_two"}
+      @collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+    end
+  end
+
+  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
+    end
+    
+    it "returns the original result if it's provided a nil result" do
+      result = nil
+      Koala::Facebook::GraphCollection.evaluate(result, @api).should == 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
+    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
+    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
+    end
+  end
+end

data/spec/cases/koala_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe "Koala" do
+  it "has a version" do
+    Koala.const_defined?("VERSION").should be_true
+  end
+  
   it "has an http_service accessor" do
     Koala.should respond_to(:http_service)
     Koala.should respond_to(:http_service=)
@@ -35,14 +39,14 @@ describe "Koala" do
     end
   end
 
-  define "make_request" do
+  describe "make_request" do
     it "passes all its arguments to the http_service" do
-      http_service = stub("http_service")
       path = "foo"
       args = {:a => 2}
       verb = "get"
       options = {:c => :d}
-      http_service.should_receive(:make_request).with(path, args, verb, options)
+      
+      Koala.http_service.should_receive(:make_request).with(path, args, verb, options)
       Koala.make_request(path, args, verb, options)
     end
   end

data/spec/cases/oauth_spec.rb

@@ -53,40 +53,107 @@ describe "Koala::Facebook::OAuth" do
 
   describe "for cookie parsing" do
     describe "get_user_info_from_cookies" do
-      it "should properly parse valid cookies" do
-        result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["valid_cookies"])
-        result.should be_a(Hash)
-      end
+      context "for signed cookies" do
+        before :each do
+          # we don't actually want to make requests to Facebook to redeem the code
+          @cookie = KoalaTest.oauth_test_data["valid_signed_cookies"]
+          @token = "my token"
+          @oauth.stub(:get_access_token_info).and_return("access_token" => @token)
+        end
+        
+        it "parses valid cookies" do
+          result = @oauth.get_user_info_from_cookies(@cookie)
+          result.should be_a(Hash)
+        end
 
-      it "should return all the cookie components from valid cookie string" do
-        cookie_data = KoalaTest.oauth_test_data["valid_cookies"]
-        parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
-        number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
-        parsing_results.length.should == number_of_components
-      end
+        it "returns all the components in the signed request" do
+          result = @oauth.get_user_info_from_cookies(@cookie)
+          @oauth.parse_signed_request(@cookie.values.first).each_pair do |k, v|
+            result[k].should == v
+          end          
+        end
+        
+        it "makes a request to Facebook to redeem the code if present" do
+          code = "foo"
+          @oauth.stub(:parse_signed_request).and_return({"code" => code})
+          @oauth.should_receive(:get_access_token_info).with(code, anything)
+          @oauth.get_user_info_from_cookies(@cookie)
+        end
 
-      it "should properly parse valid offline access cookies (e.g. no expiration)" do
-        result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["offline_access_cookies"])
-        result["uid"].should
-      end
+        it "sets the code redemption redirect_uri to ''" do
+          @oauth.should_receive(:get_access_token_info).with(anything, :redirect_uri => '')
+          @oauth.get_user_info_from_cookies(@cookie)
+        end
 
-      it "should return all the cookie components from offline access cookies" do
-        cookie_data = KoalaTest.oauth_test_data["offline_access_cookies"]
-        parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
-        number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
-        parsing_results.length.should == number_of_components
+        context "if the code is missing" do
+          it "doesn't make a request to Facebook" do
+            @oauth.stub(:parse_signed_request).and_return({})
+            @oauth.should_receive(:get_access_token_info).never
+            @oauth.get_user_info_from_cookies(@cookie)
+          end
+
+          it "returns nil" do
+            @oauth.stub(:parse_signed_request).and_return({})
+            @oauth.get_user_info_from_cookies(@cookie).should be_nil
+          end
+        end
+        
+        context "if the code is present" do
+          it "adds the access_token into the hash" do
+            @oauth.get_user_info_from_cookies(@cookie)["access_token"].should == @token
+          end
+          
+          it "returns nil if the call to FB fails" do
+            @oauth.stub(:get_access_token_info).and_return(nil)
+            @oauth.get_user_info_from_cookies(@cookie).should be_nil
+          end
+        end
+        
+        it "shouldn't parse invalid cookies" do
+          # make an invalid string by replacing some values
+          bad_cookie_hash = @cookie.inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
+          result = @oauth.get_user_info_from_cookies(bad_cookie_hash)
+          result.should be_nil
+        end
       end
+      
+      context "for unsigned cookies" do
+        it "should properly parse valid cookies" do
+          result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["valid_cookies"])
+          result.should be_a(Hash)
+        end
 
-      it "shouldn't parse expired cookies" do
-        result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["expired_cookies"])
-        result.should be_nil
-      end
+        it "should return all the cookie components from valid cookie string" do
+          cookie_data = KoalaTest.oauth_test_data["valid_cookies"]
+          parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
+          number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
+          parsing_results.length.should == number_of_components
+        end
 
-      it "shouldn't parse invalid cookies" do
-        # make an invalid string by replacing some values
-        bad_cookie_hash = KoalaTest.oauth_test_data["valid_cookies"].inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
-        result = @oauth.get_user_info_from_cookies(bad_cookie_hash)
-        result.should be_nil
+        it "should properly parse valid offline access cookies (e.g. no expiration)" do
+          result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["offline_access_cookies"])
+          result["uid"].should
+        end
+
+        it "should return all the cookie components from offline access cookies" do
+          cookie_data = KoalaTest.oauth_test_data["offline_access_cookies"]
+          parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
+          number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
+          parsing_results.length.should == number_of_components
+        end
+
+        it "shouldn't parse expired cookies" do
+          new_time = @time.to_i * 2
+          @time.stub(:to_i).and_return(new_time)          
+          @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["valid_cookies"]).should be_nil
+        end
+
+        it "shouldn't parse invalid cookies" do
+          # make an invalid string by replacing some values
+          bad_cookie_hash = KoalaTest.oauth_test_data["valid_cookies"].inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
+          result = @oauth.get_user_info_from_cookies(bad_cookie_hash)
+          result.should be_nil
+        end
       end
     end
 
@@ -179,8 +246,24 @@ describe "Koala::Facebook::OAuth" do
   end
 
   describe "for fetching access tokens" do
-    if KoalaTest.code
-      describe "get_access_token_info" do
+    describe ".get_access_token_info" do
+      it "uses options[:redirect_uri] if provided" do
+        uri = "foo"
+        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => uri), anything, anything).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_access_token_info(@code, :redirect_uri => uri)
+      end
+      
+      it "uses the redirect_uri used to create the @oauth if no :redirect_uri option is provided" do
+        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => @callback_url), anything, anything).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_access_token_info(@code)        
+      end
+      
+      it "makes a GET request" do
+        Koala.should_receive(:make_request).with(anything, anything, "get", anything).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_access_token_info(@code)                
+      end
+
+      if KoalaTest.code
         it "should properly get and parse an access token token results into a hash" do
           result = @oauth.get_access_token_info(@code)
           result.should be_a(Hash)
@@ -190,36 +273,40 @@ describe "Koala::Facebook::OAuth" do
           result = @oauth.get_access_token_info(@code)
           result["access_token"].should
         end
-
         it "should raise an error when get_access_token is called with a bad code" do
           lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::APIError)
         end
       end
+    end
+    
+    describe ".get_access_token" do
+      # TODO refactor these to be proper tests with stubs and tests against real data
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_access_token(@code, options)
+      end
 
-      describe "get_access_token" do
-        it "should use get_access_token_info to get and parse an access token token results" do
+      if KoalaTest.code
+        it "uses get_access_token_info to get and parse an access token token results" do
           result = @oauth.get_access_token(@code)
           result.should be_a(String)
         end
 
-        it "should return the access token as a string" do
+        it "returns the access token as a string" do
           result = @oauth.get_access_token(@code)
           original = @oauth.get_access_token_info(@code)
           result.should == original["access_token"]
         end
 
-        it "should raise an error when get_access_token is called with a bad code" do
+        it "raises an error when get_access_token is called with a bad code" do
           lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::APIError)
         end
-
-        it "should pass on any options provided to make_request" do
-          options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
-          @oauth.get_access_token(@code, options)
-        end
       end
-    else
-      it "OAuth code tests will not be run since the code field in facebook_data.yml is blank."
+    end
+    
+    unless KoalaTest.code
+      it "Some OAuth code tests will not be run since the code field in facebook_data.yml is blank."
     end
 
     describe "get_app_access_token_info" do

data/spec/cases/test_users_spec.rb

@@ -13,6 +13,13 @@ describe "Koala::Facebook::TestUsers" do
         raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
       end
     end
+    
+    after :each do
+      # clean up any test users
+      ((@network || []) + [@user1, @user2]).each do |u|
+        puts "Unable to delete test user #{u.inspect}" if u && (!@test_users.delete(u) rescue false)
+      end
+    end
 
     describe "when initializing" do
       # basic initialization
@@ -131,11 +138,6 @@ describe "Koala::Facebook::TestUsers" do
           @user2 = @test_users.create(true, "read_stream,user_interests")
         end
 
-        after :each do
-          @test_users.delete(@user1) if @user1
-          @test_users.delete(@user2) if @user2
-        end
-
         it "should delete a user by id" do
           @test_users.delete(@user1['id']).should be_true
           @user1 = nil
@@ -191,11 +193,6 @@ describe "Koala::Facebook::TestUsers" do
           @user2 = @test_users.create(true, "read_stream,user_interests")
         end
 
-        after :each do
-          @test_users.delete(@user1)
-          @test_users.delete(@user2)
-        end
-
         it "should list test users" do
           result = @test_users.list
           result.should be_an(Array)
@@ -243,16 +240,6 @@ describe "Koala::Facebook::TestUsers" do
       end
 
       describe "tests that create users" do
-        before :each do
-          test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
-          test_users.delete_all
-        end
-
-        after :each do
-          test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
-          test_users.delete_all
-        end
-
         it "should create a 5 person network" do
           size = 5
           @network = @test_users.create_network(size)
@@ -261,10 +248,11 @@ describe "Koala::Facebook::TestUsers" do
         end
       end
 
-      it "should limit to a 50 person network" do
-        @test_users.should_receive(:create).exactly(50).times
+      it "has no built-in network size limit" do
+        times = 100
+        @test_users.should_receive(:create).exactly(times).times
         @test_users.stub!(:befriend)
-        @network = @test_users.create_network(51)
+        @network = @test_users.create_network(times)
       end
 
       it "should pass on the installed and permissions parameters to create" do

data/spec/cases/uploadable_io_spec.rb

@@ -86,6 +86,34 @@ describe "Koala::UploadableIO" do
       end
     end
 
+    describe "when given an IO object" do
+      before(:each) do
+        @io = StringIO.open("abcdefgh")
+        @koala_io_params = [@io]
+      end
+
+      describe "and a content type" do
+        before :each do
+          @koala_io_params.concat(["image/jpg"])
+        end
+
+        it "returns an UploadableIO with the same io" do
+          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @koala_io_params[0]
+        end
+
+        it "returns an UploadableIO with the same content_type" do
+          content_stub = @koala_io_params[1] = stub('Content Type')
+          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+        end
+      end
+
+      describe "and no content type" do
+        it "raises an exception" do
+          lambda { Koala::UploadableIO.new(*@koala_io_params) }.should raise_exception(Koala::KoalaError)
+        end
+      end
+    end
+
     describe "when given a Rails 3 ActionDispatch::Http::UploadedFile" do
       before(:each) do
         @tempfile, @uploaded_file = rails_3_mocks

data/spec/fixtures/facebook_data.yml

@@ -30,11 +30,12 @@ oauth_test_data:
     # note: the tests stub the time class so these default cookies are always valid (if you're using the default app)
     # if not you may want to remove the stubbing to test expiration
     fbs_119908831367602: '"access_token=119908831367602|2.LKE7ksSPOx0V_8mHPr2NHQ__.3600.1273363200-2905623|CMpi0AYbn03Oukzv94AUha2qbO4.&expires=1273363200&secret=lT_9zm5r5IbJ6Aa5O54nFw__&session_key=2.LKE7ksSPOx0V_8mHPr2NHQ__.3600.1273363200-2905623&sig=9515e93113921f9476a4efbdd4a3c746&uid=2905623"'
-  expired_cookies:
-    fbs_119908831367602: '"access_token=119908831367602|2.xv9mi6QSOpr474s4n2X_pw__.3600.1273287600-2905623|yVt5WH_S6J5p3gFa5_5lBzckhws.&expires=1273287600&secret=V_E79ovQnXqxGctFuC_n5A__&session_key=2.xv9mi6QSOpr474s4n2X_pw__.3600.1273287600-2905623&sig=eeef60838c0c800258d89b7e6ddddddb&uid=2905623"'
   offline_access_cookies:
     # note: I've revoked the offline access for security reasons, so you can't make calls against this :)
     fbs_119908831367602: '"access_token=119908831367602|08170230801eb225068e7a70-2905623|Q3LDCYYF8CX9cstxnZLsxiR0nwg.&expires=0&secret=78abaee300b392e275072a9f2727d436&session_key=08170230801eb225068e7a70-2905623&sig=423b8aa4b6fa1f9a571955f8e929d567&uid=2905623"'
+  valid_signed_cookies: 
+    "fbsr_119908831367602": "f1--LHwjHVCxfs97hRHL-4cF-0jNxZRc6MGzo1qHLb0.eyJhbGdvcml0aG0iOiJITUFDLVNIQTI1NiIsImNvZGUiOiIyLkFRQm90a0pBWlhVY1l3RkMuMzYwMC4xMzE0ODEzNjAwLjEtMjkwNTYyM3x4V2xya0d0UmJIZlpIclRnVWwxQmxJcVhRbjQiLCJpc3N1ZWRfYXQiOjEzMTQ4MDY2NTUsInVzZXJfaWQiOiIyOTA1NjIzIn0"
+
 
   # These values from the OAuth Playground (see above) will work out of the box
   # You can update this to live data if desired

data/spec/fixtures/mock_facebook_responses.yml

@@ -87,10 +87,10 @@ graph_api:
         with_token: '[{"headers":[{"name":"Location","value":"http://google.com"}]}]'
     batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "me/friends"}]) %>:
       post:
-        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[]}"}]'
+        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[],\"paging\":{}}"}]'
     batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me"}, {"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
       post:
-        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[]}"}]'
+        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[],\"paging\":{}}"}]'
     batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights"}, {"method"=>"get", "relative_url"=>"koppel?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},{"body":"{\"id\":\"123\"}"}]'
@@ -113,7 +113,7 @@ graph_api:
         with_token: '[null,{"body":"{}"}]'
     batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends", "omit_response_on_success" => false}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
       post:
-        with_token: '[{"body":"{\"data\":[]}"},{"body":"{}"}]'
+        with_token: '[{"body":"{\"data\":[],\"paging\":{}}"},{"body":"{}"}]'
     batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=i-dont-exist:$.data.*.id}"}"}]) %>:
       post:
         with_token: '{"error":190,"error_description":"Error validating access token."}'
@@ -211,7 +211,7 @@ graph_api:
     no_args:
       get:
         <<: *token_required
-        with_token: '{"data": [{}]}'
+        with_token: '{"data": [{}], "paging": {}}'
 
   /lukeshepard/picture:
     type=large:
@@ -261,7 +261,7 @@ graph_api:
       get:
         with_token: '{"data": [{"id": "507731521_100412693339488"}], "paging": {"previous": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000", "next": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000"}}'
         no_token: '{"data": [{"id": "507731521_100412693339488"}], "paging": {"previous": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000", "next": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000"}}'
-    "limit=25&q=facebook&until=2010-09-23T21:17:33+0000":
+    "limit=25&q=facebook&until=<%= TEST_DATA['search_time'] %>":
       get:
         with_token: '{"data": [{"id": "507731521_100412693339488"}], "paging": {"previous": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000", "next": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000"}}'
         no_token: '{"data": [{"id": "507731521_100412693339488"}], "paging": {"previous": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000", "next": "https:\/\/graph.facebook.com\/7204941866\/photos?limit=25&until=2008-09-15T18%3A30%3A25%2B0000"}}'

data/spec/support/graph_api_shared_examples.rb

@@ -17,9 +17,7 @@ shared_examples_for "Koala GraphAPI" do
   describe "graph_call" do
     it "should pass all arguments to the api method" do
       args = [KoalaTest.user1, {}, "get", {:a => :b}]
-
       @api.should_receive(:api).with(*args)
-
       @api.graph_call(*args)
     end
 
@@ -27,6 +25,27 @@ shared_examples_for "Koala GraphAPI" do
       Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error" => "An error occurred!"}, {}))
       lambda { @api.graph_call(KoalaTest.user1, {}) }.should raise_exception(Koala::Facebook::APIError)
     end
+    
+    it "passes the results through GraphCollection.evaluate" do
+      result = {}
+      @api.stub(:api).and_return(result)
+      Koala::Facebook::GraphCollection.should_receive(:evaluate).with(result, @api)
+      @api.graph_call("/me")
+    end
+    
+    it "returns the results of GraphCollection.evaluate" do
+      expected = {}
+      @api.stub(:api).and_return([])
+      Koala::Facebook::GraphCollection.should_receive(:evaluate).and_return(expected)
+      @api.graph_call("/me").should == expected
+    end
+    
+    it "returns the post_processing block's results if one is supplied" do
+      other_result = [:a, 2, :three]
+      block = Proc.new {|r| other_result}
+      @api.stub(:api).and_return({})
+      @api.graph_call("/me", {}, "get", {}, &block).should == other_result
+    end 
   end
 
   # SEARCH
@@ -349,12 +368,6 @@ end
 
 # GraphCollection
 shared_examples_for "Koala GraphAPI with GraphCollection" do
-
-  it "should create an array-like object" do
-    call = @api.graph_call("contextoptional/photos")
-    Koala::Facebook::GraphCollection.new(call, @api).should be_an(Array)
-  end
-
   describe "when getting a collection" do
     # GraphCollection methods
     it "should get a GraphCollection when getting connections" do
@@ -380,74 +393,14 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
     end
 
     it "should get a GraphCollection when paging through results" do
-      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}])
+      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])
       @results.should be_a(Koala::Facebook::GraphCollection)
     end
 
     it "should return nil if the page call fails with nil" do
       # this happens sometimes
       @api.should_receive(:graph_call).and_return(nil)
-      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}]).should be_nil
-    end
-
-    # GraphCollection attributes
-    describe "the GraphCollection" do
-      before(:each) do
-        @result = @api.get_connections(KoalaTest.page, "photos")
-      end
-
-      it "should have a read-only paging attribute" do
-        @result.methods.map(&:to_sym).should include(:paging)
-        @result.methods.map(&:to_sym).should_not include(:paging=)
-      end
-
-      describe "when getting a whole page" do
-        before(:each) do
-          @second_page = stub("page of Fb graph results")
-          @base = stub("base")
-          @args = stub("args")
-          @page_of_results = stub("page of results")
-        end
-
-        it "should return the previous page of results" do
-          @result.should_receive(:previous_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-
-          @result.previous_page#.should == @page_of_results
-        end
-
-        it "should return the next page of results" do
-          @result.should_receive(:next_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-
-          @result.next_page#.should == @page_of_results
-        end
-
-        it "should return nil it there are no other pages" do
-          %w{next previous}.each do |this|
-            @result.should_receive("#{this}_page_params".to_sym).and_return(nil)
-            @result.send("#{this}_page").should == nil
-          end
-        end
-      end
-
-      describe "when parsing page paramters" do
-        before(:each) do
-          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::API.new)
-        end
-
-        it "should return the base as the first array entry" do
-          base = "url_path"
-          @graph_collection.parse_page_url("anything.com/#{base}?anything").first.should == base
-        end
-
-        it "should return the arguments as a hash as the last array entry" do
-          args_hash = {"one" => "val_one", "two" => "val_two"}
-          @graph_collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
-        end
-      end
+      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}]).should be_nil
     end
   end
 end