koala 0.9.0 → 0.10.0

data/spec/koala/net_http_service_tests.rb

@@ -1,180 +1,185 @@
 require 'koala/http_services'
-  
 class NetHTTPServiceTests < Test::Unit::TestCase
   module Bear
     include Koala::NetHTTPService
   end
-  
-  it "should define a make_request static module method" do
-    Bear.respond_to?(:make_request).should be_true
-  end
 
-  describe "when making a request" do
-    before(:each) do
-      # Setup stubs for make_request to execute without exceptions
-      @mock_http_response = stub('Net::HTTPResponse', :code => 1)
-      @mock_body = stub('Net::HTTPResponse body')
-      @http_request_result = [@mock_http_response, @mock_body]
-      
-      @http_yield_mock = mock('Net::HTTP start yielded object')
-      
-      @http_yield_mock.stub(:post).and_return(@http_request_result)
-      @http_yield_mock.stub(:get).and_return(@http_request_result)
-      
-      @http_mock = stub('Net::HTTP object', 'use_ssl=' => true, 'verify_mode=' => true)
-      @http_mock.stub(:start).and_yield(@http_yield_mock)
-      
-      Net::HTTP.stub(:new).and_return(@http_mock)
-    end
-  
-    it "should use POST if verb is not GET" do
-      @http_yield_mock.should_receive(:post).and_return(@mock_http_response)
-      @http_mock.should_receive(:start).and_yield(@http_yield_mock)
-      
-      Bear.make_request('anything', {}, 'anything')
-    end
-    
-    it "should use port 443" do
-      Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
-      
-      Bear.make_request('anything', {}, 'anything')  
-    end
-    
-    it "should use SSL" do
-      @http_mock.should_receive('use_ssl=').with(true)
-      
-      Bear.make_request('anything', {}, 'anything')  
-    end
-    
-    it "should use the graph server by default" do
-      Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
-      Bear.make_request('anything', {}, 'anything')  
-    end
-    
-    it "should use the REST server if the :rest_api option is true" do
-      Net::HTTP.should_receive(:new).with(Koala::Facebook::REST_SERVER, anything).and_return(@http_mock)
-      Bear.make_request('anything', {}, 'anything', :rest_api => true)  
-    end
-    
-    it "should turn off vertificate validaiton warnings" do
-      @http_mock.should_receive('verify_mode=').with(OpenSSL::SSL::VERIFY_NONE)
-      
-      Bear.make_request('anything', {}, 'anything')
-    end
-    
-    it "should start an HTTP connection" do
-      @http_mock.should_receive(:start).and_yield(@http_yield_mock)
-      Bear.make_request('anything', {}, 'anything')
+  describe "NetHTTPService module holder class Bear" do
+    it "should define a make_request static module method" do
+      Bear.respond_to?(:make_request).should be_true
     end
-    
-    describe "via POST" do
-      it "should use Net::HTTP to make a POST request" do
-        @http_yield_mock.should_receive(:post).and_return(@http_request_result)
-        
-        Bear.make_request('anything', {}, 'post')
+
+    describe "when making a request" do
+      before(:each) do
+        # Setup stubs for make_request to execute without exceptions
+        @mock_http_response = stub('Net::HTTPResponse', :code => 1)
+        @mock_body = stub('Net::HTTPResponse body')
+        @http_request_result = [@mock_http_response, @mock_body]
+
+        # to_ary is called in Ruby 1.9 to provide backwards compatibility 
+        # with the response, body = http.get() syntax we use
+        @mock_http_response.stub!(:to_ary).and_return(@http_request_result)
+
+        @http_yield_mock = mock('Net::HTTP start yielded object')
+
+        @http_yield_mock.stub(:post).and_return(@http_request_result)
+        @http_yield_mock.stub(:get).and_return(@http_request_result)
+
+        @http_mock = stub('Net::HTTP object', 'use_ssl=' => true, 'verify_mode=' => true)
+        @http_mock.stub(:start).and_yield(@http_yield_mock)
+
+        Net::HTTP.stub(:new).and_return(@http_mock)
       end
-      
-      it "should go to the specified path adding a / if it doesn't exist" do
-        path = mock('Path')
-        @http_yield_mock.should_receive(:post).with(path, anything).and_return(@http_request_result)
-        
-        Bear.make_request(path, {}, 'post')        
+
+      it "should use POST if verb is not GET" do
+        @http_yield_mock.should_receive(:post).and_return(@mock_http_response)
+        @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+
+        Bear.make_request('anything', {}, 'anything')
       end
