koala 0.9.0 → 1.0.0.beta

data/spec/koala/oauth/oauth_tests.rb

@@ -1,14 +1,3 @@
-# stub the Time class to always return a time for which the valid cookie is still valid
-class Time
-  def self.now
-    self
-  end
-  
-  def self.to_i
-    1273363199
-  end
-end
-
 class FacebookOAuthTests < Test::Unit::TestCase
   describe "Koala OAuth tests" do
     before :each do
@@ -27,6 +16,10 @@ class FacebookOAuthTests < Test::Unit::TestCase
       @request_secret = @oauth_data["request_secret"] || @secret 
       @signed_request = @oauth_data["signed_request"]
       @signed_request_result = @oauth_data["signed_request_result"]
+      # for signed requests (http://developers.facebook.com/docs/authentication/canvas/encryption_proposal)
+      @signed_params_secret = @oauth_data["signed_params_secret"] || @secret 
+      @signed_params = @oauth_data["signed_params"]
+      @signed_params_result = @oauth_data["signed_params_result"]
       
       # this should expanded to cover all variables
       raise Exception, "Must supply app data to run FacebookOAuthTests!" unless @app_id && @secret && @callback_url && 
@@ -34,6 +27,10 @@ class FacebookOAuthTests < Test::Unit::TestCase
                                                                                 @raw_offline_access_token_string
 
       @oauth = Koala::Facebook::OAuth.new(@app_id, @secret, @callback_url)
+
+      @time = Time.now
+      Time.stub!(:now).and_return(@time)
+      @time.stub!(:to_i).and_return(1273363199)
     end
     
     # initialization
@@ -298,6 +295,11 @@ class FacebookOAuthTests < Test::Unit::TestCase
           # it should return nil for each of the invalid ones
           result.each_with_index {|r, index| index > 0 ? r.should(be_a(Hash)) : r.should(be_nil)}
         end
+        
+        it "should throw an APIError if Facebook returns an empty body (as happens for instance when the API breaks)" do
+          @oauth.should_receive(:fetch_token_string).and_return("")
+          lambda { @oauth.get_token_info_from_session_keys(@oauth_data["multiple_session_keys"]) }.should raise_error(Koala::Facebook::APIError)
+        end
       end
       
       describe "with get_tokens_from_session_keys" do
@@ -358,81 +360,48 @@ class FacebookOAuthTests < Test::Unit::TestCase
         @oauth = Koala::Facebook::OAuth.new(@app_id, @request_secret || @app_secret)
       end
 
-      it "should break the request into the encoded signature and the payload" do
-        @signed_request.should_receive(:split).with(".").and_return(["", ""])
-        @oauth.parse_signed_request(@signed_request)
+      # the signed request code comes directly from Facebook
+      # so we only need to test at a high level that it works      
+      # signed params refers to http://developers.facebook.com/docs/authentication/canvas
+      # signed request refers to http://developers.facebook.com/docs/authentication/canvas/encryption_proposal
+      it "should throw an error if the algorithm is unsupported" do
+        JSON.stub!(:parse).and_return("algorithm" => "my fun algorithm")
+        lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
       end
       
-      it "should base64 URL decode the signed request" do
-        sig = ""
-        @signed_request.should_receive(:split).with(".").and_return([sig, "1"])
-        @oauth.should_receive(:base64_url_decode).with(sig).and_return("4")
-        @oauth.parse_signed_request(@signed_request)
+      it "should throw an error if the signature is invalid" do
+        OpenSSL::HMAC.stub!(:hexdigest).and_return("i'm an invalid signature")
+        lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
       end
 
-      it "should base64 URL decode the signed request" do
-        sig = @signed_request.split(".")[0]
-        @oauth.should_receive(:base64_url_decode).with(sig).and_return(nil)
-        @oauth.parse_signed_request(@signed_request)        
-      end
-      
-      it "should get the sha64 encoded payload using proper arguments from OpenSSL::HMAC" do
-        payload = ""
-        @signed_request.should_receive(:split).with(".").and_return(["1", payload])
-        OpenSSL::HMAC.should_receive(:digest).with("sha256", @request_secret, payload)
-        @oauth.parse_signed_request(@signed_request)        
+      describe "for signed params" do
+        it "should work" do
+          @oauth.parse_signed_request(@signed_request).should == @signed_request_result
+        end      
       end
       
