koala 1.8.0 → 1.9.0rc1

data/spec/cases/uploadable_io_spec.rb

@@ -16,7 +16,7 @@ describe "Koala::UploadableIO" do
       :tempfile => tempfile,
       :original_filename => "bar"
     )
-    tempfile.stub(:respond_to?).with(:path).and_return(true)
+    allow(tempfile).to receive(:respond_to?).with(:path).and_return(true)
 
     [tempfile, uploaded_file]
   end
@@ -39,15 +39,15 @@ describe "Koala::UploadableIO" do
         end
 
         it "returns an UploadIO with the same file path" do
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @path
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path).to eq(@path)
         end
 
         it "returns an UploadIO with the same content type" do
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == @stub_type
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(@stub_type)
         end
 
         it "returns an UploadIO with the file's name" do
-          Koala::UploadableIO.new(*@koala_io_params).filename.should == File.basename(@path)
+          expect(Koala::UploadableIO.new(*@koala_io_params).filename).to eq(File.basename(@path))
         end
       end
 
@@ -68,16 +68,16 @@ describe "Koala::UploadableIO" do
         end
 
         it "returns an UploadIO with the same io" do
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @koala_io_params[0]
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path).to eq(@koala_io_params[0])
         end
 
         it "returns an UploadableIO with the same content_type" do
           content_stub = @koala_io_params[1] = double('Content Type')
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(content_stub)
         end
 
         it "returns an UploadableIO with the right filename" do
-          Koala::UploadableIO.new(*@koala_io_params).filename.should == File.basename(@file.path)
+          expect(Koala::UploadableIO.new(*@koala_io_params).filename).to eq(File.basename(@file.path))
         end
       end
 
@@ -100,16 +100,16 @@ describe "Koala::UploadableIO" do
 
         it "returns an UploadIO with the same io" do
           #Problem comparing Tempfile in Ruby 1.8, REE and Rubinius mode 1.8
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.path.should == @koala_io_params[0].path
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path.path).to eq(@koala_io_params[0].path)
         end
 
         it "returns an UploadableIO with the same content_type" do
           content_stub = @koala_io_params[1] = double('Content Type')
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(content_stub)
         end
 
         it "returns an UploadableIO with the right filename" do
-          Koala::UploadableIO.new(*@koala_io_params).filename.should == File.basename(@file.path)
+          expect(Koala::UploadableIO.new(*@koala_io_params).filename).to eq(File.basename(@file.path))
         end
       end
 
@@ -130,18 +130,18 @@ describe "Koala::UploadableIO" do
         end
 
         it "returns an UploadableIO with the same io" do
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @koala_io_params[0]
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path).to eq(@koala_io_params[0])
         end
 
         it "returns an UploadableIO with the same content_type" do
           content_stub = @koala_io_params[1] = double('Content Type')
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(content_stub)
         end
       end
 
       describe "and no content type" do
         it "raises an exception" do
-          lambda { Koala::UploadableIO.new(*@koala_io_params) }.should raise_exception(Koala::KoalaError)
+          expect { Koala::UploadableIO.new(*@koala_io_params) }.to raise_exception(Koala::KoalaError)
         end
       end
     end
@@ -153,18 +153,18 @@ describe "Koala::UploadableIO" do
 
       it "gets the path from the tempfile associated with the UploadedFile" do
         expected_path = double('Tempfile')
-        @tempfile.should_receive(:path).and_return(expected_path)
-        Koala::UploadableIO.new(@uploaded_file).io_or_path.should == expected_path
+        expect(@tempfile).to receive(:path).and_return(expected_path)
+        expect(Koala::UploadableIO.new(@uploaded_file).io_or_path).to eq(expected_path)
       end
 
       it "gets the content type via the content_type method" do
         expected_content_type = double('Content Type')
-        @uploaded_file.should_receive(:content_type).and_return(expected_content_type)
-        Koala::UploadableIO.new(@uploaded_file).content_type.should == expected_content_type
+        expect(@uploaded_file).to receive(:content_type).and_return(expected_content_type)
+        expect(Koala::UploadableIO.new(@uploaded_file).content_type).to eq(expected_content_type)
       end
 
       it "gets the filename from the UploadedFile" do
-        Koala::UploadableIO.new(@uploaded_file).filename.should == @uploaded_file.original_filename
+        expect(Koala::UploadableIO.new(@uploaded_file).filename).to eq(@uploaded_file.original_filename)
       end
     end
 
@@ -178,7 +178,7 @@ describe "Koala::UploadableIO" do
         @file_hash[:tempfile] = expected_file
 
         uploadable = Koala::UploadableIO.new(@file_hash)
-        uploadable.io_or_path.should == expected_file
+        expect(uploadable.io_or_path).to eq(expected_file)
       end
 
       it "gets the content type from the :type key" do