-      
-      it "should use encoded parameters" do
-        args = {}
-        params = mock('Encoded parameters')
-        Bear.should_receive(:encode_params).with(args).and_return(params)
-        
-        @http_yield_mock.should_receive(:post).with(anything, params).and_return(@http_request_result)
-        
-        Bear.make_request('anything', args, 'post')
+
+      it "should use port 443" do
+        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+        Bear.make_request('anything', {}, 'anything')  
       end
-    end
-    
-    describe "via GET" do
-      it "should use Net::HTTP to make a GET request" do
-        @http_yield_mock.should_receive(:get).and_return(@http_request_result)
-        
-        Bear.make_request('anything', {}, 'get')
+
+      it "should use SSL" do
+        @http_mock.should_receive('use_ssl=').with(true)
+
+        Bear.make_request('anything', {}, 'anything')  
       end
-      
-      it "should use the correct path, including arguments" do
-        path = mock('Path')
-        params = mock('Encoded parameters')
-        args = {}
-        
-        Bear.should_receive(:encode_params).with(args).and_return(params)
-        @http_yield_mock.should_receive(:get).with("#{path}?#{params}").and_return(@http_request_result)
-        
-        Bear.make_request(path, args, 'get')
+
+      it "should use the graph server by default" do
+        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
+        Bear.make_request('anything', {}, 'anything')  
       end
-    end
-    
-    describe "the returned value" do
-      before(:each) do
-        @response = Bear.make_request('anything', {}, 'anything')
+
+      it "should use the REST server if the :rest_api option is true" do
+        Net::HTTP.should_receive(:new).with(Koala::Facebook::REST_SERVER, anything).and_return(@http_mock)
+        Bear.make_request('anything', {}, 'anything', :rest_api => true)  
+      end
+
+      it "should turn off vertificate validaiton warnings" do
+        @http_mock.should_receive('verify_mode=').with(OpenSSL::SSL::VERIFY_NONE)
+
+        Bear.make_request('anything', {}, 'anything')
+      end
+
+      it "should start an HTTP connection" do
+        @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+        Bear.make_request('anything', {}, 'anything')
       end
-      
-      it "should return a Koala::Response object" do
-        @response.class.should == Koala::Response
+
+      describe "via POST" do
+        it "should use Net::HTTP to make a POST request" do
+          @http_yield_mock.should_receive(:post).and_return(@http_request_result)
+
+          Bear.make_request('anything', {}, 'post')
+        end
+
+        it "should go to the specified path adding a / if it doesn't exist" do
+          path = mock('Path')
+          @http_yield_mock.should_receive(:post).with(path, anything).and_return(@http_request_result)
+
+          Bear.make_request(path, {}, 'post')        
+        end
+
+        it "should use encoded parameters" do
+          args = {}
+          params = mock('Encoded parameters')
+          Bear.should_receive(:encode_params).with(args).and_return(params)
+
+          @http_yield_mock.should_receive(:post).with(anything, params).and_return(@http_request_result)
+
+          Bear.make_request('anything', args, 'post')
+        end
       end
-      
-      it "should return a Koala::Response with the right status" do
-        @response.status.should == @mock_http_response.code  
+
+      describe "via GET" do
+        it "should use Net::HTTP to make a GET request" do
+          @http_yield_mock.should_receive(:get).and_return(@http_request_result)
+
+          Bear.make_request('anything', {}, 'get')
+        end
+
+        it "should use the correct path, including arguments" do
+          path = mock('Path')
+          params = mock('Encoded parameters')
+          args = {}
+
+          Bear.should_receive(:encode_params).with(args).and_return(params)
+          @http_yield_mock.should_receive(:get).with("#{path}?#{params}").and_return(@http_request_result)
+
+          Bear.make_request(path, args, 'get')
+        end
       end
-      
-      it "should reutrn a Koala::Response with the right body" do
-        @response.body.should == @mock_body
+
+      describe "the returned value" do
+        before(:each) do
+          @response = Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should return a Koala::Response object" do
+          @response.class.should == Koala::Response
+        end
+
+        it "should return a Koala::Response with the right status" do
+          @response.status.should == @mock_http_response.code  
+        end
+
+        it "should reutrn a Koala::Response with the right body" do
+          @response.body.should == @mock_body
+        end
+
+        it "should return a Koala::Response with the Net::HTTPResponse object as headers" do
+          @response.headers.should == @mock_http_response
+        end
+      end # describe return value
+    end # describe when making a request
+
+    describe "when encoding parameters" do
+      it "should return an empty string if param_hash evaluates to false" do
+        Bear.encode_params(nil).should == ''
       end
