koala 1.0.0 → 1.1.0

data/spec/cases/http_services/typhoeus_service_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
 
-module Deer
-  include Koala::TyphoeusService
-end
+Deer = Koala::TyphoeusService
 
 describe "TyphoeusService" do
 
   describe "TyphoeusService module holder class Deer" do
     before :each do
-      # reset the always_use_ssl parameter
-      Deer.always_use_ssl = nil
+      # reset global settings
+      Deer.always_use_ssl = Deer.proxy = Deer.timeout = nil
     end
 
     it "should define a make_request static module method" do
@@ -29,55 +27,55 @@ describe "TyphoeusService" do
         @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 Deer itself
-        Deer.stub(:post).and_return(@mock_http_response)
-        Deer.stub(:get).and_return(@mock_http_response)
+        Typhoeus::Request.stub(:post).and_return(@mock_http_response)
+        Typhoeus::Request.stub(:get).and_return(@mock_http_response)
       end
 
       it "should use POST if verb is not GET" do
-        Deer.should_receive(:post).and_return(@mock_http_response)
+        Typhoeus::Request.should_receive(:post).and_return(@mock_http_response)
         Deer.make_request('anything', {}, 'anything')
       end
 
       it "should use GET if that verb is specified" do
-        Deer.should_receive(:get).and_return(@mock_http_response)
+        Typhoeus::Request.should_receive(:get).and_return(@mock_http_response)
         Deer.make_request('anything', {}, 'get')
       end
 
       describe "the connection" do
         it "should use SSL if the request has an access token" do
-          Deer.should_receive(:post).with(/https\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
 
           Deer.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
-          Deer.should_receive(:post).with(/https\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
 
           Deer.always_use_ssl = true
           Deer.make_request('anything', {}, 'anything')
         end
 
         it "should use SSL if the :use_ssl option is provided, even if there's no token" do
-          Deer.should_receive(:post).with(/https\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
 
           Deer.always_use_ssl = true
           Deer.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
-          Deer.should_receive(:post).with(/http\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/http\:/, anything)
 
           Deer.make_request('anything', {}, 'anything')
         end
 
         it "should use the graph server by default" do
-          Deer.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
+          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
 
           Deer.make_request('anything', {}, 'anything')
         end
 
         it "should use the REST server if the :rest_api option is true" do
-          Deer.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
+          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
 
           Deer.make_request('anything', {}, 'anything', :rest_api => true)
         end
@@ -85,35 +83,45 @@ describe "TyphoeusService" do
 
       it "should pass the arguments to Typhoeus under the :params key" do
         args = {:a => 2}
-        Deer.should_receive(:post).with(anything, hash_including(:params => args))
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => args))
 
         Deer.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"
-        Deer.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
 
         Deer.make_request('anything', {}, method)
       end
 
       it "should pass :typhoeus_options to Typhoeus if provided" do
         t_options = {:a => :b}
-        Deer.should_receive(:post).with(anything, hash_including(t_options))
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(t_options))
 
         Deer.make_request("anything", {}, "post", :typhoeus_options => t_options)
       end
-      
+
+      it "should pass proxy and timeout :typhoeus_options to Typhoeus if set globally" do
+        Deer.proxy = "http://defaultproxy"
+        Deer.timeout = 20
+
+        t_options = {:proxy => "http://defaultproxy", :timeout => 20}
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(t_options))
+
+        Deer.make_request("anything", {}, "post")
+      end
+
       # 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")}
-        Deer.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
         Deer.make_request("anything", args, :post)
       end
 
       it "should include the path in the request" do
         path = "/a/b/c/1"
-        Deer.should_receive(:post).with(Regexp.new(path), anything)
+        Typhoeus::Request.should_receive(:post).with(Regexp.new(path), anything)
 
         Deer.make_request(path, {}, "post")
       end

