koala 1.0.0.beta2.1 → 1.0.0.rc

data/spec/koala/graph_api/graph_collection_tests.rb

@@ -1,104 +0,0 @@
-# GraphCollection
-shared_examples_for "Koala GraphAPI with GraphCollection" do
-  
-  it "should create an array-like object" do
-    call = @api.graph_call("contextoptional/photos")
-    Koala::Facebook::GraphCollection.new(call, @api).should be_an(Array)
-  end
-  
-  describe "when getting a collection" do
-    # GraphCollection methods    
-    it "should get a GraphCollection when getting connections" do
-      @result = @api.get_connections("contextoptional", "photos")
-      @result.should be_a(Koala::Facebook::GraphCollection)
-    end
-    
-    it "should return nil if the get_collections call fails with nil" do
-      # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.get_connections("contextoptional", "photos").should be_nil
-    end
-
-    it "should get a GraphCollection when searching" do
-      result = @api.search("facebook")
-      result.should be_a(Koala::Facebook::GraphCollection)
-    end
-
-    it "should return nil if the search call fails with nil" do
-      # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.search("facebook").should be_nil
-    end
-    
-    it "should get a GraphCollection when paging through results" do
-      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}])
-      @results.should be_a(Koala::Facebook::GraphCollection)
-    end
-    
-    it "should return nil if the page call fails with nil" do
-      # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}]).should be_nil
-    end
-    
-    # GraphCollection attributes
-    describe "the GraphCollection" do
-      before(:each) do
-        @result = @api.get_connections("contextoptional", "photos")
-      end
-          
-      it "should have a read-only paging attribute" do
-        lambda { @result.paging }.should_not raise_error
-        lambda { @result.paging = "paging" }.should raise_error(NoMethodError)
-      end
-  
-      describe "when getting a whole page" do
-        before(:each) do
-          @second_page = stub("page of Fb graph results")
-          @base = stub("base")
-          @args = stub("args")
-          @page_of_results = stub("page of results")
-        end
-    
-        it "should return the previous page of results" do
-          @result.should_receive(:previous_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_return(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-      
-          @result.previous_page.should == @page_of_results
-        end
-    
-        it "should return the next page of results" do
-          @result.should_receive(:next_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_return(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-      
-          @result.next_page.should == @page_of_results        
-        end
-    
-        it "should return nil it there are no other pages" do
-          %w{next previous}.each do |this|
-            @result.should_receive("#{this}_page_params".to_sym).and_return(nil)
-            @result.send("#{this}_page").should == nil
-          end
-        end
-      end
-  
-      describe "when parsing page paramters" do
-        before(:each) do
-          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::GraphAPI.new)
-        end
-    
-        it "should return the base as the first array entry" do
-          base = "url_path"
-          @graph_collection.parse_page_url("anything.com/#{base}?anything").first.should == base 
-        end
-    
-        it "should return the arguments as a hash as the last array entry" do
-          args_hash = {"one" => "val_one", "two" => "val_two"}
-          @graph_collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
-        end
-      end
-    end
-  end
-end

data/spec/koala/http_services/net_http_service_tests.rb

@@ -1,339 +0,0 @@
-require 'koala/http_services'
-class NetHTTPServiceTests < Test::Unit::TestCase
-  module Bear
-    include Koala::NetHTTPService
-  end
-
-  describe "NetHTTPService module holder class Bear" do
-    before :each do
-      # reset the always_use_ssl parameter
-      Bear.always_use_ssl = nil
-    end
-
-    it "should define a make_request static module method" do
-      Bear.respond_to?(:make_request).should be_true
-    end
-
-    it "should include the Koala::HTTPService module defining common features" do
-      Bear.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)
-
-          Bear.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)
-
-          Bear.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)
-
-          Bear.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)
-
-          Bear.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)
-
-          Bear.make_request('anything', @args, 'anything')
-        end
-      end
-
-      describe "if always_use_ssl is true" do
-        before :each do
-          Bear.always_use_ssl = true
-        end
-
-        it "should use SSL" do
-          @http_mock.should_receive('use_ssl=').with(true)
-
-          Bear.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)
-
-          Bear.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)
-
-          Bear.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)
-
-          Bear.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=')
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should not set the port" do
-          Net::HTTP.should_receive(:new).with(anything, nil).and_return(@http_mock)
-          Bear.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)
-        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 "no longer turns off vertificate validaiton warnings" do
-        @http_mock.should_not_receive('verify_mode=')
-
-        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
-
-      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
-
-        describe "with multipart/form-data" do
-          before(:each) do
-            Bear.stub(:encode_multipart_params)
-            Bear.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)
-
-            Bear.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)
-
-            Bear.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')
-
-            Bear.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)
-
-            Bear.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)
-
-          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
-
-      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 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])
-        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
-        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"
-        }
-
-        Bear.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 = Bear.encode_multipart_params(args)
-
-          result["not_a_file"] == args["not_a_file"]
-          result["file"] == upload_io
-        end
-      end
-      
-    end
-  end
-end

