koala 1.0.0.beta → 1.0.0

data/spec/cases/api_base_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::API" do
+  before(:each) do
+    @service = Koala::Facebook::API.new
+  end
+
+  it "should not include an access token if none was given" do
+    Koala.should_receive(:make_request).with(
+      anything,
+      hash_not_including('access_token' => 1),
+      anything,
+      anything
+    ).and_return(Koala::Response.new(200, "", ""))
+
+    @service.api('anything')
+  end
+
+  it "should include an access token if given" do
+    token = 'adfadf'
+    service = Koala::Facebook::API.new token
+
+    Koala.should_receive(:make_request).with(
+      anything,
+      hash_including('access_token' => token),
+      anything,
+      anything
+    ).and_return(Koala::Response.new(200, "", ""))
+
+    service.api('anything')
+  end
+
+  it "should have an attr_reader for access token" do
+    token = 'adfadf'
+    service = Koala::Facebook::API.new token
+    service.access_token.should == token
+  end
+
+  it "should get the attribute of a Koala::Response given by the http_component parameter" do
+    http_component = :method_name
+
+    response = mock('Mock KoalaResponse', :body => '', :status => 200)
+    response.should_receive(http_component).and_return('')
+
+    Koala.stub(:make_request).and_return(response)
+
+    @service.api('anything', 'get', {}, :http_component => http_component)
+  end
+
+  it "should return the body of the request as JSON if no http_component is given" do
+    response = stub('response', :body => 'body', :status => 200)
+    Koala.stub(:make_request).and_return(response)
+
+    json_body = mock('JSON body')
+    JSON.stub(:parse).and_return([json_body])
+
+    @service.api('anything').should == json_body
+  end
+
+  it "should execute a block with the response body if passed one" do
+    body = '{}'
+    Koala.stub(:make_request).and_return(Koala::Response.new(200, body, {}))
+
+    yield_test = mock('Yield Tester')
+    yield_test.should_receive(:pass)
+
+    @service.api('anything') do |arg|
+      yield_test.pass
+      arg.should == JSON.parse(body)
+    end
+  end
+
+  it "should raise an API error if the HTTP response code is greater than or equal to 500" do
+    Koala.stub(:make_request).and_return(Koala::Response.new(500, 'response body', {}))
+
+    lambda { @service.api('anything') }.should raise_exception(Koala::Facebook::APIError)
+  end
+
+  it "should handle rogue true/false as responses" do
+    Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'true', {}))
+    @service.api('anything').should be_true
+
+    Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'false', {}))
+    @service.api('anything').should be_false
+  end
+
+  describe "with regard to leading slashes" do
+    it "should add a leading / to the path if not present" do
+      path = "anything"
+      Koala.should_receive(:make_request).with("/#{path}", anything, anything, anything).and_return(Koala::Response.new(200, 'true', {}))
+      @service.api(path)
+    end
+
+    it "shouldn't change the path if a leading / is present" do
+      path = "/anything"
+      Koala.should_receive(:make_request).with(path, anything, anything, anything).and_return(Koala::Response.new(200, 'true', {}))
+      @service.api(path)
+    end
+  end
+
+end

data/spec/cases/graph_and_rest_api_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::GraphAndRestAPI" do
+  include LiveTestingDataHelper
+
+  describe "with an access token" do
+    before(:each) do
+      @api = Koala::Facebook::GraphAndRestAPI.new(@token)
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI with an access token"
+
+    it_should_behave_like "Koala GraphAPI"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  end
+
+  describe "without an access token" do
+    before(:each) do
+      @api = Koala::Facebook::GraphAndRestAPI.new
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI without an access token"
+
+    it_should_behave_like "Koala GraphAPI"
+    it_should_behave_like "Koala GraphAPI without an access token"
+    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  end
+end

data/spec/cases/graph_api_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::GraphAPI" do
+  include LiveTestingDataHelper
+  
+  context "with an access token" do
+    before :each do
+      @api = Koala::Facebook::GraphAPI.new(@token)
+    end
+
+    it_should_behave_like "Koala GraphAPI"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  end
+
+  context "without an access token" do
+    before :each do
+      @api = Koala::Facebook::GraphAPI.new
+    end
+
+    it_should_behave_like "Koala GraphAPI"
+    it_should_behave_like "Koala GraphAPI without an access token"
+    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  end
+end

