koala 1.2.1 → 1.3.0

data/spec/cases/api_spec.rb

@@ -11,7 +11,7 @@ describe "Koala::Facebook::API" do
       hash_not_including('access_token' => 1),
       anything,
       anything
-    ).and_return(Koala::Response.new(200, "", ""))
+    ).and_return(Koala::HTTPService::Response.new(200, "", ""))
 
     @service.api('anything')
   end
@@ -25,7 +25,7 @@ describe "Koala::Facebook::API" do
       hash_including('access_token' => token),
       anything,
       anything
-    ).and_return(Koala::Response.new(200, "", ""))
+    ).and_return(Koala::HTTPService::Response.new(200, "", ""))
 
     service.api('anything')
   end
@@ -36,15 +36,22 @@ describe "Koala::Facebook::API" do
     service.access_token.should == token
   end
 
-  it "gets the attribute of a Koala::Response given by the http_component parameter" do
+  it "gets the attribute of a Koala::HTTPService::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('')
-
+    result = stub("result")
+    response.stub(http_component).and_return(result)
     Koala.stub(:make_request).and_return(response)
 
-    @service.api('anything', {}, 'get', :http_component => http_component)
+    @service.api('anything', {}, 'get', :http_component => http_component).should == result
+  end
+
+  it "returns the entire response if http_component => :response" do
+    http_component = :response
+    response = mock('Mock KoalaResponse', :body => '', :status => 200)
+    Koala.stub(:make_request).and_return(response)    
+    @service.api('anything', {}, 'get', :http_component => http_component).should == response
   end
 
   it "returns the body of the request as JSON if no http_component is given" do
@@ -59,7 +66,7 @@ describe "Koala::Facebook::API" do
 
   it "executes an error checking block if provided" do
     body = '{}'
-    Koala.stub(:make_request).and_return(Koala::Response.new(200, body, {}))
+    Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, body, {}))
 
     yield_test = mock('Yield Tester')
     yield_test.should_receive(:pass)
@@ -71,29 +78,29 @@ describe "Koala::Facebook::API" do
   end
 
   it "raises 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', {}))
+    Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(500, 'response body', {}))
 
     lambda { @service.api('anything') }.should raise_exception(Koala::Facebook::APIError)
   end
 
   it "handles rogue true/false as responses" do
-    Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'true', {}))
+    Koala.should_receive(:make_request).and_return(Koala::HTTPService::Response.new(200, 'true', {}))
     @service.api('anything').should be_true
 
-    Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'false', {}))
+    Koala.should_receive(:make_request).and_return(Koala::HTTPService::Response.new(200, 'false', {}))
     @service.api('anything').should be_false
   end
 
   describe "with regard to leading slashes" do
     it "adds 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', {}))
+      Koala.should_receive(:make_request).with("/#{path}", anything, anything, anything).and_return(Koala::HTTPService::Response.new(200, 'true', {}))
       @service.api(path)
     end
 
     it "doesn'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', {}))
+      Koala.should_receive(:make_request).with(path, anything, anything, anything).and_return(Koala::HTTPService::Response.new(200, 'true', {}))
       @service.api(path)
     end
   end

data/spec/cases/error_spec.rb

@@ -10,6 +10,16 @@ describe Koala::Facebook::APIError do
     Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type=)
   end
 
+  it "has an accessor for raw_response" do
+    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:raw_response)
+    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:raw_response=)
+  end
+
+  it "sets raw_response to the provided error details" do
+    error_response = {"type" => "foo", "other_details" => "bar"}
+    Koala::Facebook::APIError.new(error_response).raw_response.should == error_response
+  end
+  
   it "sets fb_error_type to details['type']" do
     type = "foo"
     Koala::Facebook::APIError.new("type" => type).fb_error_type.should == type

data/spec/cases/graph_api_batch_spec.rb

@@ -10,7 +10,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
     @app_api = Koala::Facebook::API.new(@app_access_token)
   end
 
-  describe "BatchOperations" do
+  describe Koala::Facebook::GraphBatchAPI::BatchOperation do
     before :each do
       @args = {
         :url => "my url",
@@ -22,32 +22,32 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       }
     end
 
-    describe "#new" do
+    describe ".new" do
       it "makes http_options accessible" do
-        Koala::Facebook::BatchOperation.new(@args).http_options.should == @args[:http_options]
+        Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).http_options.should == @args[:http_options]
       end
 
       it "makes post_processing accessible" do