@@ -186,12 +186,12 @@ describe "Koala::UploadableIO" do
         @file_hash[:type] = expected_content_type
 
         uploadable = Koala::UploadableIO.new(@file_hash)
-        uploadable.content_type.should == expected_content_type
+        expect(uploadable.content_type).to eq(expected_content_type)
       end
 
       it "gets the content type from the :type key" do
         uploadable = Koala::UploadableIO.new(@file_hash)
-        uploadable.filename.should == @file_hash[:filename]
+        expect(uploadable.filename).to eq(@file_hash[:filename])
       end
     end
 
@@ -199,12 +199,12 @@ describe "Koala::UploadableIO" do
       # what that means is tested below
       it "should accept a file object alone" do
         params = [BEACH_BALL_PATH]
-        lambda { Koala::UploadableIO.new(*params) }.should_not raise_exception
+        expect { Koala::UploadableIO.new(*params) }.not_to raise_exception
       end
 
       it "should accept a file path alone" do
         params = [BEACH_BALL_PATH]
-        lambda { Koala::UploadableIO.new(*params) }.should_not raise_exception
+        expect { Koala::UploadableIO.new(*params) }.not_to raise_exception
       end
     end
   end
@@ -212,20 +212,20 @@ describe "Koala::UploadableIO" do
   describe "getting an UploadableIO" do
     before(:each) do
       @upload_io = double("UploadIO")
-      UploadIO.stub(:new).with(anything, anything, anything).and_return(@upload_io)
+      allow(UploadIO).to receive(:new).with(anything, anything, anything).and_return(@upload_io)
     end
 
     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
+        expect(UploadIO).to receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
+        expect(Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io).to eq(@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)
+        expect(UploadIO).to 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
@@ -234,33 +234,33 @@ describe "Koala::UploadableIO" do
   describe "getting a file" do
     it "returns the File if initialized with a file" do
       f = File.new(BEACH_BALL_PATH)
-      Koala::UploadableIO.new(f).to_file.should == f
+      expect(Koala::UploadableIO.new(f).to_file).to eq(f)
     end
 
     it "should open up and return a file corresponding to the path if io_or_path is a path" do
       result = double("File")
-      File.should_receive(:open).with(BEACH_BALL_PATH).and_return(result)
-      Koala::UploadableIO.new(BEACH_BALL_PATH).to_file.should == result
+      expect(File).to receive(:open).with(BEACH_BALL_PATH).and_return(result)
+      expect(Koala::UploadableIO.new(BEACH_BALL_PATH).to_file).to eq(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
+      expect(Koala::UploadableIO.binary_content?(rails_3_mocks.last)).to be_truthy
     end
 
     it "returns true for Sinatra file uploads" do
-      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+      expect(Koala::UploadableIO.binary_content?(rails_3_mocks.last)).to be_truthy
     end
 
     it "returns true for File objects" do
-      Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH)).should be_true
+      expect(Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH))).to be_truthy
     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
+      expect(Koala::UploadableIO.binary_content?(StringIO.new)).to be_falsey
+      expect(Koala::UploadableIO.binary_content?(BEACH_BALL_PATH)).to be_falsey
+      expect(Koala::UploadableIO.binary_content?(nil)).to be_falsey
     end
   end
 end  # describe UploadableIO

data/spec/cases/utils_spec.rb

@@ -4,29 +4,29 @@ describe Koala::Utils do
   describe ".deprecate" do    
     before :each do
       # unstub deprecate so we can test it
-      Koala::Utils.unstub(:deprecate)
+       allow(Koala::Utils).to receive(:deprecate).and_call_original
     end
     
     it "has a deprecation prefix that includes the words Koala and deprecation" do
-      Koala::Utils::DEPRECATION_PREFIX.should =~ /koala/i
-      Koala::Utils::DEPRECATION_PREFIX.should =~ /deprecation/i      
+      expect(Koala::Utils::DEPRECATION_PREFIX).to match(/koala/i)
+      expect(Koala::Utils::DEPRECATION_PREFIX).to match(/deprecation/i)      
     end
     
     it "prints a warning with Kernel.warn" do
       message = Time.now.to_s + rand.to_s
-      Kernel.should_receive(:warn)
+      expect(Kernel).to receive(:warn)
       Koala::Utils.deprecate(message)
     end
 
     it "prints the deprecation prefix and the warning" do
       message = Time.now.to_s + rand.to_s
-      Kernel.should_receive(:warn).with(Koala::Utils::DEPRECATION_PREFIX + message)
+      expect(Kernel).to receive(:warn).with(Koala::Utils::DEPRECATION_PREFIX + message)
       Koala::Utils.deprecate(message)
     end
     
     it "only prints each unique message once" do
       message = Time.now.to_s + rand.to_s