data/spec/cases/koala_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "Koala" do
+  it "has an http_service accessor" do
+    Koala.respond_to?(:http_service)
+  end
+
+  it "should let an http service be set" do
+    current_service = Koala.http_service
+    Koala.http_service = Koala::MockHTTPService
+    Koala.http_service.should == Koala::MockHTTPService
+    # reset the service back to the original one (important for live tests)
+    Koala.http_service = current_service
+  end
+
+  it "sets Net::HTTP as the base service" do
+    Koala.base_http_service.should == Koala::NetHTTPService
+  end
+
+  describe ".always_use_ssl" do
+    it "should be added" do
+      # in Ruby 1.8, .methods returns strings
+      # in Ruby 1.9, .method returns symbols 
+      Koala.methods.collect {|m| m.to_sym}.should include(:always_use_ssl)
+      Koala.methods.collect {|m| m.to_sym}.should include(:always_use_ssl=)
+    end
+  end
+
+  describe ".make_request" do
+    
+    before :each do
+      @old_service = Koala.http_service
+      Koala.http_service = Koala::MockHTTPService
+    end
+    
+    after :each do
+      Koala.http_service = @old_service
+    end
+
+    it "should use SSL if Koala.always_use_ssl is set to true, even if there's no token" do
+      Koala.http_service.should_receive(:make_request).with(anything, anything, anything, hash_including(:use_ssl => true))
+
+      Koala.always_use_ssl = true
+      Koala.make_request('anything', {}, 'anything')
+    end
+
+    it "should allow the caller to override the http_service" do
+      http_service = stub
+      http_service.should_receive(:make_request)
+      
+      Koala.make_request(anything, anything, anything, :http_service => http_service)
+    end
+
+  end
+end

data/spec/cases/oauth_spec.rb

@@ -391,7 +391,7 @@ describe "Koala::Facebook::OAuth" do
     # the signed request code is ported directly from Facebook
     # so we only need to test at a high level that it works      
     it "should throw an error if the algorithm is unsupported" do
-      JSON.stub!(:parse).and_return("algorithm" => "my fun algorithm")
+      MultiJson.stub(:decode).and_return("algorithm" => "my fun algorithm")
       lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
     end
     

data/spec/cases/realtime_updates_spec.rb

@@ -43,19 +43,19 @@ describe "Koala::Facebook::RealtimeUpdates" do
     it "should not allow write access to app_id" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       # this should not throw errors
-      lambda { updates.app_id = 2 }.should raise_error(NoMethodError)
+      updates.methods.map(&:to_sym).should_not include(:app_id=)
     end
 
     it "should not allow write access to app_access_token" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       # this should not throw errors
-      lambda { updates.app_access_token = 2 }.should raise_error(NoMethodError)
+      updates.methods.map(&:to_sym).should_not include(:app_access_token=)
     end
   
     it "should not allow write access to secret" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       # this should not throw errors
-      lambda { updates.secret = 2 }.should raise_error(NoMethodError)
+      updates.methods.map(&:to_sym).should_not include(:secret=)
     end
     
     # init with secret / fetching the token

data/spec/cases/test_users_spec.rb

@@ -16,7 +16,7 @@ describe "Koala::Facebook::TestUsers" do
         raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
       end
 
-      @is_mock = defined?(Koala::IS_MOCK) && Koala::IS_MOCK
+      @is_mock = Koala.http_service.respond_to?(:mock?) && Koala.http_service.mock?
     end
 
     describe "when initializing" do

data/spec/cases/uploadable_io_spec.rb

@@ -9,6 +9,21 @@ module Koala::MIME
 end
 
 describe "Koala::UploadableIO" do
+  def rails_3_mocks
+    tempfile = stub('Tempfile', :path => "foo")
+    uploaded_file = stub('ActionDispatch::Http::UploadedFile',
+      :content_type => true,
+      :tempfile => tempfile
+    )
+    tempfile.stub!(:respond_to?).with(:path).and_return(true)
+
+    [tempfile, uploaded_file]
+  end
+  
+  def sinatra_mocks
+    {:type => "type", :tempfile => "Tempfile"}
+  end
+  
   describe "the constructor" do
     describe "when given a file path" do
       before(:each) do