-      it "should compare the encoded payload with the signature" do
-        sig = "2"
-        @oauth.should_receive(:base64_url_decode).and_return(sig)
-        encoded_payload = "1"
-        OpenSSL::HMAC.should_receive(:digest).with(anything, anything, anything).and_return(encoded_payload)
-        encoded_payload.should_receive(:==).with(sig)
-        @oauth.parse_signed_request(@signed_request)                
-      end
-        
-      describe "if the encoded payload matches the signature" do
-        before :each do
-          # set it up so the sig will match the encoded payload
-          raw_sig = ""
-          @sig = "2"
-          @payload = "1"
-          @signed_request.should_receive(:split).and_return([raw_sig, @payload])
-          @oauth.should_receive(:base64_url_decode).with(raw_sig).and_return(@sig)
-          OpenSSL::HMAC.should_receive(:digest).with(anything, anything, anything).and_return(@sig.dup)
+      describe "for signed requests" do
+        it "should work" do
+          @oauth = Koala::Facebook::OAuth.new(@app_id, @signed_params_secret || @app_secret)
+          @oauth.parse_signed_request(@signed_params).should == @signed_params_result
         end
         
-        it "should base64_url_decode the payload" do
-          @oauth.should_receive(:base64_url_decode).with(@payload).ordered.and_return("{}")
-          @oauth.parse_signed_request(@signed_request)        
+        it "should throw an error if the params are too old" do
+          @time.stub!(:to_i).and_return(1287601988 + 4000)
+          @oauth = Koala::Facebook::OAuth.new(@app_id, @signed_params_secret || @app_secret)
+          
+          lambda { @oauth.parse_signed_request(@signed_params) }.should raise_error
         end
         
-        it "should JSON decode the payload" do
-          result = "{}"
-          @oauth.should_receive(:base64_url_decode).with(@payload).and_return(result)
-          JSON.should_receive(:parse).with(result)
-          @oauth.parse_signed_request(@signed_request)        
-        end
-      end
-
-      describe "if the encoded payload does not match the signature" do
-        before :each do
-          sig = ""
-          @signed_request.should_receive(:split).and_return([sig, ""])
-          OpenSSL::HMAC.should_receive(:digest).with(anything, anything, anything).and_return("hi")
+        it "should let you specify the max age for a request" do
+          @time.stub!(:to_i).and_return(1287601988 + 4000)
+          @oauth = Koala::Facebook::OAuth.new(@app_id, @signed_params_secret || @app_secret)
+          
+          lambda { @oauth.parse_signed_request(@signed_params, 4001) }.should_not raise_error
         end
         
-        it "should return nil" do
-          @oauth.parse_signed_request(@signed_request).should be_nil
-        end
       end
       
-      describe "run against data" do
-        it "should work" do
-          @oauth.parse_signed_request(@signed_request).should == @signed_request_result
-        end
-      end
     end
 
   end # describe

data/spec/koala/rest_api/rest_api_no_access_token_tests.rb

@@ -1,82 +1,12 @@
 shared_examples_for "Koala RestAPI without an access token" do
-  # REST_CALL
-  describe "when making a rest request" do
-    it "should use the proper path" do
-      method = stub('methodName')
-      @api.should_receive(:api).with(
-        "method/#{method}",
-        anything,
-        anything,
-        anything
-      )
-      
-      @api.rest_call(method)  
-    end
-    
-    it "should always use the rest api" do
-      @api.should_receive(:api).with(
-        anything,
-        anything,
-        anything,
-        :rest_api => true
-      )  
-      
-      @api.rest_call('anything')
-    end
-    
-    it "should take an optional hash of arguments" do
-      args = {:arg1 => 'arg1'}
-      
-      @api.should_receive(:api).with(
-        anything,
-        hash_including(args),
-        anything,
-        anything
-      )
-      
-      @api.rest_call('anything', args)
-    end
-    
-    it "should always ask for JSON" do
-      @api.should_receive(:api).with(
-        anything,
-        hash_including('format' => 'json'),
-        anything,
-        anything
-      )
-      
-      @api.rest_call('anything')
-    end
-  end 
-
   # FQL_QUERY
   describe "when making a FQL request" do
-    it "should call fql.query method" do
-      @api.should_receive(:rest_call).with(
-        "fql.query", 
-        anything
-      ).and_return(Koala::Response.new(200, "2", {}))
-      
-      @api.fql_query stub('query string')
-    end
-    
-    it "should pass a query argument" do
-      query = stub('query string')
-      
-      @api.should_receive(:rest_call).with(
-        anything,
-        hash_including("query" => query)
-      )
-      
-      @api.fql_query(query)
-    end
-  
     it "should be able to access public information via FQL" do
       @result = @api.fql_query("select first_name from user where uid = 216743")
       @result.size.should == 1
       @result.first["first_name"].should == "Chris"
     end
-    
+
     it "should not be able to access protected information via FQL" do
       lambda { @api.fql_query("select read_stream from permissions where uid = 216743") }.should raise_error(Koala::Facebook::APIError)
     end