-      Kernel.should_receive(:warn).once
+      expect(Kernel).to receive(:warn).once
       Koala::Utils.deprecate(message)
       Koala::Utils.deprecate(message)
     end
@@ -34,20 +34,20 @@ describe Koala::Utils do
   
   describe ".logger" do
     it "has an accessor for logger" do
-      Koala::Utils.methods.map(&:to_sym).should include(:logger)
-      Koala::Utils.methods.map(&:to_sym).should include(:logger=)
+      expect(Koala::Utils.methods.map(&:to_sym)).to include(:logger)
+      expect(Koala::Utils.methods.map(&:to_sym)).to include(:logger=)
     end
     
     it "defaults to the standard ruby logger with level set to ERROR" do |variable|
-      Koala::Utils.logger.should be_kind_of(Logger)
-      Koala::Utils.logger.level.should == Logger::ERROR
+      expect(Koala::Utils.logger).to be_kind_of(Logger)
+      expect(Koala::Utils.logger.level).to eq(Logger::ERROR)
     end
     
     logger_methods = [:debug, :info, :warn, :error, :fatal]
     
     logger_methods.each do |logger_method|
       it "should delegate #{logger_method} to the attached logger" do
-        Koala::Utils.logger.should_receive(logger_method)
+        expect(Koala::Utils.logger).to receive(logger_method)
         Koala::Utils.send(logger_method, "Test #{logger_method} message")
       end
     end

data/spec/spec_helper.rb

@@ -1,22 +1,3 @@
-if RUBY_VERSION == '1.9.2' && RUBY_PATCHLEVEL < 290 && RUBY_ENGINE != "macruby"
-  # In Ruby 1.9.2 versions before patchlevel 290, the default Psych
-  # parser has an issue with YAML merge keys, which
-  # fixtures/mock_facebook_responses.yml relies heavily on.
-  #
-  # Anyone using an earlier version will see missing mock response
-  # errors when running the test suite similar to this:
-  #
-  # RuntimeError:
-  #   Missing a mock response for graph_api: /me/videos: source=[FILE]: post: with_token
-  #   API PATH: /me/videos?source=[FILE]&format=json&access_token=*
-  #
-  # For now, it seems the best fix is to just downgrade to the old syck YAML parser
-  # for these troubled versions.
-  #
-  # See https://github.com/tenderlove/psych/issues/8 for more details
-  YAML::ENGINE.yamler = 'syck'
-end
-
 # load the library
 require 'koala'
 

data/spec/support/custom_matchers.rb

@@ -7,14 +7,14 @@ RSpec::Matchers.define :match_url do |url|
     original_query_hash = query_to_params(original_query_string)
 
     # the base URLs need to match
-    base.should == original_base
+    expect(base).to eq(original_base)
     
     # the number of parameters should match (avoid one being a subset of the other)
-    query_hash.values.length.should == original_query_hash.values.length
+    expect(query_hash.values.length).to eq(original_query_hash.values.length)
     
     # and ensure all the keys and values match
     query_hash.each_pair do |key, value|
-      original_query_hash[key].should == value
+      expect(original_query_hash[key]).to eq(value)
     end
   end
   

data/spec/support/graph_api_shared_examples.rb

@@ -3,7 +3,7 @@ shared_examples_for "Koala GraphAPI" do
 
   # API
   it "never uses the rest api server" do
-    Koala.should_receive(:make_request).with(
+    expect(Koala).to receive(:make_request).with(
       anything,
       anything,
       anything,
@@ -16,42 +16,45 @@ shared_examples_for "Koala GraphAPI" do
   # GRAPH CALL
   describe "graph_call" do
     it "passes all arguments to the api method" do
-      args = [KoalaTest.user1, {}, "get", {:a => :b}]
-      @api.should_receive(:api).with(*args)
-      @api.graph_call(*args)
+      user = KoalaTest.user1
+      args = {}
+      verb = 'get'
+      opts = {:a => :b}
+      expect(@api).to receive(:api).with(user, args, verb, opts)
+      @api.graph_call(user, args, verb, opts)
     end
 
     it "throws an APIError if the result hash has an error key" do
-      Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(500, '{"error": "An error occurred!"}', {}))
-      lambda { @api.graph_call(KoalaTest.user1, {}) }.should raise_exception(Koala::Facebook::APIError)
+      allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, '{"error": "An error occurred!"}', {}))
+      expect { @api.graph_call(KoalaTest.user1, {}) }.to raise_exception(Koala::Facebook::APIError)
     end
 
     it "passes the results through GraphCollection.evaluate" do
       result = {}
-      @api.stub(:api).and_return(result)
-      Koala::Facebook::GraphCollection.should_receive(:evaluate).with(result, @api)
+      allow(@api).to receive(:api).and_return(result)
+      expect(Koala::Facebook::GraphCollection).to receive(:evaluate).with(result, @api)
       @api.graph_call("/me")
     end
 
     it "returns the results of GraphCollection.evaluate" do
       expected = {}
