koala 0.10.0 → 1.0.0.beta2.1

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)
@@ -134,36 +134,44 @@ class TestUsersTests < Test::Unit::TestCase
           (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'])
+        it "should make two users into friends with string hashes" do
+          result = @test_users.befriend(@user1, @user2)
           result.should be_true
         end
         
-        it "should make two users into friends by hash" do
-          result = @test_users.befriend(@user1, @user2)
+        it "should make two users into friends with symbol hashes" do
+          new_user_1 = {}
+          @user1.each_pair {|k, v| new_user_1[k.to_sym] = v}
+          new_user_2 = {}
+          @user2.each_pair {|k, v| new_user_2[k.to_sym] = v}
+          
+          result = @test_users.befriend(new_user_1, new_user_2)
           result.should be_true
-        end
+        end        
         
+        it "should not accept user IDs anymore" do
+          lambda { @test_users.befriend(@user1["id"], @user2["id"]) }.should raise_exception
+        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
             id_counter += 1
-            {"id" => id_counter, "access_token" => "119908831367602|o3wswWQ88LYjEC9-ukR_gjRIOMw.", "login_url" => "https://www.facebook.com/platform/test_account.."}
+            {"id" => id_counter, "access_token" => @token, "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..."
@@ -178,22 +186,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 +209,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