-        Koala::Facebook::BatchOperation.new(@args).post_processing.should == @args[:post_processing]
+        Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).post_processing.should == @args[:post_processing]
       end
 
       it "makes access_token accessible" do
-        Koala::Facebook::BatchOperation.new(@args).access_token.should == @args[:access_token]
+        Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).access_token.should == @args[:access_token]
       end
 
       it "doesn't change the original http_options" do
         @args[:http_options][:name] = "baz2"
         expected = @args[:http_options].dup
-        Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)
+        Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)
         @args[:http_options].should == expected
       end
 
       it "leaves the file array nil by default" do
-        Koala::Facebook::BatchOperation.new(@args).files.should be_nil
+        Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).files.should be_nil
       end
 
       it "raises a KoalaError if no access token supplied" do
-        expect { Koala::Facebook::BatchOperation.new(@args.merge(:access_token => nil)) }.to raise_exception(Koala::KoalaError)
+        expect { Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args.merge(:access_token => nil)) }.to raise_exception(Koala::KoalaError)
       end
 
       describe "when supplied binary files" do
@@ -69,7 +69,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
         it "adds binary files to the files attribute as UploadableIOs" do
           @args[:args].merge!("source" => @binary)
-          batch_op = Koala::Facebook::BatchOperation.new(@args)
+          batch_op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args)
           batch_op.files.should_not be_nil
           batch_op.files.find {|k, v| v == @uploadable_io}.should_not be_nil
         end
@@ -77,24 +77,24 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         it "works if supplied an UploadableIO as an argument" do
           # as happens with put_picture at the moment
           @args[:args].merge!("source" => @uploadable_io)
-          batch_op = Koala::Facebook::BatchOperation.new(@args)
+          batch_op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args)
           batch_op.files.should_not be_nil
           batch_op.files.find {|k, v| v == @uploadable_io}.should_not be_nil
         end
 
         it "assigns each binary parameter unique name" do
           @args[:args].merge!("source" => @binary, "source2" => @binary)
-          batch_op = Koala::Facebook::BatchOperation.new(@args)
+          batch_op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args)
           # if the name wasn't unique, there'd just be one item
           batch_op.files.should have(2).items
         end
 
         it "assigns each binary parameter unique name across batch requests" do
           @args[:args].merge!("source" => @binary, "source2" => @binary)
-          batch_op = Koala::Facebook::BatchOperation.new(@args)
+          batch_op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args)
           # simulate the batch operation, since it's used in determination
           @batch_queue << batch_op
-          batch_op2 = Koala::Facebook::BatchOperation.new(@args)
+          batch_op2 = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args)
           @batch_queue << batch_op2
           # if the name wasn't unique, we should have < 4 items since keys would be the same
           batch_op.files.merge(batch_op2.files).should have(4).items
@@ -102,13 +102,13 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
         it "removes the value from the arguments" do
           @args[:args].merge!("source" => @binary)
-          Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should_not =~ /source=/
+          Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:body].should_not =~ /source=/
         end
       end
 
     end
 
-    describe ".to_batch_params" do
+    describe "#to_batch_params" do
       describe "handling arguments and URLs" do
         shared_examples_for "request with no body" do
           it "adds the args to the URL string, with ? if no args previously present" do
@@ -116,7 +116,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             @args[:url] = url = "/"
             Koala.http_service.stub(:encode_params).and_return(test_args)
 
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == "#{url}?#{test_args}"
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == "#{url}?#{test_args}"
           end
 
           it "adds the args to the URL string, with & if args previously present" do
@@ -124,16 +124,16 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             @args[:url] = url = "/?a=2"
             Koala.http_service.stub(:encode_params).and_return(test_args)
 
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == "#{url}&#{test_args}"
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == "#{url}&#{test_args}"
           end
 
           it "adds nothing to the URL string if there are no args to be added" do
             @args[:args] = {}
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])[:relative_url].should == @args[:url]
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(@args[:access_token])[:relative_url].should == @args[:url]
           end
 
           it "adds nothing to the body" do
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should be_nil
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:body].should be_nil
           end
         end
 
@@ -142,13 +142,13 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             test_args = "foo"
             Koala.http_service.stub(:encode_params).and_return(test_args)
 
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should == test_args
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:body].should == test_args
           end
 
           it "does not set the body if there are no args" do
             test_args = ""
             Koala.http_service.stub(:encode_params).and_return(test_args)
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should be_nil
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:body].should be_nil
           end
 
 