@@ -29,6 +44,12 @@ describe "Koala::UploadableIO" do
           stub_type = @koala_io_params[1] = stub('Content Type')
           Koala::UploadableIO.new(*@koala_io_params).content_type.should == stub_type
         end
+
+        it "should detect that NetHTTPService must be used" do
+          @koala_io_params[0] = mock
+          @koala_io_params[0].stub!(:read)
+          Koala::UploadableIO.new(*@koala_io_params).requires_base_http_service.should be_true
+        end
       end
 
       describe "and no content type" do
@@ -63,13 +84,7 @@ describe "Koala::UploadableIO" do
 
     describe "when given a Rails 3 ActionDispatch::Http::UploadedFile" do
       before(:each) do
-        @tempfile = stub('Tempfile', :path => "foo")
-        @uploaded_file = stub('ActionDispatch::Http::UploadedFile',
-          :content_type => true,
-          :tempfile => @tempfile
-        )
-
-        @tempfile.stub!(:respond_to?).with(:path).and_return(true)
+        @tempfile, @uploaded_file = rails_3_mocks
       end
 
       it "should get the content type via the content_type method" do
@@ -87,10 +102,7 @@ describe "Koala::UploadableIO" do
 
     describe "when given a Sinatra file parameter hash" do
       before(:each) do
-        @file_hash = {
-          :type => "type",
-          :tempfile => "Tempfile"
-        }
+        @file_hash = sinatra_mocks
       end
 
       it "should get the content type from the :type key" do
@@ -130,9 +142,19 @@ describe "Koala::UploadableIO" do
       UploadIO.stub!(:new).with(anything, anything, anything).and_return(@upload_io)
     end
 
-    it "should call the constructor with the content type, file name, and a dummy file name" do
-      UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
-      Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io.should == @upload_io
+    context "if no filename was provided" do
+      it "should call the constructor with the content type, file name, and a dummy file name" do
+        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
+        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io.should == @upload_io
+      end
+    end
+    
+    context "if a filename was provided" do
+      it "should call the constructor with the content type, file name, and the filename" do
+        filename = "file"
+        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", filename).and_return(@upload_io)
+        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type", filename).to_upload_io
+      end
     end
   end
 
@@ -148,4 +170,24 @@ describe "Koala::UploadableIO" do
       Koala::UploadableIO.new(BEACH_BALL_PATH).to_file.should == result
     end
   end
+
+  describe "#binary_content?" do
+    it "returns true for Rails 3 file uploads" do
+      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+    end
+    
+    it "returns true for Sinatra file uploads" do
+      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+    end
+    
+    it "returns true for File objects" do
+      Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH)).should be_true
+    end
+    
+    it "returns false for everything else" do
+      Koala::UploadableIO.binary_content?(StringIO.new).should be_false
+      Koala::UploadableIO.binary_content?(BEACH_BALL_PATH).should be_false
+      Koala::UploadableIO.binary_content?(nil).should be_false
+    end
+  end
 end  # describe UploadableIO

data/spec/fixtures/mock_facebook_responses.yml

@@ -24,6 +24,18 @@ rest_api:
         with_token: '[{"read_stream":1}]' 
         no_token: '{"error_code":104,"error_msg":"Requires valid signature","request_args":[{"key":"method","value":"fql.query"},{"key":"format","value":"json"},{"key":"query","value":"select read_stream from permissions where uid = 216743"}]}'
 
