koala 1.2.1 → 1.3.0rc1

data/spec/spec_helper.rb

@@ -21,6 +21,9 @@ end
 # See https://github.com/tenderlove/psych/issues/8 for more details
 YAML::ENGINE.yamler = 'syck' if RUBY_VERSION == '1.9.2' && RUBY_PATCHLEVEL < 290
 
+# load custom RSpec matchers
+require 'support/custom_matchers'
+
 # load the library
 require 'koala'
 

data/spec/support/custom_matchers.rb

@@ -0,0 +1,28 @@
+# Verifies that two URLs are equal, ignoring the order of the query string parameters
+RSpec::Matchers.define :match_url do |url|
+  match do |original_url|
+    base, query_string = url.split("?")
+    original_base, original_query_string = original_url.split("?")
+    query_hash = query_to_params(query_string)
+    original_query_hash = query_to_params(original_query_string)
+
+    # the base URLs need to match
+    base.should == original_base
+    
+    # the number of parameters should match (avoid one being a subset of the other)
+    query_hash.values.length.should == original_query_hash.values.length
+    
+    # and ensure all the keys and values match
+    query_hash.each_pair do |key, value|
+      original_query_hash[key].should == value
+    end
+  end
+  
+  def query_to_params(query_string)
+    query_string.split("&").inject({}) do |hash, segment|
+      k, v = segment.split("=")
+      hash[k] = v
+      hash
+    end
+  end
+end

data/spec/support/graph_api_shared_examples.rb

@@ -86,7 +86,7 @@ shared_examples_for "Koala GraphAPI" do
   end
 
   it "can access a user's picture" do
-    @api.get_picture("chris.baclig").should =~ /http[s]*\:\/\//
+    @api.get_picture(KoalaTest.user2).should =~ /http[s]*\:\/\//
   end
 
   it "can access a user's picture, given a picture type"  do
@@ -128,6 +128,63 @@ shared_examples_for "Koala GraphAPI" do
     # the results should have an ID and a name, among other things
     (result["id"] && result["name"]).should_not be_nil
   end
+  
+  # FQL  
+  describe "#fql_query" do
+    it "makes a request to /fql" do
+      @api.should_receive(:get_object).with("fql", anything, anything)
+      @api.fql_query stub('query string')
+    end
+
+    it "passes a query argument" do
+      query = stub('query string')
+      @api.should_receive(:get_object).with(anything, hash_including(:q => query), anything)
+      @api.fql_query(query)
+    end
+
+    it "passes on any other arguments provided" do
+      args = {:a => 2}
+      @api.should_receive(:get_object).with(anything, hash_including(args), anything)
+      @api.fql_query("a query", args)
+    end
+  end
+
+  describe "#fql_multiquery" do
+    it "makes a request to /fql" do
+      @api.should_receive(:get_object).with("fql", anything, anything)
+      @api.fql_multiquery 'query string'
+    end
+
+    it "passes a queries argument" do
+      queries = stub('query string')
+      queries_json = "some JSON"
+      MultiJson.stub(:encode).with(queries).and_return(queries_json)
+
+      @api.should_receive(:get_object).with(anything, hash_including(:q => queries_json), anything)
+      @api.fql_multiquery(queries)
+    end
+
+    it "simplifies the response format" do
+      raw_results = [
+        {"name" => "query1", "fql_result_set" => [1, 2, 3]},
+        {"name" => "query2", "fql_result_set" => [:a, :b, :c]}
+      ]
+      expected_results = {
+        "query1" => [1, 2, 3],
+        "query2" => [:a, :b, :c]
+      }
+
+      @api.stub(:get_object).and_return(raw_results)
+      results = @api.fql_multiquery({:query => true})
+      results.should == expected_results
+    end
+
+    it "passes on any other arguments provided" do
+      args = {:a => 2}
+      @api.should_receive(:get_object).with(anything, hash_including(args), anything)
+      @api.fql_multiquery("a query", args)
+    end
+  end
 end
 
 
@@ -211,7 +268,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
   
 
-  describe ".put_picture" do
+  describe "#put_picture" do
     it "can post photos to the user's wall with an open file object" do
       content_type = "image/jpg"
       file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
@@ -264,7 +321,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     end
   end
 
-  describe ".put_video" do
+  describe "#put_video" do
     before :each do
       @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")
       @content_type = "video/mpeg4"