-      @api.stub(:api).and_return([])
-      Koala::Facebook::GraphCollection.should_receive(:evaluate).and_return(expected)
-      @api.graph_call("/me").should == expected
+      allow(@api).to receive(:api).and_return([])
+      expect(Koala::Facebook::GraphCollection).to receive(:evaluate).and_return(expected)
+      expect(@api.graph_call("/me")).to eq(expected)
     end
 
     it "returns the post_processing block's results if one is supplied" do
       other_result = [:a, 2, :three]
       block = Proc.new {|r| other_result}
-      @api.stub(:api).and_return({})
-      @api.graph_call("/me", {}, "get", {}, &block).should == other_result
+      allow(@api).to receive(:api).and_return({})
+      expect(@api.graph_call("/me", {}, "get", {}, &block)).to eq(other_result)
     end
   end
 
   # SEARCH
   it "can search" do
     result = @api.search("facebook")
-    result.length.should be_an(Integer)
+    expect(result.length).to be_an(Integer)
   end
 
   # DATA
@@ -61,71 +64,71 @@ shared_examples_for "Koala GraphAPI" do
   it "gets public data about a user" do
     result = @api.get_object(KoalaTest.user1)
     # the results should have an ID and a name, among other things
-    (result["id"] && result["name"]).should_not be_nil
+    expect(result["id"] && result["name"]).not_to be_nil
   end
 
   it "gets public data about a Page" do
     result = @api.get_object(KoalaTest.page)
     # the results should have an ID and a name, among other things
-    (result["id"] && result["name"]).should
+    expect(result["id"] && result["name"]).to be_truthy
   end
 
   it "returns [] from get_objects if passed an empty array" do
     results = @api.get_objects([])
-    results.should == []
+    expect(results).to eq([])
   end
 
   it "gets multiple objects" do
     results = @api.get_objects([KoalaTest.page, KoalaTest.user1])
-    results.should have(2).items
+    expect(results.size).to eq(2)
   end
 
   it "gets multiple objects if they're a string" do
     results = @api.get_objects("facebook,#{KoalaTest.user1}")
-    results.should have(2).items
+    expect(results.size).to eq(2)
   end
 
   describe "#get_picture" do
     it "can access a user's picture" do