@@ -84,11 +14,12 @@ shared_examples_for "Koala RestAPI without an access token" do
 end
 
 class FacebookRestAPINoAccessTokenTest < Test::Unit::TestCase
-  before :each do
-    @api = Koala::Facebook::RestAPI.new
-  end
-  
   describe "Koala RestAPI without an access token" do
-    it_should_behave_like "Koala RestAPI without an access token" 
+    before :each do
+      @api = Koala::Facebook::RestAPI.new
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI without an access token"
   end
 end

data/spec/koala/rest_api/rest_api_tests.rb

@@ -0,0 +1,118 @@
+shared_examples_for "Koala RestAPI" do
+  # REST_CALL
+  describe "when making a rest request" do
+    it "should use the proper path" do
+      method = stub('methodName')
+      @api.should_receive(:api).with(
+        "method/#{method}",
+        anything,
+        anything,
+        anything
+      )
+
+      @api.rest_call(method)
+    end
+
+    it "should always use the rest api" do
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        hash_including(:rest_api => true)
+      )
+
+      @api.rest_call('anything')
+    end
+
+    it "should set the read_only option to true if the method is listed in the read-only list" do
+      method = Koala::Facebook::RestAPI::READ_ONLY_METHODS.first
+
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        hash_including(:read_only => true)
+      )
+
+      @api.rest_call(method)
+    end
+
+    it "should set the read_only option to false if the method is not inthe read-only list" do
+      method = "I'm not a read-only method"
+
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        hash_including(:read_only => false)
+      )
+
+      @api.rest_call(method)
+    end
+
+
+    it "should take an optional hash of arguments" do
+      args = {:arg1 => 'arg1'}
+
+      @api.should_receive(:api).with(
+        anything,
+        hash_including(args),
+        anything,
+        anything
+      )
+
+      @api.rest_call('anything', args)
+    end
+
+    it "should always ask for JSON" do
+      @api.should_receive(:api).with(
+        anything,
+        hash_including('format' => 'json'),
+        anything,
+        anything
+      )
+
+      @api.rest_call('anything')
+    end
+
+    it "should pass any options provided to the API" do
+      options = {:a => 2}
+
+      @api.should_receive(:api).with(
+        anything,
+        hash_including('format' => 'json'),
+        anything,
+        hash_including(options)
+      )
+
+      @api.rest_call('anything', {}, options)
+    end
+
+    it "should throw 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 "should call fql.query method" do
+        @api.should_receive(:rest_call).with(
+          "fql.query",
+          anything
+        ).and_return(Koala::Response.new(200, "2", {}))
+
+        @api.fql_query stub('query string')
+      end
+
+      it "should pass a query argument" do
+        query = stub('query string')
+
+        @api.should_receive(:rest_call).with(
+          anything,
+          hash_including("query" => query)
+        )
+
+        @api.fql_query(query)
+      end
+    end
+  end
+end

data/spec/koala/rest_api/rest_api_with_access_token_tests.rb

@@ -8,7 +8,7 @@ shared_examples_for "Koala RestAPI with an access token" do
 
   it "should be able to 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::GraphAPI.new(@token)
@@ -26,11 +26,13 @@ end
 
 class FacebookRestAPIWithAccessTokenTests < Test::Unit::TestCase
   describe "Koala RestAPI with an access token" do
-    it_should_behave_like "live testing examples"
-    it_should_behave_like "Koala RestAPI with an access token"
-    
+    include LiveTestingDataHelper
+
     before :each do
       @api = Koala::Facebook::RestAPI.new(@token)
     end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI with an access token"
   end
 end

data/spec/koala/test_users/test_users_tests.rb

