koala 0.10.0 → 1.0.0.beta

data/spec/koala/graph_api/graph_api_tests.rb

@@ -0,0 +1,86 @@
+shared_examples_for "Koala GraphAPI" do
+  # all Graph API instances should pass these tests, regardless of configuration
+
+  # API
+  it "should never use the rest api server" do
+    Koala.should_receive(:make_request).with(
+      anything,
+      anything,
+      anything,
+      hash_not_including(:rest_api => true)
+    ).and_return(Koala::Response.new(200, "", {}))
+
+    @api.api("anything")
+  end
+
+  # GRAPH CALL
+  describe "graph_call" do
+    it "should pass all arguments to the api method" do
+      args = ["koppel", {}, "get", {:a => :b}]
+
+      @api.should_receive(:api).with(*args)
+
+      @api.graph_call(*args)
+    end
+
+    it "should throw an APIError if the result hash has an error key" do
+      Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error" => "An error occurred!"}, {}))
+      lambda { @api.graph_call("koppel", {}) }.should raise_exception(Koala::Facebook::APIError)
+    end
+  end
+
+  # SEARCH
+  it "should be able to search" do
+    result = @api.search("facebook")
+    result.length.should be_an(Integer)
+  end
+
+  # DATA
+  # access public info
+
+  it "should get public data about a user" do
+    result = @api.get_object("koppel")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should_not be_nil
+  end
+
+  it "should get public data about a Page" do
+    result = @api.get_object("contextoptional")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should
+  end
+
+  it "should be able to get multiple objects" do
+    results = @api.get_objects(["contextoptional", "naitik"])
+    results.length.should == 2
+  end
+
+  it "should be able to access a user's picture" do
+    @api.get_picture("chris.baclig").should =~ /http\:\/\//
+  end
+
+  it "should be able to access a user's picture, given a picture type"  do
+    @api.get_picture("chris.baclig", {:type => 'large'}).should =~ /^http\:\/\//
+  end
+
+  it "should be able to access connections from public Pages" do
+    result = @api.get_connections("contextoptional", "photos")
+    result.should be_a(Array)
+  end
+
+  # SEARCH
+  it "should be able to search" do
+    result = @api.search("facebook")
+    result.length.should be_an(Integer)
+  end
+
+  # PAGING THROUGH COLLECTIONS
+  # see also graph_collection_tests
+  it "should make a request for a page when provided a specific set of page params" do
+    query = [1, 2]
+    @api.should_receive(:graph_call).with(*query)
+    @api.get_page(query)
+  end
+
+
+end

data/spec/koala/graph_api/graph_api_with_access_token_tests.rb

@@ -1,150 +1,154 @@
 shared_examples_for "Koala GraphAPI with an access token" do
-  it "should get public data about a user" do
-      result = @api.get_object("koppel")
-      # the results should have an ID and a name, among other things
-      (result["id"] && result["name"]).should_not be_nil
-    end
 
-    it "should get private data about a user" do
-      result = @api.get_object("koppel")
-      # updated_time should be a pretty fixed test case
-      result["updated_time"].should_not be_nil
-    end
+  it "should get private data about a user" do
+    result = @api.get_object("koppel")
+    # updated_time should be a pretty fixed test case
+    result["updated_time"].should_not be_nil
+  end
 
-    it "should get public data about a Page" do
-      result = @api.get_object("contextoptional")
-      # the results should have an ID and a name, among other things
-      (result["id"] && result["name"]).should
-    end
-  
-    it "should get data about 'me'" do
-      result = @api.get_object("me")
-      result["updated_time"].should
-    end
-  
-    it "should be able to get multiple objects" do
-      result = @api.get_objects(["contextoptional", "naitik"])
-      result.length.should == 2
-    end
-  
-    it "should be able to access a user's picture" do
-      @api.get_picture("chris.baclig").should =~ /http\:\/\//
-    end
-  
-    it "should be able to access a user's picture, given a picture type"  do
-      @api.get_picture("chris.baclig", {:type => 'large'}).should =~ /^http\:\/\//
-    end
+  it "should get data about 'me'" do
+    result = @api.get_object("me")
+    result["updated_time"].should
+  end
+
+  it "should be able to get multiple objects" do
+    result = @api.get_objects(["contextoptional", "naitik"])
+    result.length.should == 2
+  end
+  it "should be able to access connections from users" do
+    result = @api.get_connections("lukeshepard", "likes")
+    result.length.should > 0
+  end
+
+  # PUT
+  it "should be able to write an object to the graph" do
+    result = @api.put_wall_post("Hello, world, from the test suite!")
+    @temporary_object_id = result["id"]
+    @temporary_object_id.should_not be_nil
+  end
+
+  # DELETE
+  it "should be able to delete posts" do
+    result = @api.put_wall_post("Hello, world, from the test suite delete method!")
+    object_id_to_delete = result["id"]
+    delete_result = @api.delete_object(object_id_to_delete)
+    delete_result.should == true
+  end
   