-      @api.get_picture(KoalaTest.user2).should =~ /http[s]*\:\/\//
+      expect(@api.get_picture(KoalaTest.user2)).to match(/http[s]*\:\/\//)
     end
 
     it "can access a user's picture, given a picture type"  do
-      @api.get_picture(KoalaTest.user2, {:type => 'large'}).should =~ /^http[s]*\:\/\//
+      expect(@api.get_picture(KoalaTest.user2, {:type => 'large'})).to match(/^http[s]*\:\/\//)
     end
 
     it "works even if Facebook returns nil" do
-      @api.stub(:graph_call).and_return(nil)
-      @api.get_picture(KoalaTest.user2, {:type => 'large'}).should be_nil
+      allow(@api).to receive(:graph_call).and_return(nil)
+      expect(@api.get_picture(KoalaTest.user2, {:type => 'large'})).to be_nil
     end
   end
 
   it "can access connections from public Pages" do
     result = @api.get_connections(KoalaTest.page, "photos")
-    result.should be_a(Array)
+    expect(result).to be_a(Array)
   end
 
   it "can access comments for a URL" do
     result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/472"])
-    (result["http://developers.facebook.com/blog/post/472"]).should
+    expect(result["http://developers.facebook.com/blog/post/472"]).to be_truthy
   end
 
   it "can access comments for 2 URLs" do
     result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/490", "http://developers.facebook.com/blog/post/472"])
-    (result["http://developers.facebook.com/blog/post/490"] && result["http://developers.facebook.com/blog/post/472"]).should
+    expect(result["http://developers.facebook.com/blog/post/490"] && result["http://developers.facebook.com/blog/post/472"]).to be_truthy
   end
 
   # SEARCH
   it "can search" do
     result = @api.search("facebook")
-    result.length.should be_an(Integer)
+    expect(result.length).to be_an(Integer)
   end
 
   # PAGING THROUGH COLLECTIONS
   # see also graph_collection_tests
   it "makes a request for a page when provided a specific set of page params" do
     query = [1, 2]
-    @api.should_receive(:graph_call).with(*query)
+    expect(@api).to receive(:graph_call).with(*query)
     @api.get_page(query)
   end
 
@@ -133,41 +136,41 @@ shared_examples_for "Koala GraphAPI" do
   it "can use the beta tier" do
     result = @api.get_object(KoalaTest.user1, {}, :beta => true)
     # the results should have an ID and a name, among other things
-    (result["id"] && result["name"]).should_not be_nil
+    expect(result["id"] && result["name"]).to be_truthy
   end
 
   # FQL
   describe "#fql_query" do
     it "makes a request to /fql" do
-      @api.should_receive(:get_object).with("fql", anything, anything)
+      expect(@api).to receive(:get_object).with("fql", anything, anything)
       @api.fql_query double('query string')
     end
 
     it "passes a query argument" do
       query = double('query string')
-      @api.should_receive(:get_object).with(anything, hash_including(:q => query), anything)
+      expect(@api).to receive(:get_object).with(anything, hash_including(:q => query), anything)
       @api.fql_query(query)
     end
 
     it "passes on any other arguments provided" do
       args = {:a => 2}
-      @api.should_receive(:get_object).with(anything, hash_including(args), anything)
+      expect(@api).to receive(:get_object).with(anything, hash_including(args), anything)
       @api.fql_query("a query", args)
     end
   end
 
   describe "#fql_multiquery" do
     it "makes a request to /fql" do
-      @api.should_receive(:get_object).with("fql", anything, anything)
+      expect(@api).to receive(:get_object).with("fql", anything, anything)
       @api.fql_multiquery 'query string'
     end
 
     it "passes a queries argument" do
       queries = double('query string')
       queries_json = "some JSON"
-      MultiJson.stub(:dump).with(queries).and_return(queries_json)
+      allow(MultiJson).to receive(:dump).with(queries).and_return(queries_json)
 
-      @api.should_receive(:get_object).with(anything, hash_including(:q => queries_json), anything)
+      expect(@api).to receive(:get_object).with(anything, hash_including(:q => queries_json), anything)
       @api.fql_multiquery(queries)
     end
 
@@ -181,14 +184,14 @@ shared_examples_for "Koala GraphAPI" do
         "query2" => [:a, :b, :c]
       }
 
-      @api.stub(:get_object).and_return(raw_results)
+      allow(@api).to receive(:get_object).and_return(raw_results)
       results = @api.fql_multiquery({:query => true})
-      results.should == expected_results
+      expect(results).to eq(expected_results)
     end
 
     it "passes on any other arguments provided" do
       args = {:a => 2}
-      @api.should_receive(:get_object).with(anything, hash_including(args), anything)
+      expect(@api).to receive(:get_object).with(anything, hash_including(args), anything)
       @api.fql_multiquery("a query", args)
     end
   end
@@ -199,28 +202,28 @@ shared_examples_for "Koala GraphAPI with an access token" do
   it "gets private data about a user" do
     result = @api.get_object(KoalaTest.user1)
     # updated_time should be a pretty fixed test case
-    result["updated_time"].should_not be_nil
+    expect(result["updated_time"]).not_to be_nil
   end
 
   it "gets data about 'me'" do
     result = @api.get_object("me")
-    result["updated_time"].should
+    expect(result["updated_time"]).to be_truthy
   end
 
   it "gets multiple objects" do
     result = @api.get_objects([KoalaTest.page, KoalaTest.user1])
-    result.length.should == 2
+    expect(result.length).to eq(2)
   end
   it "can access connections from users" do
     result = @api.get_connections(KoalaTest.user2, "friends")
-    result.length.should > 0
+    expect(result.length).to be > 0
   end
 
   # PUT
   it "can 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
+    expect(@temporary_object_id).not_to be_nil
   end
 
   # DELETE
@@ -228,7 +231,7 @@ shared_examples_for "Koala GraphAPI with an access token" 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
+    expect(delete_result).to eq(true)
   end
 
   it "can delete likes" do
@@ -236,7 +239,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     @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
+    expect(delete_like_result).to eq(true)
   end
 
   # additional put tests
@@ -247,13 +250,13 @@ shared_examples_for "Koala GraphAPI with an access token" do
     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
+    expect(get_result["message"]).to eq(message)
   end
 
   it "can post a message with an attachment to a feed" do
     result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"})
     @temporary_object_id = result["id"]
-    @temporary_object_id.should_not be_nil
+    expect(@temporary_object_id).not_to be_nil
   end
 
   it "can post a message whose attachment has a properties dictionary" do
@@ -271,11 +274,11 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
     result = @api.put_wall_post("body", args)
     @temporary_object_id = result["id"]
-    @temporary_object_id.should_not be_nil
+    expect(@temporary_object_id).not_to be_nil
 
     # ensure the properties dictionary is there
     api_data = @api.get_object(@temporary_object_id)
-    api_data["properties"].should_not be_nil
+    expect(api_data["properties"]).not_to be_nil
   end
 
   describe "#put_picture" do
@@ -285,7 +288,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
       result = @api.put_picture(file, content_type)
       @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
+      expect(@temporary_object_id).not_to be_nil
     end
 
     it "can post photos to the user's wall without an open file object" do
@@ -294,7 +297,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
       result = @api.put_picture(file_path, content_type)
       @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
+      expect(@temporary_object_id).not_to be_nil
     end
 
     it "can verify a photo posted to a user's wall" do
@@ -305,10 +308,10 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
       result = @api.put_picture(file_path, content_type, :message => expected_message)
       @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
+      expect(@temporary_object_id).not_to be_nil
 
       get_result = @api.get_object(@temporary_object_id)
-      get_result["name"].should == expected_message
+      expect(get_result["name"]).to eq(expected_message)
     end
 
 
@@ -320,13 +323,13 @@ shared_examples_for "Koala GraphAPI with an access token" do
       it "can post photo to the user's wall using a URL" do
         result = @api.put_picture(@url)
         @temporary_object_id = result["id"]
-        @temporary_object_id.should_not be_nil
+        expect(@temporary_object_id).not_to be_nil
       end
 
       it "can post photo to the user's wall using a URL and an additional param" do
         result = @api.put_picture(@url, :message => "my message")
         @temporary_object_id = result["id"]
-        @temporary_object_id.should_not be_nil
+        expect(@temporary_object_id).not_to be_nil
       end
     end
   end
@@ -339,9 +342,9 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
     it "sets options[:video] to true" do
       source = double("UploadIO")
-      Koala::UploadableIO.stub(:new).and_return(source)
-      source.stub(:requires_base_http_service).and_return(false)
-      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::HTTPService::Response.new(200, "[]", {}))
+      allow(Koala::UploadableIO).to receive(:new).and_return(source)
+      allow(source).to receive(:requires_base_http_service).and_return(false)
+      expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::HTTPService::Response.new(200, "[]", {}))
       @api.put_video("foo")
     end
 