data/spec/koala/http_services/typhoeus_service_tests.rb

@@ -1,162 +0,0 @@
-require 'koala/http_services'
-class TyphoeusServiceTests < Test::Unit::TestCase
-  module Bear
-    include Koala::TyphoeusService
-  end
-
-  describe "TyphoeusService module holder class Bear" do
-    before :each do
-      # reset the always_use_ssl parameter
-      Bear.always_use_ssl = nil
-    end
-
-    it "should define a make_request static module method" do
-      Bear.respond_to?(:make_request).should be_true
-    end
-
-    it "should include the Koala::HTTPService module defining common features" do
-      Bear.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_body = stub('Typhoeus response body')
-        @mock_headers_hash = stub({:value => "headers hash"})
-        @mock_http_response = stub(Typhoeus::Response, :code => 1, :headers_hash => @mock_headers_hash, :body => @mock_body)
-
-        # Typhoeus is an included module, so we stub methods on Bear itself
-        Bear.stub(:post).and_return(@mock_http_response)
-        Bear.stub(:get).and_return(@mock_http_response)
-      end
-
-      it "should use POST if verb is not GET" do
-        Bear.should_receive(:post).and_return(@mock_http_response)
-        Bear.make_request('anything', {}, 'anything')
-      end
-
-      it "should use GET if that verb is specified" do
-        Bear.should_receive(:get).and_return(@mock_http_response)
-        Bear.make_request('anything', {}, 'get')
-      end
-
-      describe "the connection" do
-        it "should use SSL if the request has an access token" do
-          Bear.should_receive(:post).with(/https\:/, anything)
-
-          Bear.make_request('anything', {"access_token" => "123"}, 'anything')
-        end
-
-        it "should use SSL if always_use_ssl is true, even if there's no token" do
-          Bear.should_receive(:post).with(/https\:/, anything)
-
-          Bear.always_use_ssl = true
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should use SSL if the :use_ssl option is provided, even if there's no token" do
-          Bear.should_receive(:post).with(/https\:/, anything)
-
-          Bear.always_use_ssl = true
-          Bear.make_request('anything', {}, 'anything', :use_ssl => true)
-        end
-
-        it "should not use SSL if always_use_ssl is false and there's no token" do
-          Bear.should_receive(:post).with(/http\:/, anything)
-
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should use the graph server by default" do
-          Bear.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
-
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should use the REST server if the :rest_api option is true" do
-          Bear.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
-
-          Bear.make_request('anything', {}, 'anything', :rest_api => true)
-        end
-      end
-
-      it "should pass the arguments to Typhoeus under the :params key" do
-        args = {:a => 2}
-        Bear.should_receive(:post).with(anything, hash_including(:params => args))
-
-        Bear.make_request('anything', args, "post")
-      end
-
-      it "should add the method to the arguments if the method isn't get or post" do
-        method = "telekenesis"
-        Bear.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
-
-        Bear.make_request('anything', {}, method)
-      end
-
-      it "should pass :typhoeus_options to Typhoeus if provided" do
-        t_options = {:a => :b}
-        Bear.should_receive(:post).with(anything, hash_including(t_options))
-
-        Bear.make_request("anything", {}, "post", :typhoeus_options => t_options)
-      end
-
-      it "should include the path in the request" do
-        path = "/a/b/c/1"
-        Bear.should_receive(:post).with(Regexp.new(path), anything)
-
-        Bear.make_request(path, {}, "post")
-      end
-
-      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_headers_hash
-        end
-      end # describe return value
-    end
-    
-    describe "with file upload" do
-      it "should include an interface to NetHTTPService called NetHTTPInterface" do
-        # we should be able to access it
-        lambda { Koala::TyphoeusService::NetHTTPInterface }.should_not raise_exception(Exception)
-        Koala::TyphoeusService::NetHTTPInterface.included_modules.include?(Koala::NetHTTPService).should be_true
-      end
-      
-      it "should call the NetHTTPInterface if multipart is required" do
-        method = "any_method"
-        args = {}
-        verb = "get"
-        options = {}
-
-        Bear.stub(:params_require_multipart?).and_return(true)
-        Koala::TyphoeusService::NetHTTPInterface.should_receive(:make_request).with(method, args, verb, options)
-
-        Bear.make_request(method, args, verb, options)
-      end
-      
-      # Typhoeus file uploads currently don't work
-      # for live tests, run the Graph API tests with Typhoues, which will run file uploads
-      # it "should pass any files directly on to Typhoues" do
-      #  args = {:file => File.new(__FILE__, "r")}
-      #  Bear.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
-      #  Bear.make_request("anything", args, :post)
-      # end
-    end
-  end
-end