+  /method/fql.multiquery:
+    'queries=<%= MultiJson.encode({"query1" => "select post_id from stream where source_id = me()", "query2" => "select fromid from comment where post_id in (select post_id from #query1)", "query3" => "select uid, name from user where uid in (select fromid from #query2)"}) %>':
+      get: 
+        with_token: '[{"name":"query1", "fql_result_set":[]},{"name":"query2", "fql_result_set":[]},{"name":"query3", "fql_result_set":[]}]'
+        no_token: '{"error_code":104,"error_msg":"Requires valid signature","request_args":[{"key":"method","value":"fql.query"},{"key":"format","value":"json"},{"key":"query","value":"select read_stream from permissions where uid = 216743"}]}'
+    'queries=<%= MultiJson.encode({"query1" => "select first_name from user where uid = 216743", "query2" => "select first_name from user where uid = 2905623"}) %>':
+      get:
+        with_token: '[{"name":"query1", "fql_result_set":[{"first_name":"Chris"}]},{"name":"query2", "fql_result_set":[{"first_name":"Alex"}]}]' 
+        no_token: '[{"name":"query1", "fql_result_set":[{"first_name":"Chris"}]},{"name":"query2", "fql_result_set":[{"first_name":"Alex"}]}]'
+
+
+
 
 # ====== GRAPH API =====
 graph_api:
@@ -49,7 +61,7 @@ graph_api:
     
   test_user_no_perms: &test_user_no_perms
     post:
-      with_token: '{"id": "777777777", "access_token":"<%= ACCESS_TOKEN %>", "login_url":"https://www.facebook.com/platform/test_account.."}'
+      with_token: '{"id": "777777777", "access_token":"<%= APP_ACCESS_TOKEN %>", "login_url":"https://www.facebook.com/platform/test_account.."}'
   
   test_user_befriended: &test_user_befriended
     post:
@@ -59,8 +71,60 @@ graph_api:
   root:
     ids=contextoptional,naitik: 
       get:
-        with_token: '[{}, {}]'
-        no_token: '[{}, {}]'
+        with_token: '{"contextoptional":"{}","naitik":"{}"}'
+        no_token: '{"contextoptional":"{}","naitik":"{}"}'
+    # Ruby 1.8.7 and 1.9.2 generate JSON with different key ordering, hence we have to dynamically generate it here 
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "koppel"}]) %>:
+      post:
+        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"id\":\"456\"}"}]'
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/picture"}]) %>:
+      post:
+        with_token: '[{"headers":[{"name":"Location","value":"http://google.com"}]}]'
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "me/friends"}]) %>:
+      post:
+        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[]}"}]'
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me"}, {"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
+      post:
+        with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[]}"}]'
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights"}, {"method"=>"get", "relative_url"=>"koppel?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
+      post:
+        with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},{"body":"{\"id\":\"123\"}"}]'
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"FEED_ITEM_BATCH/likes"}, {"method"=>"delete", "relative_url"=> "FEED_ITEM_BATCH"}]) %>:
+      post:
+        with_token: '[{"body": "{\"id\": \"MOCK_LIKE\"}"},{"body":true}]'
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
+      post:
+        with_token: '[null,{"body":"{}"}]'
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends", "omit_response_on_success" => false}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
+      post:
+        with_token: '[{"body":"{\"data\":[]}"},{"body":"{}"}]'
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=i-dont-exist:$.data.*.id}"}"}]) %>:
+      post:
+        with_token: '{"error":190,"error_description":"Error validating access token."}'
+    batch=<%= MultiJson.encode([{"method" => "post", "relative_url" => "method/fql.query", "body" => "query=select+name+from+user+where+uid%3D4"}]) %>:
+      post:
+        with_token: '[{"body":"[{\"name\":\"Mark Zuckerberg\"}]"}]'
+      
+    # dependencies
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me", "name" => "getme"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getme"}]) %>:
+      post: &batch_dependent
+        with_token: '[null,{"body":"{\"id\":\"123\"}"}]'  
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights", "name" => "getdata"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getdata"}]) %>:
+      post:
+        with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
+  
+    # attached files tests
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
+      post:
+        with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
+      post:
+        with_token: '[{"body":"{\"id\": \"MOCK_PHOTO\"}"}]'
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}, {"method"=>"post", "relative_url"=>"koppel/photos", "attached_files" => "op2_file0"}]) %>&op1_file0=[FILE]&op2_file0=[FILE]:
+      post:
+        with_token: '[{"body":"{\"id\": \"MOCK_PHOTO\"}"}, {"body":"{\"id\": \"MOCK_PHOTO\"}"}]'
+
+
   /me:
     no_args:
       get:
