koala 0.10.0 → 1.0.0.beta

data/spec/koala/oauth/oauth_tests.rb

@@ -16,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 && 
@@ -24,9 +28,9 @@ class FacebookOAuthTests < Test::Unit::TestCase
 
       @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)
+      @time = Time.now
+      Time.stub!(:now).and_return(@time)
+      @time.stub!(:to_i).and_return(1273363199)
     end
     
     # initialization
@@ -356,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,94 +1,25 @@
 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
   end
 end
 
-class FacebookRestAPINoAccessTokenTest < Test::Unit::TestCase 
+class FacebookRestAPINoAccessTokenTest < Test::Unit::TestCase
   describe "Koala RestAPI without an access token" do
     before :each do
       @api = Koala::Facebook::RestAPI.new
     end
-    
-    it_should_behave_like "Koala RestAPI without an access token" 
+
+    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)
@@ -27,10 +27,12 @@ end
 class FacebookRestAPIWithAccessTokenTests < Test::Unit::TestCase
   describe "Koala RestAPI with an access token" do
     include LiveTestingDataHelper
-    it_should_behave_like "Koala RestAPI with an access token"
-    
+
     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

@@ -10,37 +10,37 @@ class TestUsersTests < Test::Unit::TestCase
       @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!" 
+        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 
+      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)      
+        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) 
+        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})
@@ -53,31 +53,31 @@ class TestUsersTests < Test::Unit::TestCase
         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")
@@ -87,25 +87,25 @@ class TestUsersTests < Test::Unit::TestCase
         after :each do
           print "\nCleaning up test users..."
           @test_users.delete(@user1) if @user1
-          @test_users.delete(@user2) if @user2 
+          @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]
@@ -114,18 +114,18 @@ class TestUsersTests < Test::Unit::TestCase
           @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)
@@ -133,26 +133,26 @@ class TestUsersTests < Test::Unit::TestCase
           (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    
+
+    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
@@ -163,7 +163,7 @@ class TestUsersTests < Test::Unit::TestCase
           @test_users.stub!(:delete).and_return(true)
         end
       end
-      
+
       describe "tests that create users" do
         before :each do
           print "\nCleaning up test user network..."
@@ -178,22 +178,15 @@ class TestUsersTests < Test::Unit::TestCase
           test_users.delete_all
           puts "done!"
         end
-        
-        it "should create a 2 person network" do
-          @network = @test_users.create_network(2)
-          @network.should be_a(Array)
-          @network.size.should == 2
-        end
-      
-        it "should create a 50 person network" do
-          puts "\nStarting 50-person network test (this may take several minutes)..."
-          @network = @test_users.create_network(50)
+
+        it "should create a 5 person network" do
+          size = 5
+          @network = @test_users.create_network(size)
           @network.should be_a(Array)
-          @network.size.should == 50
-          puts "done!"
+          @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)
@@ -208,7 +201,7 @@ class TestUsersTests < Test::Unit::TestCase
         @test_users.stub!(:befriend)
         @network = @test_users.create_network(count, installed, perms)
       end
-      
+
     end # when creating network
 
   end  # describe Koala TestUsers