data/spec/cases/http_services/http_service_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+
+class Bear
+  include Koala::HTTPService
+end
+
+describe "Koala::HTTPService" do
+
+  describe "common methods" do
+    describe "always_use_ssl accessor" do
+      it "should be added" do
+        # in Ruby 1.8, .methods returns strings
+        # in Ruby 1.9, .method returns symbols 
+        Bear.methods.collect {|m| m.to_sym}.should include(:always_use_ssl)
+        Bear.methods.collect {|m| m.to_sym}.should include(:always_use_ssl=)
+      end
+    end
+    
+    describe "server" do
+      describe "without options[:beta]" do
+        it "should return the rest server if options[:rest_api]" do
+          Bear.server(:rest_api => true).should == Koala::Facebook::REST_SERVER
+        end
+
+        it "should return the rest server if !options[:rest_api]" do
+          Bear.server(:rest_api => false).should == Koala::Facebook::GRAPH_SERVER
+          Bear.server({}).should == Koala::Facebook::GRAPH_SERVER
+        end
+      end
+      
+      describe "without options[:beta]" do
+        before :each do
+          @options = {:beta => true}
+        end
+        
+        it "should return the rest server if options[:rest_api]" do
+          server = Bear.server(@options.merge(:rest_api => true))
+          server.should =~ Regexp.new(Koala::Facebook::REST_SERVER)
+          server.should =~ /beta\./
+        end
+
+        it "should return the rest server if !options[:rest_api]" do
+          server = Bear.server(:beta => true)
+          server.should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER)
+          server.should =~ /beta\./
+        end
+      end
+      
+    end
+
+  end
+
+end