@@ -156,7 +156,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             test_args = "foo"
             Koala.http_service.stub(:encode_params).and_return(test_args)
 
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == @args[:url]
+            Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == @args[:url]
           end
         end
 
@@ -194,45 +194,45 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       end
 
       it "includes the access token if the token is not the main one for the request" do
-         params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)
+         params = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)
          params[:relative_url].should =~ /access_token=#{@args[:access_token]}/
       end
 
       it "includes the other arguments if the token is not the main one for the request" do
         @args[:args] = {:a => 2}
-        params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)
+        params = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)
         params[:relative_url].should =~ /a=2/
       end
 
       it "does not include the access token if the token is the main one for the request" do
-         params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])
+         params = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(@args[:access_token])
          params[:relative_url].should_not =~ /access_token=#{@args[:access_token]}/
       end
 
       it "includes the other arguments if the token is the main one for the request" do
         @args[:args] = {:a => 2}
-        params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])
+        params = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(@args[:access_token])
         params[:relative_url].should =~ /a=2/
       end
 
       it "includes any arguments passed as http_options[:batch_args]" do
         batch_args = {:name => "baz", :headers => {:some_param => true}}
         @args[:http_options][:batch_args] = batch_args
-        params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)
+        params = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(nil)
         params.should include(batch_args)
       end
 
       it "includes the method" do
-        params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])
+        params = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args).to_batch_params(@args[:access_token])
         params[:method].should == @args[:method].to_s
       end
 
       it "works with nil http_options" do
-        expect { Koala::Facebook::BatchOperation.new(@args.merge(:http_options => nil)).to_batch_params(nil) }.not_to raise_exception
+        expect { Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args.merge(:http_options => nil)).to_batch_params(nil) }.not_to raise_exception
       end
 
       it "works with nil args" do
-        expect { Koala::Facebook::BatchOperation.new(@args.merge(:args => nil)).to_batch_params(nil) }.not_to raise_exception
+        expect { Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args.merge(:args => nil)).to_batch_params(nil) }.not_to raise_exception
       end
 
       describe "with binary files" do
@@ -252,7 +252,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
         it "adds file identifiers as attached_files in a comma-separated list" do
           @args[:args].merge!("source" => @binary, "source2" => @binary)
-          batch_op = Koala::Facebook::BatchOperation.new(@args)
+          batch_op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(@args)
           file_ids = batch_op.files.find_all {|k, v| v == @uploadable_io}.map {|k, v| k}
           params = batch_op.to_batch_params(nil)
           params[:attached_files].should == file_ids.join(",")
@@ -263,9 +263,8 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
   end
 
   describe "GraphAPI batch interface" do
-
     it "returns nothing for a batch operation" do
-      Koala.stub(:make_request).and_return(Koala::Response.new(200, "[]", {}))
+      Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, "[]", {}))
       @api.batch do |batch_api|
         batch_api.get_object('me').should be_nil
       end
@@ -273,7 +272,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
     describe "#batch" do
       before :each do
-        @fake_response = Koala::Response.new(200, "[]", {})
+        @fake_response = Koala::HTTPService::Response.new(200, "[]", {})
         Koala.stub(:make_request).and_return(@fake_response)
       end
 
@@ -300,9 +299,9 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
         it "sets args['batch'] to a json'd map of all the batch params" do
           access_token = "bar"
-          op = Koala::Facebook::BatchOperation.new(:access_token => access_token, :method => :get, :url => "/")
+          op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(:access_token => access_token, :method => :get, :url => "/")
           op.stub(:to_batch_params).and_return({:a => 2})
-          Koala::Facebook::BatchOperation.stub(:new).and_return(op)
+          Koala::Facebook::GraphBatchAPI::BatchOperation.stub(:new).and_return(op)
 
           # two requests should generate two batch operations
           expected = MultiJson.encode([op.to_batch_params(access_token), op.to_batch_params(access_token)])
@@ -320,7 +319,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           @key = "file0_0"
           @uploadable_io = stub("UploadableIO")
           batch_op = stub("Koala Batch Operation", :files => {@key => @uploadable_io}, :to_batch_params => {}, :access_token => "foo")
-          Koala::Facebook::BatchOperation.stub(:new).and_return(batch_op)
+          Koala::Facebook::GraphBatchAPI::BatchOperation.stub(:new).and_return(batch_op)
 
           Koala.should_receive(:make_request).with(anything, hash_including(@key => @uploadable_io), anything, anything).and_return(@fake_response)
           Koala::Facebook::API.new("bar").batch do |batch_api|