@@ -350,13 +353,13 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
       result = @api.put_video(file, @content_type)
       @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
+      expect(@temporary_object_id).not_to be_nil
     end
 
     it "can post videos to the user's wall without an open file object" do
       result = @api.put_video(@cat_movie, @content_type)
       @temporary_object_id = result["id"]
-      @temporary_object_id.should_not be_nil
+      expect(@temporary_object_id).not_to be_nil
     end
 
     # note: Facebook doesn't post videos immediately to the wall, due to processing time
@@ -372,7 +375,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
     # 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
+    expect(it_matches).to eq(true)
   end
 
   it "can comment on an object" do
@@ -381,7 +384,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
     # 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
+    expect(comment_result).not_to be_nil
   end
 
   it "can verify a comment posted about an object" do
@@ -395,38 +398,38 @@ shared_examples_for "Koala GraphAPI with an access token" do
     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
+    expect(get_result["message"]).to eq(comment_text)
   end
 
   it "can like an object" do
     result = @api.put_wall_post("Hello, world, from the test suite, testing liking!")
     @temporary_object_id = result["id"]
     like_result = @api.put_like(@temporary_object_id)
-    like_result.should be_true
+    expect(like_result).to be_truthy
   end
 
   # Page Access Token Support
   describe "#get_page_access_token" do
     it "gets the page object with the access_token field" do
       # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
-      @api.should_receive(:api).with("my_page", hash_including({:fields => "access_token"}), "get", anything)
+      expect(@api).to receive(:api).with("my_page", hash_including({:fields => "access_token"}), "get", anything)
       @api.get_page_access_token("my_page")
     end
 
     it "merges in any other arguments" do
       # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
       args = {:a => 3}
-      @api.should_receive(:api).with("my_page", hash_including(args), "get", anything)
+      expect(@api).to receive(:api).with("my_page", hash_including(args), "get", anything)
       @api.get_page_access_token("my_page", args)
     end
   end
 
   it "can get information about an access token" do
     result = @api.debug_token(KoalaTest.app_access_token)
-    result.should be_kind_of(Hash)
-    result["data"].should be_kind_of(Hash)
-    result["data"]["app_id"].to_s.should == KoalaTest.app_id.to_s
-    result["data"]["application"].should_not be_nil
+    expect(result).to be_kind_of(Hash)
+    expect(result["data"]).to be_kind_of(Hash)
+    expect(result["data"]["app_id"].to_s).to eq(KoalaTest.app_id.to_s)
+    expect(result["data"]["application"]).not_to be_nil
   end
 
   describe "#set_app_restrictions" do
@@ -438,31 +441,31 @@ shared_examples_for "Koala GraphAPI with an access token" do
     end
 
     it "makes a POST to /app_id" do
-      @app_api.should_receive(:graph_call).with(KoalaTest.app_id, anything, "post", anything)
+      expect(@app_api).to receive(:graph_call).with(KoalaTest.app_id, anything, "post", anything)
       @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)
     end
 
     it "JSON-encodes the restrictions" do
