koala 1.0.0 → 1.2.0

data/spec/cases/realtime_updates_spec.rb

@@ -3,11 +3,10 @@ require 'spec_helper'
 describe "Koala::Facebook::RealtimeUpdates" do
   before :all do
     # get oauth data
-    @oauth_data = $testing_data["oauth_test_data"]
-    @app_id = @oauth_data["app_id"]
-    @secret = @oauth_data["secret"]
-    @callback_url = @oauth_data["callback_url"]
-    @app_access_token = @oauth_data["app_access_token"]
+    @app_id = KoalaTest.app_id
+    @secret = KoalaTest.secret
+    @callback_url = KoalaTest.oauth_test_data["callback_url"]
+    @app_access_token = KoalaTest.app_access_token
     
     # check OAuth data
     unless @app_id && @secret && @callback_url && @app_access_token
@@ -15,14 +14,13 @@ describe "Koala::Facebook::RealtimeUpdates" do
     end
     
     # get subscription data
-    @subscription_data = $testing_data["subscription_test_data"]
-    @verify_token = @subscription_data["verify_token"]
-    @challenge_data = @subscription_data["challenge_data"]
-    @subscription_path = @subscription_data["subscription_path"]
+    @verify_token = KoalaTest.subscription_test_data["verify_token"]
+    @challenge_data = KoalaTest.subscription_test_data["challenge_data"]
+    @subscription_path = KoalaTest.subscription_test_data["subscription_path"]
     
     # check subscription data
     unless @verify_token && @challenge_data && @subscription_path
-      raise Exception, "Must supply verify_token and equivalent challenge_data to run live subscription tests!" 
+      raise Exception, "Must supply verify_token and equivalent challenge_data to run subscription tests!" 
     end
   end
 
@@ -34,28 +32,40 @@ describe "Koala::Facebook::RealtimeUpdates" do
     end
     
     # attributes
-    it "should allow read access to app_id, app_access_token, and secret" do
-      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      # this should not throw errors
-      updates.app_id && updates.app_access_token && updates.secret
+    it "should allow read access to app_id" do
+      # in Ruby 1.9, .method returns symbols 
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:app_id)
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:app_id=)
     end
-    
-    it "should not allow write access to app_id" do
-      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      # this should not throw errors
-      lambda { updates.app_id = 2 }.should raise_error(NoMethodError)
+
+    it "should allow read access to app_access_token" do
+      # in Ruby 1.9, .method returns symbols 
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:app_access_token)
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
     end
 
-    it "should not allow write access to app_access_token" do
-      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      # this should not throw errors
-      lambda { updates.app_access_token = 2 }.should raise_error(NoMethodError)
+    it "should allow read access to secret" do
+      # in Ruby 1.9, .method returns symbols 
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:secret)
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:secret=)
     end
-  
-    it "should not allow write access to secret" do
-      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      # this should not throw errors
-      lambda { updates.secret = 2 }.should raise_error(NoMethodError)
+
+    it "should allow read access to api" do
+      # in Ruby 1.9, .method returns symbols 
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:api)
+      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:api=)
+    end
+
+    # old graph_api accessor
+    it "returns the api object when graph_api is called" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+      updates.graph_api.should == updates.api
+    end
+
+    it "fire a deprecation warning when graph_api is called" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+      Koala::Utils.should_receive(:deprecate)
+      updates.graph_api
     end
     
     # init with secret / fetching the token
@@ -151,20 +161,24 @@ describe "Koala::Facebook::RealtimeUpdates" do
       end
       
       describe "and a block is given" do
+        before :each do
+          @params['hub.verify_token'] = @token
+        end
+          
         it "should give the block the token as a parameter" do
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             token.should == @token
           end
         end
         
         it "should return false if the given block return false" do
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             false
           end.should be_false
         end
         
         it "should return false if the given block returns nil" do
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             nil
           end.should be_false
         end

data/spec/cases/rest_api_spec.rb

@@ -1,25 +1,41 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::RestAPI" do
-  
+  describe "class consolidation" do
+    before :each do
+      Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
+    end
+
+    it "still allows you to instantiate a GraphAndRestAPI object" do
+      api = Koala::Facebook::RestAPI.new("token").should be_a(Koala::Facebook::RestAPI)
+    end
+
+    it "ultimately creates an API object" do
+      api = Koala::Facebook::RestAPI.new("token").should be_a(Koala::Facebook::API)
+    end
+
+    it "fires a depreciation warning" do
+      Koala::Utils.should_receive(:deprecate)
+      api = Koala::Facebook::RestAPI.new("token")
+    end
+  end
+
   context "without an access token" do
     before :each do
-      @api = Koala::Facebook::RestAPI.new
+      @api = Koala::Facebook::API.new
     end
 
     it_should_behave_like "Koala RestAPI"
     it_should_behave_like "Koala RestAPI without an access token"
   end