@@ -366,35 +365,78 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       end
 
       describe "processing the request" do
-        it "throws an error if the response is not 200" do
-          Koala.stub(:make_request).and_return(Koala::Response.new(500, "[]", {}))
-          expect { Koala::Facebook::API.new("foo").batch do |batch_api|
-            batch_api.get_object('me')
-          end }.to raise_exception(Koala::Facebook::APIError)
+        it "returns the result headers as a hash if http_component is headers" do
+          Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
+          result = @api.batch do |batch_api|
+            batch_api.get_object(KoalaTest.user1, {}, :http_component => :headers)
+          end
+          result[0].should == {"Content-Type" => "text/javascript; charset=UTF-8"}
         end
+        
+        describe "if it errors" do
+          it "raises an APIError if the response is not 200" do
+            Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(500, "[]", {}))
+            expect { 
+              Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+            }.to raise_exception(Koala::Facebook::APIError)
+          end
 
-        it "throws an error if the response is a Batch API-style error" do
-          Koala.stub(:make_request).and_return(Koala::Response.new(200, '{"error":190,"error_description":"Error validating access token."}', {}))
-          expect { Koala::Facebook::API.new("foo").batch do |batch_api|
-            batch_api.get_object('me')
-          end }.to raise_exception(Koala::Facebook::APIError)
+          context "with the old style" do
+            before :each do
+              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":190,"error_description":"Error validating access token."}', {}))
+            end
+            
+            it "throws an error if the response is an old Batch API-style error" do
+              expect { 
+                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+              }.to raise_exception(Koala::Facebook::APIError)
+            end   
+            
+            it "provides a type for the error if the response is an old Batch API-style error" do
+              begin
+                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+              rescue Koala::Facebook::APIError => err
+              end
+              err.fb_error_type.should
+            end         
+            
+            it "passes all the error details if an old Batch API-style error is raised" do
+              begin
+                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+              rescue Koala::Facebook::APIError => err
+              end
+              err.raw_response["error"].should == 190
+            end
+          end
+          
+          context "with the new style" do          
+            before :each do
+              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}', {}))
+            end
+
+            it "throws an error if the response is a new Graph API-style error" do
+              expect { 
+                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+              }.to raise_exception(Koala::Facebook::APIError)
+            end
+            
+            it "passes all the error details if an old Batch API-style error is raised" do
+              begin
+                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+              rescue Koala::Facebook::APIError => err
+              end
+              err.raw_response["message"].should
+            end
+          end
         end
 
         it "returns the result status if http_component is status" do