-    it "should be able to access connections from users" do
-      result = @api.get_connections("lukeshepard", "likes")
-      result.length.should > 0
-    end
+  it "should be able to delete likes" do
+    result = @api.put_wall_post("Hello, world, from the test suite delete method!")
+    @temporary_object_id = result["id"]
+    @api.put_like(@temporary_object_id)
+    delete_like_result = @api.delete_like(@temporary_object_id)
+    delete_like_result.should == true
+  end
 
-    it "should be able to access connections from public Pages" do
-      result = @api.get_connections("contextoptional", "photos")
-      result.should be_a(Array)
-    end
+  # additional put tests
+  it "should be able to verify messages posted to a wall" do
+    message = "the cats are asleep"
+    put_result = @api.put_wall_post(message)
+    @temporary_object_id = put_result["id"]
+    get_result = @api.get_object(@temporary_object_id)
+
+    # make sure the message we sent is the message that got posted
+    get_result["message"].should == message
+  end
+
+  it "should be able to post a message with an attachment to a feed" do
+    result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "Context Optional", :link => "http://www.contextoptional.com/"})
+    @temporary_object_id = result["id"]
+    @temporary_object_id.should_not be_nil
+  end
+
+  it "should be able to post photos to the user's wall with an open file object" do
+    file_hash = {
+      "content_type" => "image/jpg",
+      "path" => File.join(File.dirname(__FILE__), "..", "assets", "beach.jpg"),
+      "file" => File.open(File.join(File.dirname(__FILE__), "..", "assets", "beach.jpg"))
+    }
+    result = @api.put_picture(file_hash)
+    @temporary_object_id = result["id"] 
+    @temporary_object_id.should_not be_nil
+  end
+  
+  it "should be able to post photos to the user's wall without an open file object" do
+    file_hash = {
+      "content_type" => "image/jpg",
+      "path" => File.join(File.dirname(__FILE__), "..", "assets", "beach.jpg")
+    }
+    result = @api.put_picture(file_hash)
+    @temporary_object_id = result["id"] 
+    @temporary_object_id.should_not be_nil
+  end
     
-    # paging
-    # see also graph_collection_tests
-    it "should make a request for a page when provided a specific set of page params" do
-      query = [1, 2]
-      @api.should_receive(:graph_call).with(*query)
-      @api.get_page(query)
-    end
+  it "should be able to verify a photo posted to a user's wall" do
+    file_hash = {
+      "content_type" => "image/jpg",
+      "path" => File.join(File.dirname(__FILE__), "..", "assets", "beach.jpg")
+    }
+    expected_message = "This is the test message"
     
+    result = @api.put_picture(file_hash, :message => expected_message)
+    @temporary_object_id = result["id"] 
+    @temporary_object_id.should_not be_nil
     
-    # PUT
-    it "should be able to write an object to the graph" do
-      result = @api.put_wall_post("Hello, world, from the test suite!")
-      @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
-    end
-
-    # DELETE
-    it "should be able to delete posts" do 
-      result = @api.put_wall_post("Hello, world, from the test suite delete method!")
-      object_id_to_delete = result["id"]
-      delete_result = @api.delete_object(object_id_to_delete)
-      delete_result.should == true
-    end
+    get_result = @api.get_object(@temporary_object_id)
+    get_result["name"].should == expected_message
+  end
+        
+  it "should be able to verify a message with an attachment posted to a feed" do
+    attachment = {"name" => "Context Optional", "link" => "http://www.contextoptional.com/"}
+    result = @api.put_wall_post("Hello, world, from the test suite again!", attachment)
+    @temporary_object_id = result["id"]
+    get_result = @api.get_object(@temporary_object_id)
 
-    # additional put tests
-    it "should be able to verify messages posted to a wall" do
-      message = "the cats are asleep"
-      put_result = @api.put_wall_post(message)
-      @temporary_object_id = put_result["id"]
-      get_result = @api.get_object(@temporary_object_id)
-      
-      # make sure the message we sent is the message that got posted
-      get_result["message"].should == message
-    end
+    # make sure the result we fetch includes all the parameters we sent
+    it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
+    it_matches.should == true
+  end
 
-    it "should be able to post a message with an attachment to a feed" do
-      result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "Context Optional", :link => "http://www.contextoptional.com/"})
-      @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
-    end
-    
-    it "should be able to verify a message with an attachment posted to a feed" do
-      attachment = {"name" => "Context Optional", "link" => "http://www.contextoptional.com/"}
-      result = @api.put_wall_post("Hello, world, from the test suite again!", attachment)
-      @temporary_object_id = result["id"]
-      get_result = @api.get_object(@temporary_object_id)
-
-      # make sure the result we fetch includes all the parameters we sent
-      it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
-      it_matches.should == true 
-    end
+  it "should be able to comment on an object" do
+    result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
+    @temporary_object_id = result["id"]
 