@@ -83,6 +147,9 @@ graph_api:
     message=Hello, world, from the test suite delete method!: 
       post: 
         with_token: '{"id": "FEED_ITEM_DELETE"}'
+    message=Hello, world, from the test suite batch API!: 
+      post: 
+        with_token: '{"id": "FEED_ITEM_BATCH"}'
     link=http://oauth.twoalex.com/&message=Hello, world, from the test suite again!&name=OAuth Playground:
       post:
         with_token: '{"id": "FEED_ITEM_CONTEXT"}'
@@ -95,6 +162,16 @@ graph_api:
       post:
         <<: *token_required
         with_token: '{"id": "MOCK_PHOTO"}'
+  /me/videos:
+    source=[FILE]:
+      post:
+        <<: *token_required
+        with_token: '{"id": "MOCK_PHOTO"}'
+    message=This is the test message&source=[FILE]:
+      post:
+        <<: *token_required
+        with_token: '{"id": "MOCK_PHOTO"}'
+
   /koppel:
     no_args:
       get:
@@ -144,6 +221,24 @@ graph_api:
           headers:
             Location: http://facebook.com/
 
+  /comments:
+    ids=http://developers.facebook.com/blog/post/472:
+      get: 
+        with_token: '{"http://developers.facebook.com/blog/post/472": []}'
+        no_token: '{"http://developers.facebook.com/blog/post/472": []}'
+    ids=http://developers.facebook.com/blog/post/490,http://developers.facebook.com/blog/post/472:
+      get: 
+        with_token: '{"http://developers.facebook.com/blog/post/490": [], "http://developers.facebook.com/blog/post/472": []}'
+        no_token: '{"http://developers.facebook.com/blog/post/490": [], "http://developers.facebook.com/blog/post/472": []}'
+    ids=:
+      get:
+        body: '{"error": {"type": "OAuthException","message": "Cannot specify an empty identifier"}}'
+        code: 400
+    no_args:
+      get:
+        body: '{"error": {"type": "Exception","message": "No node specified"}}'
+        code: 500        
+
   /search:
     q=facebook:
       get: 
@@ -169,7 +264,7 @@ graph_api:
         <<: *oauth_error
     client_id=<%= APP_ID %>&client_secret=<%= SECRET %>&type=client_cred:
       post:
-        no_token: access_token=<%= ACCESS_TOKEN %>
+        no_token: access_token=<%= APP_ACCESS_TOKEN %>
   /oauth/exchange_sessions:
     client_id=<%= APP_ID %>&client_secret=<%= SECRET %>&sessions=<%= OAUTH_DATA["session_key"] %>&type=client_cred: 
       post:
@@ -311,4 +406,4 @@ graph_api:
 
   /777777777:
     no_args:
-      <<: *item_deleted
+      <<: *item_deleted

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 begin
   require 'bundler/setup'
 rescue LoadError
-  puts 'although not required, bundler is recommened for running the tests'
+  puts 'Although not required, bundler is recommended for running the tests.'
 end
 
 # load the libraries
@@ -9,6 +9,7 @@ require 'koala'
 
 # load testing data libraries
 require 'support/live_testing_data_helper'
+require 'support/json_testing_fix' # ensure consistent to_json behavior
 require 'support/mock_http_service'
 require 'support/rest_api_shared_examples'
 require 'support/graph_api_shared_examples'