-  
-  context "with an access token" do
-    include LiveTestingDataHelper
 
+  context "with an access token" do
     before :each do
-      @api = Koala::Facebook::RestAPI.new(@token)
+      @api = Koala::Facebook::API.new(@token)
     end
 
     it_should_behave_like "Koala RestAPI"
     it_should_behave_like "Koala RestAPI with an access token"
   end
-  
+
 end

data/spec/cases/test_users_spec.rb

@@ -2,21 +2,23 @@ require 'spec_helper'
 
 describe "Koala::Facebook::TestUsers" do
   context "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"]
+      @app_id = KoalaTest.app_id
+      @secret = KoalaTest.secret
+      @app_access_token = KoalaTest.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
+    
+    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
@@ -39,68 +41,103 @@ describe "Koala::Facebook::TestUsers" do
         Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
         test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
       end
-    end
 
-    describe "when used without network" do
-      before :each do
-        @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+      # attributes
+      it "should allow read access to app_id, app_access_token, and secret" do
+        # in Ruby 1.9, .method returns symbols
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_id)
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(: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
+      it "should allow read access to app_access_token" do
+        # in Ruby 1.9, .method returns symbols
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_access_token)
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
       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
+      it "should allow read access to secret" do
+        # in Ruby 1.9, .method returns symbols
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:secret)
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:secret=)
       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, anything)
-        result = @test_users.create(true, "read_stream,publish_stream")
+      it "should allow read access to api" do
+        # in Ruby 1.9, .method returns symbols
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:api)
+        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:api=)
       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, anything)
-        result = @test_users.create(true, ["read_stream", "publish_stream"])
+      # old graph_api accessor
+      it "returns the api object when graph_api is called" do
+        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+        test_users.graph_api.should == test_users.api
       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
+      it "fire a deprecation warning when graph_api is called" do
+        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+        Koala::Utils.should_receive(:deprecate)
+        test_users.graph_api
       end
+    end
 
-      it "lets you specify other graph arguments, like uid and access token" do
-        args = {:uid => "some test user ID", :owner_access_token => "some owner access token"}
-        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
-        @test_users.create(true, nil, args)
+    describe "when used without network" do
+      before :each do
+        @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
       end
-      
-      it "lets you specify http options that get passed through to the graph call" do
-        options = {:some_http_option => true}
-        @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
-        @test_users.create(true, nil, {}, options)
+
+      # TEST USER MANAGEMENT
+
+      describe ".create" do
+        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, 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, 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
+
+        it "lets you specify other graph arguments, like uid and access token" do
+          args = {:uid => "some test user ID", :owner_access_token => "some owner access token"}
+          @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
+          @test_users.create(true, nil, args)
+        end
+
+        it "lets you specify http options that get passed through to the graph call" do
+          options = {:some_http_option => true}
+          @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+          @test_users.create(true, nil, {}, options)
+        end
       end
 
-      describe "with a user to delete" do
+      describe ".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
-          @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
@@ -116,7 +153,7 @@ describe "Koala::Facebook::TestUsers" do
         end
       end
 
-      describe "with delete_all" do
+      describe ".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)
@@ -125,17 +162,37 @@ describe "Koala::Facebook::TestUsers" do
         end
       end
 
+      describe ".update" do
+        before :each do
+          @updates = {:name => "Foo Baz"}
+        end
+
+        it "makes a POST with the test user Graph API " do
+          user = @test_users.create(true)
+          @test_users.graph_api.should_receive(:graph_call).with(anything, anything, "post", anything)
+          @test_users.update(user, @updates)
+        end
+
+        it "makes a request to the test user with the update params " do
+          user = @test_users.create(true)
+          @test_users.graph_api.should_receive(:graph_call).with(user["id"], @updates, anything, anything)
+          @test_users.update(user, @updates)
+        end
+
+        it "works" do
+          user = @test_users.create(true)
+          @test_users.update(user, @updates)
+          user_info = Koala::Facebook::API.new(user["access_token"]).get_object(user["id"])
+          user_info["name"].should == @updates[:name]
+        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)
@@ -143,22 +200,22 @@ describe "Koala::Facebook::TestUsers" do
           (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 with string hashes" do
           result = @test_users.befriend(@user1, @user2)
           result.should be_true
         end
-      
+
         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
@@ -171,7 +228,7 @@ describe "Koala::Facebook::TestUsers" do
         @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
         @network = []
 
-        if @is_mock
+        if KoalaTest.mock_interface?
           id_counter = 999999900
           @test_users.stub!(:create).and_return do
             id_counter += 1
@@ -183,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)
@@ -201,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
@@ -218,4 +266,4 @@ describe "Koala::Facebook::TestUsers" do
 
     end # when creating network
   end
-end  # describe Koala TestUsers
+end  # describe Koala TestUsers