-      
-      it "should return a Koala::Response with the Net::HTTPResponse object as headers" do
-        @response.headers.should == @mock_http_response
+
+      it "should convert values to JSON if the value is not a String" do
+        val = 'json_value'
+        not_a_string = 'not_a_string'
+        not_a_string.stub(:class).and_return('NotAString')
+        not_a_string.should_receive(:to_json).and_return(val)
+
+        string = "hi"
+
+        args = {
+          not_a_string => not_a_string,
+          string => string
+        }
+
+        result = Bear.encode_params(args)
+        result.split('&').find do |key_and_val|
+          key_and_val.match("#{not_a_string}=#{val}")
+        end.should be_true
       end
-    end # describe return value
-  end # describe when making a request
-  
-  describe "when encoding parameters" do
-    it "should return an empty string if param_hash evaluates to false" do
-      Bear.encode_params(nil).should == ''
-    end
-    
-    it "should convert values to JSON if the value is not a String" do
-      val = 'json_value'
-      not_a_string = 'not_a_string'
-      not_a_string.stub(:class).and_return('NotAString')
-      not_a_string.should_receive(:to_json).and_return(val)
-      
-      string = "hi"
-      
-      args = {
-        not_a_string => not_a_string,
-        string => string
-      }
-      
-      result = Bear.encode_params(args)
-      result.split('&').find do |key_and_val|
-        key_and_val.match("#{not_a_string}=#{val}")
-      end.should be_true
-    end
-    
-    it "should escape all values" do
-      args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
-      
-      result = Bear.encode_params(args)
-      result.split('&').each do |key_val|
-        key, val = key_val.split('=')
-        val.should == CGI.escape(args[key])
+
+      it "should escape all values" do
+        args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
+
+        result = Bear.encode_params(args)
+        result.split('&').each do |key_val|
+          key, val = key_val.split('=')
+          val.should == CGI.escape(args[key])
+        end
       end
-    end
-    
-    it "should convert all keys to Strings" do
-      args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
-      
-      result = Bear.encode_params(args)
-      result.split('&').each do |key_val|
-        key, val = key_val.split('=')
-        key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
+
+      it "should convert all keys to Strings" do
+        args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
+
+        result = Bear.encode_params(args)
+        result.split('&').each do |key_val|
+          key, val = key_val.split('=')
+          key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
+        end
       end
     end
   end

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
@@ -34,6 +23,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 +291,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

data/spec/koala/rest_api/rest_api_no_access_token_tests.rb

@@ -83,12 +83,12 @@ shared_examples_for "Koala RestAPI without an access token" do
   end
 end
 
-class FacebookRestAPINoAccessTokenTest < Test::Unit::TestCase
-  before :each do
-    @api = Koala::Facebook::RestAPI.new
-  end
-  
+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" 
   end
 end

data/spec/koala/rest_api/rest_api_with_access_token_tests.rb

@@ -26,7 +26,7 @@ end
 
 class FacebookRestAPIWithAccessTokenTests < Test::Unit::TestCase
   describe "Koala RestAPI with an access token" do
-    it_should_behave_like "live testing examples"
+    include LiveTestingDataHelper
     it_should_behave_like "Koala RestAPI with an access token"
     
     before :each do

data/spec/koala/test_users/test_users_tests.rb

@@ -0,0 +1,215 @@
+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 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)
+          @network.should be_a(Array)
+          @network.size.should == 50
+          puts "done!"
+        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

data/spec/koala_spec_helper.rb

@@ -1,6 +1,18 @@
-require 'test/unit'
-require 'rubygems'
-require 'spec/test/unit'
+if defined?(RUBY_VERSION) && RUBY_VERSION =~ /1\.9/
+  require 'test/unit'
+  require 'rspec'
+
+  Rspec.configure do |c|
+    c.mock_with :rspec
+  end
+  
+else
+  # Ruby 1.8.x
+  require 'test/unit'
+  require 'rubygems'
+
+  require 'spec/test/unit'
+end
 
 # load the libraries
 require 'koala'
@@ -28,4 +40,9 @@ require 'koala/oauth/oauth_tests'
 require 'koala/realtime_updates/realtime_updates_tests'
 
 # Services tests
-require 'koala/net_http_service_tests'
+require 'koala/net_http_service_tests'
+
+# Test users tests
+require 'koala/test_users/test_users_tests'
+
+

data/spec/koala_spec_without_mocks.rb

@@ -15,5 +15,5 @@ unless $testing_data["oauth_token"]
 end
 
 unless $testing_data["oauth_test_data"] && $testing_data["oauth_test_data"]["code"] && $testing_data["oauth_test_data"]["secret"]
-  puts "Cookie tests will fail until you store valid data for the cookie hash, app_id, and app secret in facebook_data.yml"
+  puts "OAuth code tests will fail until you store valid data for the user's OAuth code and the app secret in facebook_data.yml"
 end