-    it "should be able to comment on an object" do
-      result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
-      @temporary_object_id = result["id"]
-      
-      # this will be deleted when the post gets deleted 
-      comment_result = @api.put_comment(@temporary_object_id, "it's my comment!")
-      comment_result.should_not be_nil
-    end
-    
-    it "should be able to verify a comment posted about an object" do
-      message_text = "Hello, world, from the test suite, testing comments!"
-      result = @api.put_wall_post(message_text)
-      @temporary_object_id = result["id"]
-      
-      # this will be deleted when the post gets deleted 
-      comment_text = "it's my comment!"
-      comment_result = @api.put_comment(@temporary_object_id, comment_text)
-      get_result = @api.get_object(comment_result["id"])
-
-      # make sure the text of the comment matches what we sent
-      get_result["message"].should == comment_text
-    end
+    # this will be deleted when the post gets deleted
+    comment_result = @api.put_comment(@temporary_object_id, "it's my comment!")
+    comment_result.should_not be_nil
+  end
 
-    it "should be able to like an object" do
-      result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
-      @temporary_object_id = result["id"]
-      like_result = @api.put_like(@temporary_object_id)
-    end
+  it "should be able to verify a comment posted about an object" do
+    message_text = "Hello, world, from the test suite, testing comments!"
+    result = @api.put_wall_post(message_text)
+    @temporary_object_id = result["id"]
 
-    # SEARCH
-    it "should be able to search" do
-      result = @api.search("facebook")
-      result.length.should be_an(Integer)
-    end
+    # this will be deleted when the post gets deleted
+    comment_text = "it's my comment!"
+    comment_result = @api.put_comment(@temporary_object_id, comment_text)
+    get_result = @api.get_object(comment_result["id"])
 
-    # API
-    # the above tests test this already, but we should consider additional api tests
+    # make sure the text of the comment matches what we sent
+    get_result["message"].should == comment_text
+  end
 
-    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  it "should be able to like an object" do
+    result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
+    @temporary_object_id = result["id"]
+    like_result = @api.put_like(@temporary_object_id)
+    like_result.should be_true
+  end
 end
 
 class FacebookWithAccessTokenTests < Test::Unit::TestCase
   describe "Koala GraphAPI with an access token" do
     include LiveTestingDataHelper
-    it_should_behave_like "Koala GraphAPI with an access token"
-    
+
     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
 end

data/spec/koala/live_testing_data_helper.rb

@@ -19,7 +19,7 @@ module LiveTestingDataHelper
         errors = []
         
         if count > 0
-          print "\nCleaning up #{count} temporary #{count > 1 ? "objects" : "object"}..."
+          print "\nCleaning up #{count} temporary #{count > 1 ? "objects" : "object (#{@temporary_object_ids.first})"}..."
           @temporary_object_ids.each do |id|
             # get our API
             api = @api || (@test_users ? @test_users.graph_api : nil)

data/spec/koala/net_http_service_tests.rb

@@ -5,10 +5,19 @@ class NetHTTPServiceTests < Test::Unit::TestCase
   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
@@ -16,7 +25,7 @@ class NetHTTPServiceTests < Test::Unit::TestCase
         @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 
+        # 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)
 
@@ -31,33 +40,102 @@ class NetHTTPServiceTests < Test::Unit::TestCase
         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)
+      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')
+          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
 
-      it "should use port 443" do
-        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+      describe "if the request has an access token" do
+        before :each do
+          @args = {"access_token" => "123"}
+        end
 
-        Bear.make_request('anything', {}, 'anything')  
+        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
 
-      it "should use SSL" do
-        @http_mock.should_receive('use_ssl=').with(true)
+      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')  
+          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')  
+        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)  
+        Bear.make_request('anything', {}, 'anything', :rest_api => true)
       end
 
       it "should turn off vertificate validaiton warnings" do
@@ -82,7 +160,7 @@ class NetHTTPServiceTests < Test::Unit::TestCase
           path = mock('Path')
           @http_yield_mock.should_receive(:post).with(path, anything).and_return(@http_request_result)
 
-          Bear.make_request(path, {}, 'post')        
+          Bear.make_request(path, {}, 'post')
         end
 
         it "should use encoded parameters" do
@@ -94,6 +172,45 @@ class NetHTTPServiceTests < Test::Unit::TestCase
 
           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
@@ -125,7 +242,7 @@ class NetHTTPServiceTests < Test::Unit::TestCase
         end
 
         it "should return a Koala::Response with the right status" do