data/spec/cases/http_services/net_http_service_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+
+module Horse
+  include Koala::NetHTTPService
+end
+
+describe "NetHTTPService module holder class Horse" do
+  before :each do
+    # reset the always_use_ssl parameter
+    Horse.always_use_ssl = nil
+  end
+
+  it "should define a make_request static module method" do
+    Horse.respond_to?(:make_request).should be_true
+  end
+
+  it "should include the Koala::HTTPService module defining common features" do
+    Horse.included_modules.include?(Koala::HTTPService).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]
+
+      # 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
+
+    describe "the connection" do
+      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)
+
+        Horse.make_request('anything', {}, 'anything')
+      end
+
+      it "should use GET if that verb is specified" do
+        @http_yield_mock.should_receive(:get).and_return(@mock_http_response)
+        @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+
+        Horse.make_request('anything', {}, 'get')
+      end
+
+      it "should add the method to the arguments if it's not get or post" do
+        args = {}
+        method = "telekenesis"
+        # since the arguments get encoded later, we'll test for merge!
+        # even though that's somewhat testing internal implementation
+        args.should_receive(:merge!).with(:method => method)
+
+        Horse.make_request('anything', args, method)
+      end
+    end
+
+    describe "if the request has an access token" do
+      before :each do
+        @args = {"access_token" => "123"}
+      end
+
+      it "should use SSL" do
+        @http_mock.should_receive('use_ssl=').with(true)
+
+        Horse.make_request('anything', @args, 'anything')
+      end
+
+      it "should set the port to 443" do
+        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+        Horse.make_request('anything', @args, 'anything')
+      end
+    end
+    
+    describe "if always_use_ssl is true" do
+      before :each do
+        Horse.always_use_ssl = true
+      end
+
+      it "should use SSL" do
+        @http_mock.should_receive('use_ssl=').with(true)
+
+        Horse.make_request('anything', {}, 'anything')
+      end
+
+      it "should set the port to 443" do
+        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+        Horse.make_request('anything', {}, 'anything')
+      end
+    end
+
+    describe "if the use_ssl option is provided" do
+      it "should use SSL" do
+        @http_mock.should_receive('use_ssl=').with(true)
+
+        Horse.make_request('anything', {}, 'anything', :use_ssl => true)
+      end
+
+      it "should set the port to 443" do
+        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+        Horse.make_request('anything', {}, 'anything', :use_ssl => true)
+      end
+    end
+
+    describe "if there's no token and always_use_ssl isn't true" do
+      it "should not use SSL" do
+        @http_mock.should_not_receive('use_ssl=')
+        Horse.make_request('anything', {}, 'anything')
+      end
+
+      it "should not set the port" do
+        Net::HTTP.should_receive(:new).with(anything, nil).and_return(@http_mock)
+        Horse.make_request('anything', {}, 'anything')
+      end
+    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)
+      Horse.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)
+      Horse.make_request('anything', {}, 'anything', :rest_api => true)
+    end
+
+    it "no longer sets verify_mode to no verification" do
+      @http_mock.should_not_receive('verify_mode=')
+
+      Horse.make_request('anything', {}, 'anything')
+    end
+
+    it "should start an HTTP connection" do
+      @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+      Horse.make_request('anything', {}, 'anything')
+    end
+    
+    it 'creates a HTTP Proxy object when options contain a proxy' do
+      Net::HTTP.should_receive(:new).with(anything, anything, 'proxy', 1234, 'user', 'pass').and_return(@http_mock)
+      Horse.make_request('anything', {}, 'anything', {:proxy => 'http://user:pass@proxy:1234'})
+    end
+
+    it 'sets both timeouts when options contains a timeout' do
+      @http_mock.should_receive(:open_timeout=).with(10)
+      @http_mock.should_receive(:read_timeout=).with(10)
+      Horse.make_request('anything', {}, 'anything', {:timeout => 10})
+    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)
+
+        Horse.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)
+
+        Horse.make_request(path, {}, 'post')
+      end
+
+      it "should use encoded parameters" do
+        args = {}
+        params = mock('Encoded parameters')
+        Horse.should_receive(:encode_params).with(args).and_return(params)
+
+        @http_yield_mock.should_receive(:post).with(anything, params).and_return(@http_request_result)
+
+        Horse.make_request('anything', args, 'post')
+      end
+
+      describe "with multipart/form-data" do
+        before(:each) do
+          Horse.stub(:encode_multipart_params)
+          Horse.stub("params_require_multipart?").and_return(true)
+
+          @multipart_request_stub = stub('Stub Multipart Request')
+          Net::HTTP::Post::Multipart.stub(:new).and_return(@multipart_request_stub)
+
+          @file_stub = stub('fake File', "kind_of?" => true, "path" => 'anypath.jpg')
+
+          @http_yield_mock.stub(:request).with(@multipart_request_stub).and_return(@http_request_result)
+        end
+
+        it "should use multipart/form-data if any parameter is a valid file hash" do
+          @http_yield_mock.should_receive(:request).with(@multipart_request_stub).and_return(@http_request_result)
+
+          Horse.make_request('anything', {}, 'post')
+        end
+
+        it "should use the given request path for the request" do
+          args = {"file" => @file_stub}
+          expected_path = 'expected/path'
+
+          Net::HTTP::Post::Multipart.should_receive(:new).with(expected_path, anything).and_return(@multipart_request_stub)
+
+          Horse.make_request(expected_path, {}, 'post')
+        end
+
+        it "should use multipart encoded arguments for the request" do
+          args = {"file" => @file_stub}
+          expected_params = stub('Stub Multipart Params')
+
+          Horse.should_receive(:encode_multipart_params).with(args).and_return(expected_params)
+          Net::HTTP::Post::Multipart.should_receive(:new).with(anything, expected_params).and_return(@multipart_request_stub)
+
+          Horse.make_request('anything', args, 'post')
+        end
+      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)
+
+        Horse.make_request('anything', {}, 'get')
+      end
+
+      it "should use the correct path, including arguments" do
+        path = mock('Path')
+        params = mock('Encoded parameters')
+        args = {}
+
+        Horse.should_receive(:encode_params).with(args).and_return(params)
+        @http_yield_mock.should_receive(:get).with("#{path}?#{params}").and_return(@http_request_result)
+
+        Horse.make_request(path, args, 'get')
+      end
+    end
+
+    describe "the returned value" do
+      before(:each) do
+        @response = Horse.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
+      Horse.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 = Horse.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 = Horse.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        val.should == CGI.escape(args[key])
+      end
+    end
+
+    it "should convert all keys to Strings" do
+      args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
+
+      result = Horse.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
+
+  describe "when detecting if multipart posting is needed" do
+    it "should be true if any parameter value requires multipart post" do
+      koala_io = mock("Koala::IO")
+      koala_io.should_receive(:kind_of?).with(Koala::UploadableIO).and_return(true)
+
+      args = {
+        "key1" => "val",
+        "key2" => "val",
+        "key3" => koala_io,
+        "key4" => "val"
+      }
+
+      Horse.params_require_multipart?(args).should be_true
+    end
+    
+    describe "when encoding multipart/form-data params" do
+      it "should replace Koala::UploadableIO values with UploadIO values" do
+        upload_io = UploadIO.new(__FILE__, "fake type")
+        
+        uploadable_io = stub('Koala::UploadableIO')
+        uploadable_io.should_receive(:kind_of?).with(Koala::UploadableIO).and_return(true)
+        uploadable_io.should_receive(:to_upload_io).and_return(upload_io)
+        args = {
+          "not_a_file" => "not a file",
+          "file" => uploadable_io
+        }
+        
+        result = Horse.encode_multipart_params(args)
+
+        result["not_a_file"] == args["not_a_file"]
+        result["file"] == upload_io
+      end
+    end
+    
+  end
+end