@@ -0,0 +1,208 @@
+class TestUsersTests < Test::Unit::TestCase
+  include Koala
+
+  describe "Koala TestUsers with access token" do
+    include LiveTestingDataHelper
+
+    before :all do
+      # get oauth data
+      @oauth_data = $testing_data["oauth_test_data"]
+      @app_id = @oauth_data["app_id"]
+      @secret = @oauth_data["secret"]
+      @app_access_token = @oauth_data["app_access_token"]
+
+      # check OAuth data
+      unless @app_id && @secret && @app_access_token
+        raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
+      end
+
+      @is_mock = defined?(Koala::IS_MOCK) && Koala::IS_MOCK
+    end
+
+    describe "when initializing" do
+      # basic initialization
+      it "should initialize properly with an app_id and an app_access_token" do
+        test_users = Facebook::TestUsers.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        test_users.should be_a(Facebook::TestUsers)
+      end
+
+      # init with secret / fetching the token
+      it "should initialize properly with an app_id and a secret" do
+        test_users = Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+        test_users.should be_a(Facebook::TestUsers)
+      end
+
+      it "should use the OAuth class to fetch a token when provided an app_id and a secret" do
+        oauth = Facebook::OAuth.new(@app_id, @secret)
+        token = oauth.get_app_access_token
+        oauth.should_receive(:get_app_access_token).and_return(token)
+        Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
+        test_users = Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+      end
+    end
+
+    describe "when used without network" do
+      before :each do
+        @test_users = Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+      end
+
+      # TEST USER MANAGEMENT
+      it "should create a test user when not given installed" do
+        result = @test_users.create(false)
+        @temporary_object_id = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
+      end
+
+      it "should create a test user when not given installed, ignoring permissions" do
+        result = @test_users.create(false, "read_stream")
+        @temporary_object_id = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
+      end
+
+      it "should accept permissions as a string" do
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything)
+        result = @test_users.create(true, "read_stream,publish_stream")
+      end
+
+      it "should accept permissions as an array" do
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything)
+        result = @test_users.create(true, ["read_stream", "publish_stream"])
+      end
+
+      it "should create a test user when given installed and a permission" do
+        result = @test_users.create(true, "read_stream")
+        @temporary_object_id = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
+      end
+
+      describe "with a user to delete" do
+        before :each do
+          @user1 = @test_users.create(true, "read_stream")
+          @user2 = @test_users.create(true, "read_stream,user_interests")
+        end
+
+        after :each do
+          print "\nCleaning up test users..."
+          @test_users.delete(@user1) if @user1
+          @test_users.delete(@user2) if @user2
+          puts "done."
+        end
+
+        it "should delete a user by id" do
+          @test_users.delete(@user1['id']).should be_true
+          @user1 = nil
+        end
+
+        it "should delete a user by hash" do
+          @test_users.delete(@user2).should be_true
+          @user2 = nil
+        end
+
+        it "should not delete users when provided a false ID" do
+          lambda { @test_users.delete("#{@user1['id']}1") }.should raise_exception(Koala::Facebook::APIError)
+        end
+      end
+
+      describe "with delete_all" do
+        it "should delete all users found by the list commnand" do
+          array = [1, 2, 3]
+          @test_users.should_receive(:list).and_return(array)
+          array.each {|i| @test_users.should_receive(:delete).with(i) }
+          @test_users.delete_all
+        end
+      end
+
+      describe "with existing users" do
+        before :each do
+          @user1 = @test_users.create(true, "read_stream")
+          @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)
+          first_user, second_user = result[0], result[1]
+          (first_user["id"] && first_user["access_token"] && first_user["login_url"]).should
+          (second_user["id"] && second_user["access_token"] && second_user["login_url"]).should
+        end
+
+        it "should make two users into friends by id" do
+          result = @test_users.befriend(@user1['id'], @user2['id'])
+          result.should be_true
+        end
+
+        it "should make two users into friends by hash" do
+          result = @test_users.befriend(@user1, @user2)
+          result.should be_true
+        end
+
+      end # with existing users
+
+    end # when used without network
+
+    describe "when creating a network of friends" do
+      before :each do
+        @test_users = Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+        @network = []
+
+        if @is_mock
+          id_counter = 999999900
+          @test_users.stub!(:create).and_return do
+            id_counter += 1
+            {"id" => id_counter, "access_token" => "119908831367602|o3wswWQ88LYjEC9-ukR_gjRIOMw.", "login_url" => "https://www.facebook.com/platform/test_account.."}
+          end
+          @test_users.stub!(:befriend).and_return(true)
+          @test_users.stub!(:delete).and_return(true)
+        end
+      end
+
+      describe "tests that create users" do
+        before :each do
+          print "\nCleaning up test user network..."
+          test_users = Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+          test_users.delete_all
+          puts "done!"
+        end
+
+        after :each do
+          print "\nCleaning up test user network..."
+          test_users = Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+          test_users.delete_all
+          puts "done!"
+        end
+
+        it "should create a 5 person network" do
+          size = 5
+          @network = @test_users.create_network(size)
+          @network.should be_a(Array)
+          @network.size.should == size
+        end
+      end
+
+      it "should limit to a 50 person network" do
+        @test_users.should_receive(:create).exactly(50).times
+        @test_users.stub!(:befriend)
+        @network = @test_users.create_network(51)
+      end
+
+      it "should pass on the installed and permissions parameters to create" do
+        perms = ["read_stream", "offline_access"]
+        installed = false
+        count = 25
+        @test_users.should_receive(:create).exactly(count).times.with(installed, perms)
+        @test_users.stub!(:befriend)
+        @network = @test_users.create_network(count, installed, perms)
+      end
+
+    end # when creating network
+
+  end  # describe Koala TestUsers
+end # class