-          @response.status.should == @mock_http_response.code  
+          @response.status.should == @mock_http_response.code
         end
 
         it "should reutrn a Koala::Response with the right body" do
@@ -182,5 +299,132 @@ class NetHTTPServiceTests < Test::Unit::TestCase
         end
       end
     end
+    
+    describe "when detecting if multipart posting is needed" do
+      it "should be true if any parameter value requires multipart post" do
+        valid_file_hash = stub("Stub Valid File Hash")
+        
+        Bear.stub!("is_valid_file_hash?").and_return(false)
+        Bear.stub!("is_valid_file_hash?").with(valid_file_hash).and_return(true)
+        
+        args = {
+          "key1" => "val",
+          "key2" => "val",
+          "key3" => valid_file_hash,
+          "key4" => "val"
+        }
+        
+        Bear.params_require_multipart?(args).should be_true
+      end
+      
+      describe "and looking at individual values" do
+        before(:each) do          
+          @valid_hash = {
+            "content_type" => 1,
+            "path" => 1
+          }
+        end
+        
+        it "should only accept hashes" do
+          Bear.is_valid_file_hash?(@valid_hash).should be_true
+          
+          @valid_hash.stub!("kind_of?").with(Hash).and_return(false)
+          Bear.is_valid_file_hash?(@valid_hash).should be_false
+        end
+        
+        it "should always require a content_type key" do
+          @valid_hash.delete("content_type")
+          Bear.is_valid_file_hash?(@valid_hash).should be_false
+        end
+        
+        it "should always require the path key" do
+          @valid_hash.delete("path")
+          Bear.is_valid_file_hash?(@valid_hash).should be_false
+        end
+        
+        describe "with file IOs" do
+          before :each do
+            @stub_file = stub('Stub IO File')
+            @valid_hash["file"] = @stub_file
+          end
+          
+          it "should accept hashes with the file object that responds to read" do
+            @stub_file.should_receive("respond_to?").with(:read).and_return(true)
+          
+            @valid_hash["file"] = @stub_file
+            Bear.is_valid_file_hash?(@valid_hash).should be_true
+          end
+          
+          it "should not accept hashes with a file object that does not respond to read" do
+            @stub_file.should_receive("respond_to?").with(:read).and_return(false)
+          
+            @valid_hash["file"] = @stub_file
+            Bear.is_valid_file_hash?(@valid_hash).should be_false
+          end
+          
+        end
+      end
+    end
+    
+    describe "when encoding multipart/form-data params" do
+      it "should replace valid file hashes with file objects with UploadIO objects" do
+        file_hash_stub = {
+          "path" => "Fake File Name",
+          "content_type" => "Fake Content Type"
+        }
+        
+        # UploadIO should be created
+        uploadio_stub = stub("UploadIO Shell Stub")
+        UploadIO.should_receive("new").with(file_hash_stub["path"], file_hash_stub["content_type"]).and_return(uploadio_stub)
+
+        # Ruby 1.9 test compatibility
+        content_stub = "UploadIOContent Stub"
+        uploadio_stub.stub(:to_ary).and_return([content_stub])
+        
+        args = {
+          "not_a_file" => "not a file",
+          "file" => file_hash_stub
+        }
+        
+        # Check that is_valid_file_hash is called on the file_hash_stub
+        Bear.stub!("is_valid_file_hash?").and_return(false)
+        Bear.should_receive("is_valid_file_hash?").with(file_hash_stub).and_return(true)
+        
+        result = Bear.encode_multipart_params(args)
+        
+        result["not_a_file"] == args["not_a_file"]
+        result["file"] == content_stub
+      end
+
+      it "should replace valid file hashes with file objects with UploadIO objects" do
+        file_hash_stub = {
+          "file" => "Fake File IO",
+          "path" => "Fake File Name",
+          "content_type" => "Fake Content Type"
+        }
+        
+        # UploadIO should be created
+        uploadio_stub = stub("UploadIO Shell Stub")
+        UploadIO.should_receive("new").with(file_hash_stub["file"], file_hash_stub["content_type"], file_hash_stub["path"]).and_return(uploadio_stub)
+
+        # Ruby 1.9 test compatibility
+        content_stub = "UploadIOContent Stub"
+        uploadio_stub.stub(:to_ary).and_return([content_stub])
+        
+        args = {
+          "not_a_file" => "not a file",
+          "file" => file_hash_stub
+        }
+        
+        # Check that is_valid_file_hash is called on the file_hash_stub
+        Bear.stub!("is_valid_file_hash?").and_return(false)
+        Bear.should_receive("is_valid_file_hash?").with(file_hash_stub).and_return(true)
+        
+        result = Bear.encode_multipart_params(args)
+        
+        result["not_a_file"] == args["not_a_file"]
+        result["file"] == content_stub
+      end
+    end
   end
 end