@@ -340,10 +397,90 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   # Page Access Token Support
-  it "gets a page's access token" do
-    # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
-    @api.should_receive(:api).with("my_page", {:fields => "access_token"}, "get", anything)
-    @api.get_page_access_token("my_page")
+  describe "#get_page_access_token" do
+    it "gets the page object with the access_token field" do
+      # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
+      @api.should_receive(:api).with("my_page", hash_including({:fields => "access_token"}), "get", anything)
+      @api.get_page_access_token("my_page")
+    end
+    
+    it "merges in any other arguments" do
+      # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
+      args = {:a => 3}
+      @api.should_receive(:api).with("my_page", hash_including(args), "get", anything)
+      @api.get_page_access_token("my_page", args)
+    end    
+  end
+
+  describe "#set_app_restrictions" do
+    before :all do
+      oauth = Koala::Facebook::OAuth.new(KoalaTest.app_id, KoalaTest.secret)
+      app_token = oauth.get_app_access_token
+      @app_api = Koala::Facebook::API.new(app_token)
+      @restrictions = {"age_distr" => "13+"}
+    end
+
+    it "makes a POST to /app_id" do
+      @app_api.should_receive(:graph_call).with(KoalaTest.app_id, anything, "post", anything)
+      @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)
+    end
+    
+    it "JSON-encodes the restrictions" do
+      @app_api.should_receive(:graph_call).with(anything, hash_including(:restrictions => MultiJson.encode(@restrictions)), anything, anything)
+      @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)
+    end
+    
+    it "includes the other arguments" do
+      args = {:a => 2}
+      @app_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
+      @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions, args)
+    end
+    
+    it "works" do
+      @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions).should be_true
+    end
+  end
+
+  it "can access public information via FQL" do
+    result = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
+    result.size.should == 1
+    result.first['first_name'].should == KoalaTest.user2_name
+  end
+
+  it "can access public information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => "select first_name from user where uid = #{KoalaTest.user2_id}",
+      :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
+    )
+    result.size.should == 2
+    result["query1"].first['first_name'].should == KoalaTest.user2_name
+    result["query2"].first['first_name'].should == KoalaTest.user1_name
+  end
+
+  it "can access protected information via FQL" do
+    # Tests agains the permissions fql table
+
+    # get the current user's ID
+    # we're sneakily using the Graph API, which should be okay since it has its own tests
+    g = Koala::Facebook::API.new(@token)
+    id = g.get_object("me", :fields => "id")["id"]
+
+    # now send a query about your permissions
+    result = @api.fql_query("select read_stream from permissions where uid = #{id}")
+
+    result.size.should == 1
+    # we've verified that you have read_stream permissions, so we can test against that
+    result.first["read_stream"].should == 1
+  end
+
+  it "can access protected information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => "select post_id from stream where source_id = me()",
+      :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
+      :query3 => "select uid, name from user where uid in (select fromid from #query2)"
+    )
+    result.size.should == 3
+    result.keys.should include("query1", "query2", "query3")
   end
 
   # test all methods to make sure they pass data through to the API
@@ -363,7 +500,11 @@ shared_examples_for "Koala GraphAPI with an access token" do
       :put_comment => 3,
       :put_like => 2, :delete_like => 2,
       :search => 3,
+      :set_app_restrictions => 4,
+      :get_page_access_token => 3,
+      :fql_query => 3, :fql_multiquery => 3,
       # methods that have special arguments
+      :get_comments_for_urls => [["url1", "url2"], {}],
       :put_picture => ["x.jpg", "image/jpg", {}, "me"],
       :put_video => ["x.mp4", "video/mpeg4", {}, "me"],
       :get_objects => [["x"], {}]
@@ -433,9 +574,8 @@ end
 
 
 shared_examples_for "Koala GraphAPI without an access token" do
-
   it "can't get private data about a user" do
-    result = @api.get_object("koppel")
+    result = @api.get_object(KoalaTest.user1)
     # updated_time should be a pretty fixed test case
     result["updated_time"].should be_nil
   end
@@ -445,11 +585,11 @@ shared_examples_for "Koala GraphAPI without an access token" do
   end
 
   it "can't access connections from users" do
-    lambda { @api.get_connections("lukeshepard", "friends") }.should raise_error(Koala::Facebook::APIError)
+    lambda { @api.get_connections(KoalaTest.user2, "friends") }.should raise_error(Koala::Facebook::APIError)
   end
 
   it "can't put an object" do