-      @app_api.should_receive(:graph_call).with(anything, hash_including(:restrictions => MultiJson.dump(@restrictions)), anything, anything)
+      expect(@app_api).to receive(:graph_call).with(anything, hash_including(:restrictions => MultiJson.dump(@restrictions)), anything, anything)
       @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)
     end
 
     it "includes the other arguments" do
       args = {:a => 2}
-      @app_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
+      expect(@app_api).to receive(:graph_call).with(anything, hash_including(args), anything, anything)
       @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions, args)
     end
 
     it "works" do
-      @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions).should be_true
+      expect(@app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)).to be_truthy
     end
   end
 
   it "can access public information via FQL" do
     result = @api.fql_query("select uid, first_name from user where uid = #{KoalaTest.user2_id}")
-    result.size.should == 1
-    result.first['first_name'].should == KoalaTest.user2_name
-    result.first['uid'].should == KoalaTest.user2_id.to_i
+    expect(result.size).to eq(1)
+    expect(result.first['first_name']).to eq(KoalaTest.user2_name)
+    expect(result.first['uid']).to eq(KoalaTest.user2_id.to_i)
   end
 
   it "can access public information via FQL.multiquery" do
@@ -470,11 +473,11 @@ shared_examples_for "Koala GraphAPI with an access token" do
       :query1 => "select uid, first_name from user where uid = #{KoalaTest.user2_id}",
       :query2 => "select uid, first_name from user where uid = #{KoalaTest.user1_id}"
     )
-    result.size.should == 2
+    expect(result.size).to eq(2)
     # this should check for first_name, but there's an FB bug currently
-    result["query1"].first['uid'].should == KoalaTest.user2_id.to_i
+    expect(result["query1"].first['uid']).to eq(KoalaTest.user2_id.to_i)
     # result["query1"].first['first_name'].should == KoalaTest.user2_name
-    result["query2"].first['first_name'].should == KoalaTest.user1_name
+    expect(result["query2"].first['first_name']).to eq(KoalaTest.user1_name)
   end
 
   it "can access protected information via FQL" do
@@ -488,9 +491,9 @@ shared_examples_for "Koala GraphAPI with an access token" do
     # now send a query about your permissions
     result = @api.fql_query("select read_stream from permissions where uid = #{id}")
 
-    result.size.should == 1
+    expect(result.size).to eq(1)
     # we've verified that you have read_stream permissions, so we can test against that
-    result.first["read_stream"].should == 1
+    expect(result.first["read_stream"]).to eq(1)
   end
 
   it "can access protected information via FQL.multiquery" do
@@ -499,8 +502,8 @@ shared_examples_for "Koala GraphAPI with an access token" do
       :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)"
     )
-    result.size.should == 3
-    result.keys.should include("query1", "query2", "query3")
+    expect(result.size).to eq(3)
+    expect(result.keys).to include("query1", "query2", "query3")
   end
 
   # test all methods to make sure they pass data through to the API
@@ -532,7 +535,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
       it "passes http options through for #{method_name}" do
         options = {:a => 2}
         # graph call should ultimately receive options as the fourth argument
-        @api.should_receive(:graph_call).with(anything, anything, anything, options)
+        expect(@api).to receive(:graph_call).with(anything, anything, anything, options)
 
         # if we supply args, use them (since some methods process params)
         # the method should receive as args n-1 anythings and then options
@@ -546,7 +549,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     it "passes http options through for get_picture" do
       options = {:a => 2}
       # graph call should ultimately receive options as the fourth argument
-      @api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options)).and_return({})
+      expect(@api).to receive(:graph_call).with(anything, anything, anything, hash_including(options)).and_return({})
       @api.send(:get_picture, "x", {}, options)
     end
   end
@@ -559,35 +562,35 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
     # GraphCollection methods
     it "gets a GraphCollection when getting connections" do
       @result = @api.get_connections(KoalaTest.page, "photos")
-      @result.should be_a(Koala::Facebook::GraphCollection)
+      expect(@result).to be_a(Koala::Facebook::GraphCollection)
     end
 
     it "returns nil if the get_collections call fails with nil" do
       # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.get_connections(KoalaTest.page, "photos").should be_nil
+      expect(@api).to receive(:graph_call).and_return(nil)
+      expect(@api.get_connections(KoalaTest.page, "photos")).to be_nil
     end
 
     it "gets a GraphCollection when searching" do
       result = @api.search("facebook")
-      result.should be_a(Koala::Facebook::GraphCollection)
+      expect(result).to be_a(Koala::Facebook::GraphCollection)
     end
 
     it "returns 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
+      expect(@api).to receive(:graph_call).and_return(nil)
+      expect(@api.search("facebook")).to be_nil
     end
 
     it "gets a GraphCollection when paging through results" do
       @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])