-          Koala.stub(:make_request).and_return(Koala::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
+          Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
           result = @api.batch do |batch_api|
             batch_api.get_object(KoalaTest.user1, {}, :http_component => :status)
           end
           result[0].should == 203
         end
-
-        it "returns the result headers as a hash if http_component is headers" do
-          Koala.stub(:make_request).and_return(Koala::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
-          result = @api.batch do |batch_api|
-            batch_api.get_object(KoalaTest.user1, {}, :http_component => :headers)
-          end
-          result[0].should == {"Content-Type" => "text/javascript; charset=UTF-8"}
-        end
       end
 
       it "is thread safe" do
@@ -505,7 +547,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       it "posts binary files" do
         file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
 
-        Koala::Facebook::BatchOperation.instance_variable_set(:@identifier, 0)
+        Koala::Facebook::GraphBatchAPI::BatchOperation.instance_variable_set(:@identifier, 0)
         result = @api.batch do |batch_api|
           batch_api.put_picture(file)
         end
@@ -518,7 +560,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
         file2 = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
 
-        Koala::Facebook::BatchOperation.instance_variable_set(:@identifier, 0)
+        Koala::Facebook::GraphBatchAPI::BatchOperation.instance_variable_set(:@identifier, 0)
         results = @api.batch do |batch_api|
           batch_api.put_picture(file)
           batch_api.put_picture(file2, {}, KoalaTest.user1)

data/spec/cases/graph_collection_spec.rb

@@ -74,18 +74,34 @@ describe Koala::Facebook::GraphCollection do
   end
 
   describe "when parsing page paramters" do
-    it "should return the base as the first array entry" do
-      base = "url_path"
-      @collection.parse_page_url("anything.com/#{base}?anything").first.should == base
+    describe "#parse_page_url" do
+      it "should pass the url to the class method" do
+        url = stub("url")
+        Koala::Facebook::GraphCollection.should_receive(:parse_page_url).with(url)
+        @collection.parse_page_url(url)
+      end
+
+      it "should return the result of the class method" do
+        parsed_content = stub("parsed_content")
+        Koala::Facebook::GraphCollection.stub(:parse_page_url).and_return(parsed_content)
+        @collection.parse_page_url(stub("url")).should == parsed_content
+      end
     end
+    
+    describe ".parse_page_url" do    
+      it "should return the base as the first array entry" do
+        base = "url_path"
+        Koala::Facebook::GraphCollection.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"}
-      @collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+      it "should return the arguments as a hash as the last array entry" do
+        args_hash = {"one" => "val_one", "two" => "val_two"}
+        Koala::Facebook::GraphCollection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+      end
     end
   end
 
-  describe "#evaluate" do
+  describe ".evaluate" do
     it "returns the original result if it's provided a non-hash result" do
       result = []
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result

data/spec/cases/http_service_spec.rb

@@ -28,7 +28,7 @@ describe "Koala::HTTPService" do
     end
 
     it "adds multipart" do
-      @builder.should_receive(:use).with(Koala::MultipartRequest)
+      @builder.should_receive(:use).with(Koala::HTTPService::MultipartRequest)
       Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
     end
 
@@ -90,7 +90,7 @@ describe "Koala::HTTPService" do
     end
   end
 
-  describe "#encode_params" do
+  describe ".encode_params" do
     it "returns an empty string if param_hash evaluates to false" do
       Koala::HTTPService.encode_params(nil).should == ''
     end
@@ -135,7 +135,7 @@ describe "Koala::HTTPService" do
     end
   end
 
-  describe "#make_request" do
+  describe ".make_request" do
     before :each do
       # Setup stubs for make_request to execute without exceptions
       @mock_body = stub('Typhoeus response body')
@@ -273,7 +273,7 @@ describe "Koala::HTTPService" do
       :always_use_ssl => :use_ssl,
       :proxy => :proxy 
     }.each_pair do |deprecated_method, parameter|
-      describe "##{deprecated_method}" do
+      describe ".#{deprecated_method}" do
         context "read" do
           it "reads http_options[:#{parameter}]" do
             value = "foo"
@@ -305,7 +305,7 @@ describe "Koala::HTTPService" do
     
     # ssl options
     [:ca_path, :ca_file, :verify_mode].each do |deprecated_method|
-      describe "##{deprecated_method}" do
+      describe ".#{deprecated_method}" do
         context "read" do
           it "reads http_options[:ssl][:#{deprecated_method}] if http_options[:ssl]" do
             value = "foo"
@@ -422,26 +422,5 @@ describe "Koala::HTTPService" do
         end
       end
     end
-
-    {
-      :typhoeus => Koala::TyphoeusService, 
-      :net_http => Koala::NetHTTPService
-    }.each_pair do |adapter, module_class|
-      describe module_class.to_s do
-        it "responds to deprecated_interface" do
-           module_class.should respond_to(:deprecated_interface)
-        end
-      
-        it "issues a deprecation warning" do
-          Koala::Utils.should_receive(:deprecate)
-          module_class.deprecated_interface
-        end
-      
-        it "sets the default adapter to #{adapter}" do
-          module_class.deprecated_interface
-          Faraday.default_adapter.should == adapter
-        end
-      end
-    end
   end
 end

data/spec/cases/koala_spec.rb

@@ -1,15 +1,33 @@
 require 'spec_helper'
 
-describe "Koala" do
-  it "has a version" do
-    Koala.const_defined?("VERSION").should be_true
-  end
+describe Koala do
+
   
   it "has an http_service accessor" do
     Koala.should respond_to(:http_service)
     Koala.should respond_to(:http_service=)
   end
   
+  describe "constants" do
+    it "has a version" do
+      Koala.const_defined?("VERSION").should be_true
+    end
+
+    describe Koala::Facebook do      
+      it "defines GRAPH_SERVER" do
+        Koala::Facebook::GRAPH_SERVER.should == "graph.facebook.com"
+      end
+
+      it "defines REST_SERVER" do
+        Koala::Facebook::REST_SERVER.should == "api.facebook.com"
+      end
+      
+      it "defines DIALOG_HOST" do
+        Koala::Facebook::DIALOG_HOST.should == "www.facebook.com"
+      end
+    end
+  end
+  
   context "for deprecated services" do
     before :each do
       @service = Koala.http_service