-    lambda { @result = @api.put_object("lukeshepard", "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
+    lambda { @result = @api.put_object(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
   end
 
   # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
@@ -478,4 +618,37 @@ shared_examples_for "Koala GraphAPI without an access token" do
   it "can't delete a like" do
     lambda { @api.delete_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::APIError)
   end
+  
+  # FQL_QUERY
+  describe "when making a FQL request" do
+    it "can access public information via FQL" do
+      result = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
+      result.size.should == 1
+      result.first['first_name'].should == KoalaTest.user2_name
+    end
+
+    it "can access public information via FQL.multiquery" do
+      result = @api.fql_multiquery(
+        :query1 => "select first_name from user where uid = #{KoalaTest.user2_id}",
+        :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
+      )
+      result.size.should == 2
+      result["query1"].first['first_name'].should == KoalaTest.user2_name
+      result["query2"].first['first_name'].should == KoalaTest.user1_name
+    end
+
+    it "can't access protected information via FQL" do
+      lambda { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.should raise_error(Koala::Facebook::APIError)
+    end
+
+    it "can't access protected information via FQL.multiquery" do
+      lambda {
+        @api.fql_multiquery(
+          :query1 => "select post_id from stream where source_id = me()",
+          :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
+          :query3 => "select uid, name from user where uid in (select fromid from #query2)"
+        )
+      }.should raise_error(Koala::Facebook::APIError)
+    end
+  end
 end

data/spec/support/koala_test.rb

@@ -4,6 +4,7 @@ module KoalaTest
   class << self
     attr_accessor :oauth_token, :app_id, :secret, :app_access_token, :code, :session_key
     attr_accessor :oauth_test_data, :subscription_test_data, :search_time
+    attr_accessor :test_user_api
   end
     
   # Test setup
@@ -159,10 +160,13 @@ module KoalaTest
 
   # Data for testing
   def self.user1
+    # user ID, either numeric or username
     test_user? ? @live_testing_user["id"] : "koppel"
   end
 
   def self.user1_id
+    # numerical ID, used for FQL
+    # (otherwise the two IDs are interchangeable)
     test_user? ? @live_testing_user["id"] : 2905623
   end
 
@@ -171,10 +175,12 @@ module KoalaTest
   end
 
   def self.user2
+    # see notes for user1
     test_user? ? @live_testing_friend["id"] : "lukeshepard"
   end
 
   def self.user2_id
+    # see notes for user1
     test_user? ? @live_testing_friend["id"] : 2901279
   end
 
@@ -186,4 +192,7 @@ module KoalaTest
     "contextoptional"
   end
 
+  def self.app_properties
+    mock_interface? ? {"desktop" => 0} : {"description" => "A test framework for Koala and its users.  (#{rand(10000).to_i})"}
+  end
 end

data/spec/support/rest_api_shared_examples.rb

@@ -113,144 +113,17 @@ shared_examples_for "Koala RestAPI" do
 
     it "throws an APIError if the result hash has an error key" do
       Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error_code" => "An error occurred!"}, {}))
-      lambda { @api.rest_call("koppel", {}) }.should raise_exception(Koala::Facebook::APIError)
-    end
-
-    describe "when making a FQL request" do
-      it "calls fql.query method" do
-        @api.should_receive(:rest_call).with(
-          "fql.query", anything, anything
-        ).and_return(Koala::Response.new(200, "2", {}))
-
-        @api.fql_query stub('query string')
-      end
-
-      it "passes a query argument" do
-        query = stub('query string')
-
-        @api.should_receive(:rest_call).with(
-          anything, hash_including(:query => query), anything
-        )
-
-        @api.fql_query(query)
-      end
-
-      it "passes on any other arguments provided" do
-        args = {:a => 2}
-        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
-        @api.fql_query("a query", args)
-      end
-
-      it "passes on any http options provided" do
-        opts = {:a => 2}
-        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
-        @api.fql_query("a query", {}, opts)
-      end
-    end
-
-    describe "when making a FQL-multiquery request" do
-      it "calls fql.multiquery method" do
-        @api.should_receive(:rest_call).with(
-          "fql.multiquery", anything, anything
-        ).and_return({})
-
-        @api.fql_multiquery 'query string'
-      end
-
-      it "passes a queries argument" do
-        queries = stub('query string')
-        queries_json = "some JSON"
-        MultiJson.stub(:encode).with(queries).and_return(queries_json)
-
-        @api.should_receive(:rest_call).with(
-          anything,
-          hash_including(:queries => queries_json),
-          anything
-        )
-
-        @api.fql_multiquery(queries)
-      end
-
-      it "simplifies the response format" do
-        raw_results = [
-          {"name" => "query1", "fql_result_set" => [1, 2, 3]},
-          {"name" => "query2", "fql_result_set" => [:a, :b, :c]}
-        ]
-        expected_results = {
-          "query1" => [1, 2, 3],
-          "query2" => [:a, :b, :c]
-        }
-
-        @api.stub(:rest_call).and_return(raw_results)
-        results = @api.fql_multiquery({:query => true})
-        results.should == expected_results
-      end
-
-      it "passes on any other arguments provided" do
-        args = {:a => 2}
-        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
-        @api.fql_multiquery("a query", args)
-      end
-
-      it "passes on any http options provided" do
-        opts = {:a => 2}
-        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
-        @api.fql_multiquery("a query", {}, opts)
-      end
+      lambda { @api.rest_call(KoalaTest.user1, {}) }.should raise_exception(Koala::Facebook::APIError)
     end
   end
 
   it "can use the beta tier" do
-    @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}", {}, :beta => true)
+    @api.rest_call("fql.query", {:query => "select first_name from user where uid = #{KoalaTest.user2_id}"}, :beta => true)
   end
 end
 
 shared_examples_for "Koala RestAPI with an access token" do
-  # FQL
-  it "can access public information via FQL" do
-    result = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
-    result.size.should == 1
-    result.first['first_name'].should == KoalaTest.user2_name
-  end
-
-  it "can access public information via FQL.multiquery" do
-    result = @api.fql_multiquery(
-      :query1 => "select first_name from user where uid = #{KoalaTest.user2_id}",
-      :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
-    )
-    result.size.should == 2
-    result["query1"].first['first_name'].should == KoalaTest.user2_name
-    result["query2"].first['first_name'].should == KoalaTest.user1_name
-  end
-
-  it "can access protected information via FQL" do
-    # Tests agains the permissions fql table
-
-    # get the current user's ID
-    # we're sneakily using the Graph API, which should be okay since it has its own tests
-    g = Koala::Facebook::API.new(@token)
-    id = g.get_object("me", :fields => "id")["id"]
-
-    # now send a query about your permissions
-    result = @api.fql_query("select read_stream from permissions where uid = #{id}")
-
-    result.size.should == 1
-    # we've verified that you have read_stream permissions, so we can test against that
-    result.first["read_stream"].should == 1
-  end
-
-  it "can access protected information via FQL.multiquery" do
-    result = @api.fql_multiquery(
-      :query1 => "select post_id from stream where source_id = me()",
-      :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
-      :query3 => "select uid, name from user where uid in (select fromid from #query2)"
-    )
-    result.size.should == 3
-    result.keys.should include("query1", "query2", "query3")
-  end
-  
-  
-  describe ".set_app_properties" do
+  describe "#set_app_properties" do
     it "sends Facebook the properties JSON-encoded as :properties" do
       props = {:a => 2, :c => [1, 2, "d"]}
       @api.should_receive(:rest_call).with(anything, hash_including(:properties => MultiJson.encode(props)), anything, anything)
@@ -283,46 +156,13 @@ shared_examples_for "Koala RestAPI with an access token" do
       oauth = Koala::Facebook::OAuth.new(KoalaTest.app_id, KoalaTest.secret)
       app_token = oauth.get_app_access_token
       @app_api = Koala::Facebook::API.new(app_token)
-      @app_api.set_app_properties(:desktop => 0).should be_true
+      @app_api.set_app_properties(KoalaTest.app_properties).should be_true
     end
   end
 end
 
 
 shared_examples_for "Koala RestAPI without an access token" do
-  # FQL_QUERY
-  describe "when making a FQL request" do
-    it "can access public information via FQL" do
-      result = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
-      result.size.should == 1
-      result.first['first_name'].should == KoalaTest.user2_name
-    end
-
-    it "can access public information via FQL.multiquery" do
-      result = @api.fql_multiquery(
-        :query1 => "select first_name from user where uid = #{KoalaTest.user2_id}",
-        :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
-      )
-      result.size.should == 2
-      result["query1"].first['first_name'].should == KoalaTest.user2_name
-      result["query2"].first['first_name'].should == KoalaTest.user1_name
-    end
-
-    it "can't access protected information via FQL" do
-      lambda { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.should raise_error(Koala::Facebook::APIError)
-    end
-
-    it "can't access protected information via FQL.multiquery" do
-      lambda {
-        @api.fql_multiquery(
-          :query1 => "select post_id from stream where source_id = me()",
-          :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
-          :query3 => "select uid, name from user where uid in (select fromid from #query2)"
-        )
-      }.should raise_error(Koala::Facebook::APIError)
-    end
-  end
-  
   it "can't use set_app_properties" do
     lambda { @api.set_app_properties(:desktop => 0) }.should raise_error(Koala::Facebook::APIError)
   end