-      @results.should be_a(Koala::Facebook::GraphCollection)
+      expect(@results).to be_a(Koala::Facebook::GraphCollection)
     end
 
     it "returns 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"=> KoalaTest.search_time}]).should be_nil
+      expect(@api).to receive(:graph_call).and_return(nil)
+      expect(@api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])).to be_nil
     end
   end
 end
@@ -597,57 +600,57 @@ shared_examples_for "Koala GraphAPI without an access token" do
   it "can't get private data about a user" do
     result = @api.get_object(KoalaTest.user1)
     # updated_time should be a pretty fixed test case
-    result["updated_time"].should be_nil
+    expect(result["updated_time"]).to be_nil
   end
 
   it "can't get data about 'me'" do
-    lambda { @api.get_object("me") }.should raise_error(Koala::Facebook::ClientError)
+    expect { @api.get_object("me") }.to raise_error(Koala::Facebook::ClientError)
   end
 
   it "can't access connections from users" do
-    lambda { @api.get_connections(KoalaTest.user2, "friends") }.should raise_error(Koala::Facebook::ClientError)
+    expect { @api.get_connections(KoalaTest.user2, "friends") }.to raise_error(Koala::Facebook::ClientError)
   end
 
   it "can't put an object" do
-    lambda { @result = @api.put_connections(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @result = @api.put_connections(KoalaTest.user2, "feed", :message => "Hello, world") }.to raise_error(Koala::Facebook::AuthenticationError)
     # legacy put_object syntax
-    lambda { @result = @api.put_object(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @result = @api.put_object(KoalaTest.user2, "feed", :message => "Hello, world") }.to raise_error(Koala::Facebook::AuthenticationError)
   end
 
   # these are not strictly necessary as the other put methods resolve to put_connections,
   # but are here for completeness
   it "can't post to a feed" do
-    (lambda do
+    expect(lambda do
       attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"}
       @result = @api.put_wall_post("Hello, world", attachment, "facebook")
-    end).should raise_error(Koala::Facebook::AuthenticationError)
+    end).to raise_error(Koala::Facebook::AuthenticationError)
   end
 
   it "can't comment on an object" do
     # random public post on the facebook wall
-    lambda { @result = @api.put_comment("7204941866_119776748033392", "The hackathon was great!") }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @result = @api.put_comment("7204941866_119776748033392", "The hackathon was great!") }.to raise_error(Koala::Facebook::AuthenticationError)
   end
 
   it "can't like an object" do
-    lambda { @api.put_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @api.put_like("7204941866_119776748033392") }.to raise_error(Koala::Facebook::AuthenticationError)
   end
 
   # DELETE
   it "can't delete posts" do
     # test post on the Ruby SDK Test application
-    lambda { @result = @api.delete_object("115349521819193_113815981982767") }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @result = @api.delete_object("115349521819193_113815981982767") }.to raise_error(Koala::Facebook::AuthenticationError)
   end
 
   it "can't delete a like" do
-    lambda { @api.delete_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @api.delete_like("7204941866_119776748033392") }.to raise_error(Koala::Facebook::AuthenticationError)
   end
 
   # FQL_QUERY
   describe "when making a FQL request" do
     it "can access public information via FQL" do
       result = @api.fql_query("select uid, first_name from user where uid = #{KoalaTest.user2_id}")
-      result.size.should == 1
-      result.first['first_name'].should == KoalaTest.user2_name
+      expect(result.size).to eq(1)
+      expect(result.first['first_name']).to eq(KoalaTest.user2_name)
     end
 
     it "can access public information via FQL.multiquery" do
@@ -655,23 +658,23 @@ shared_examples_for "Koala GraphAPI without an access token" do
         :query1 => "select uid, first_name from user where uid = #{KoalaTest.user2_id}",
         :query2 => "select uid, first_name from user where uid = #{KoalaTest.user1_id}"
       )
-      result.size.should == 2
-      result["query1"].first['first_name'].should == KoalaTest.user2_name
-      result["query2"].first['first_name'].should == KoalaTest.user1_name
+      expect(result.size).to eq(2)
+      expect(result["query1"].first['first_name']).to eq(KoalaTest.user2_name)
+      expect(result["query2"].first['first_name']).to eq(KoalaTest.user1_name)
     end
 
     it "can't access protected information via FQL" do
-      lambda { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.should raise_error(Koala::Facebook::APIError)
+      expect { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.to raise_error(Koala::Facebook::APIError)
     end
 
     it "can't access protected information via FQL.multiquery" do
-      lambda {
+      expect {
         @api.fql_multiquery(
           :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)"
         )
-      }.should raise_error(Koala::Facebook::APIError)
+      }.to raise_error(Koala::Facebook::APIError)
     end
   end
 end