koala 1.8.0 → 1.9.0rc1

data/spec/cases/realtime_updates_spec.rb

@@ -33,83 +33,83 @@ describe "Koala::Facebook::RealtimeUpdates" do
     # basic initialization
     it "initializes properly with an app_id and an app_access_token" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      updates.should be_a(Koala::Facebook::RealtimeUpdates)
+      expect(updates).to be_a(Koala::Facebook::RealtimeUpdates)
     end
 
     # attributes
     it "allows read access to app_id" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:app_id)
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:app_id=)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).to include(:app_id)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).not_to include(:app_id=)
     end
 
     it "allows read access to app_access_token" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:app_access_token)
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).to include(:app_access_token)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).not_to include(:app_access_token=)
     end
 
     it "allows read access to secret" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:secret)
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:secret=)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).to include(:secret)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).not_to include(:secret=)
     end
 
     it "allows read access to api" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:api)
-      Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:api=)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).to include(:api)
+      expect(Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym)).not_to include(:api=)
     end
 
     # old graph_api accessor
     it "returns the api object when graph_api is called" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
-      updates.graph_api.should == updates.api
+      expect(updates.graph_api).to eq(updates.api)
     end
 
     it "fire a deprecation warning when graph_api is called" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
-      Koala::Utils.should_receive(:deprecate)
+      expect(Koala::Utils).to receive(:deprecate)
       updates.graph_api
     end
 
     # init with secret / fetching the token
     it "initializes properly with an app_id and a secret" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
-      updates.should be_a(Koala::Facebook::RealtimeUpdates)
+      expect(updates).to be_a(Koala::Facebook::RealtimeUpdates)
     end
 
     it "fetches an app_token from Facebook when provided an app_id and a secret" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
-      updates.app_access_token.should_not be_nil
+      expect(updates.app_access_token).not_to be_nil
     end
 
     it "uses the OAuth class to fetch a token when provided an app_id and a secret" do
       oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
       token = oauth.get_app_access_token
-      oauth.should_receive(:get_app_access_token).and_return(token)
-      Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
+      expect(oauth).to receive(:get_app_access_token).and_return(token)
+      expect(Koala::Facebook::OAuth).to receive(:new).with(@app_id, @secret).and_return(oauth)
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
     end
 
     it "sets up the with the app acces token" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      updates.api.should be_a(Koala::Facebook::API)
-      updates.api.access_token.should == @app_access_token
+      expect(updates.api).to be_a(Koala::Facebook::API)
+      expect(updates.api.access_token).to eq(@app_access_token)
     end
 
   end
 
   describe "#subscribe" do
     it "makes a POST to the subscription path" do
-      @updates.api.should_receive(:graph_call).with(@updates.subscription_path, anything, "post", anything)
+      expect(@updates.api).to receive(:graph_call).with(@updates.subscription_path, anything, "post", anything)
       @updates.subscribe("user", "name", @subscription_path, @verify_token)
     end
 
     it "properly formats the subscription request" do
       obj = "user"
       fields = "name"
-      @updates.api.should_receive(:graph_call).with(anything, hash_including(
+      expect(@updates.api).to receive(:graph_call).with(anything, hash_including(
         :object => obj,
         :fields => fields,
         :callback_url => @subscription_path,
@@ -122,7 +122,7 @@ describe "Koala::Facebook::RealtimeUpdates" do
       # see https://github.com/arsduo/koala/issues/150
       obj = "user"
       fields = "name"
-      @updates.api.should_not_receive(:graph_call).with(anything, hash_including(:verify_token => anything), anything, anything)
+      expect(@updates.api).not_to receive(:graph_call).with(anything, hash_including(:verify_token => anything), anything, anything)
       @updates.subscribe("user", "name", @subscription_path)
     end
 
@@ -132,7 +132,7 @@ describe "Koala::Facebook::RealtimeUpdates" do
 
     it "accepts an options hash" do
       options = {:a => 2, :b => "c"}
-      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
+      expect(@updates.api).to receive(:graph_call).with(anything, anything, anything, hash_including(options))
       @updates.subscribe("user", "name", @subscription_path, @verify_token, options)
     end
 
@@ -157,19 +157,19 @@ describe "Koala::Facebook::RealtimeUpdates" do
 
   describe "#unsubscribe" do
     it "makes a DELETE to the subscription path" do
-      @updates.api.should_receive(:graph_call).with(@updates.subscription_path, anything, "delete", anything)
+      expect(@updates.api).to receive(:graph_call).with(@updates.subscription_path, anything, "delete", anything)
       @updates.unsubscribe("user")
     end
 
     it "includes the object if provided" do
       obj = "user"
-      @updates.api.should_receive(:graph_call).with(anything, hash_including(:object => obj), anything, anything)
+      expect(@updates.api).to receive(:graph_call).with(anything, hash_including(:object => obj), anything, anything)
       @updates.unsubscribe(obj)
     end
 
     it "accepts an options hash" do
       options = {:a => 2, :b => "C"}
-      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
+      expect(@updates.api).to receive(:graph_call).with(anything, anything, anything, hash_including(options))
       @updates.unsubscribe("user", options)
     end
 
@@ -190,26 +190,26 @@ describe "Koala::Facebook::RealtimeUpdates" do
 
   describe "#list_subscriptions" do
     it "GETs the subscription path" do
-      @updates.api.should_receive(:graph_call).with(@updates.subscription_path, anything, "get", anything)
+      expect(@updates.api).to receive(:graph_call).with(@updates.subscription_path, anything, "get", anything)
       @updates.list_subscriptions
     end
 
     it "accepts options" do
       options = {:a => 3, :b => "D"}
-      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
+      expect(@updates.api).to receive(:graph_call).with(anything, anything, anything, hash_including(options))
       @updates.list_subscriptions(options)
     end
 
     describe "in practice" do
       it "lists subscriptions properly" do
-        @updates.list_subscriptions.should be_a(Array)
+        expect(@updates.list_subscriptions).to be_a(Array)
       end
     end
   end
 
   describe "#subscription_path" do
     it "returns the app_id/subscriptions" do
-      @updates.subscription_path.should == "#{@app_id}/subscriptions"
+      expect(@updates.subscription_path).to eq("#{@app_id}/subscriptions")
     end
   end
 
@@ -222,23 +222,23 @@ describe "Koala::Facebook::RealtimeUpdates" do
     end
 
     it "returns false if there is no X-Hub-Signature header" do
-      @updates.validate_update("", {}).should be_false
+      expect(@updates.validate_update("", {})).to be_falsey
     end
 
     it "returns false if the signature doesn't match the body" do
-      @updates.validate_update("", {"X-Hub-Signature" => "sha1=badsha1"}).should be_false
+      expect(@updates.validate_update("", {"X-Hub-Signature" => "sha1=badsha1"})).to be_falsey
     end
 
     it "results true if the signature matches the body with the secret" do
       body = "BODY"
       signature = OpenSSL::HMAC.hexdigest('sha1', @secret, body).chomp
-      @updates.validate_update(body, {"X-Hub-Signature" => "sha1=#{signature}"}).should be_true
+      expect(@updates.validate_update(body, {"X-Hub-Signature" => "sha1=#{signature}"})).to be_truthy
     end
 
     it "results true with alternate HTTP_X_HUB_SIGNATURE header" do
       body = "BODY"
       signature = OpenSSL::HMAC.hexdigest('sha1', @secret, body).chomp
-      @updates.validate_update(body, {"HTTP_X_HUB_SIGNATURE" => "sha1=#{signature}"}).should be_true
+      expect(@updates.validate_update(body, {"HTTP_X_HUB_SIGNATURE" => "sha1=#{signature}"})).to be_truthy
     end
 
   end
@@ -246,19 +246,19 @@ describe "Koala::Facebook::RealtimeUpdates" do
   describe ".meet_challenge" do
     it "returns false if hub.mode isn't subscribe" do
       params = {'hub.mode' => 'not subscribe'}
-      Koala::Facebook::RealtimeUpdates.meet_challenge(params).should be_false
+      expect(Koala::Facebook::RealtimeUpdates.meet_challenge(params)).to be_falsey
     end
 
     it "doesn't evaluate the block if hub.mode isn't subscribe" do
       params = {'hub.mode' => 'not subscribe'}
       block_evaluated = false
       Koala::Facebook::RealtimeUpdates.meet_challenge(params){|token| block_evaluated = true}
-      block_evaluated.should be_false
+      expect(block_evaluated).to be_falsey
     end
 
     it "returns false if not given a verify_token or block" do
       params = {'hub.mode' => 'subscribe'}
-      Koala::Facebook::RealtimeUpdates.meet_challenge(params).should be_false
+      expect(Koala::Facebook::RealtimeUpdates.meet_challenge(params)).to be_falsey
     end
 
     describe "and mode is 'subscribe'" do
@@ -273,12 +273,12 @@ describe "Koala::Facebook::RealtimeUpdates" do
         end
 
         it "returns false if the given verify token doesn't match" do
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token + '1').should be_false
+          expect(Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token + '1')).to be_falsey
         end
 
         it "returns the challenge if the given verify token matches" do
           @params['hub.challenge'] = 'challenge val'
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token).should == @params['hub.challenge']
+          expect(Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token)).to eq(@params['hub.challenge'])
         end
       end
 
@@ -289,27 +289,27 @@ describe "Koala::Facebook::RealtimeUpdates" do
 
         it "gives the block the token as a parameter" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
-            token.should == @token
+            expect(token).to eq(@token)
           end
         end
 
         it "returns false if the given block return false" do
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
+          expect(Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             false
-          end.should be_false
+          end).to be_falsey
         end
 
         it "returns false if the given block returns nil" do
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
+          expect(Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             nil
-          end.should be_false
+          end).to be_falsey
         end
 
         it "returns the challenge if the given block returns true" do
           @params['hub.challenge'] = 'challenge val'
-          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
+          expect(Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             true
-          end.should be_true
+          end).to be_truthy
         end
       end
     end

data/spec/cases/test_users_spec.rb

@@ -31,57 +31,57 @@ describe "Koala::Facebook::TestUsers" do
     # basic initialization
     it "initializes properly with an app_id and an app_access_token" do
       test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :app_access_token => @app_access_token)
-      test_users.should be_a(Koala::Facebook::TestUsers)
+      expect(test_users).to be_a(Koala::Facebook::TestUsers)
     end
 
     # init with secret / fetching the token
     it "initializes properly with an app_id and a secret" do
       test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
-      test_users.should be_a(Koala::Facebook::TestUsers)
+      expect(test_users).to be_a(Koala::Facebook::TestUsers)
     end
 
     it "uses the OAuth class to fetch a token when provided an app_id and a secret" do
       oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
       token = oauth.get_app_access_token
-      oauth.should_receive(:get_app_access_token).and_return(token)
-      Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
+      expect(oauth).to receive(:get_app_access_token).and_return(token)
+      expect(Koala::Facebook::OAuth).to receive(:new).with(@app_id, @secret).and_return(oauth)
       test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
     end
 
     # attributes
     it "allows read access to app_id, app_access_token, and secret" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_id)
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_id=)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).to include(:app_id)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).not_to include(:app_id=)
     end
 
     it "allows read access to app_access_token" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_access_token)
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).to include(:app_access_token)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).not_to include(:app_access_token=)
     end
 
     it "allows read access to secret" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:secret)
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:secret=)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).to include(:secret)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).not_to include(:secret=)
     end
 
     it "allows read access to api" do
       # in Ruby 1.9, .method returns symbols
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:api)
-      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:api=)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).to include(:api)
+      expect(Koala::Facebook::TestUsers.instance_methods.map(&:to_sym)).not_to include(:api=)
     end
 
     # old graph_api accessor
     it "returns the api object when graph_api is called" do
       test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
-      test_users.graph_api.should == test_users.api
+      expect(test_users.graph_api).to eq(test_users.api)
     end
 
     it "fire a deprecation warning when graph_api is called" do
       test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
-      Koala::Utils.should_receive(:deprecate)
+      expect(Koala::Utils).to receive(:deprecate)
       test_users.graph_api
     end
   end
@@ -93,43 +93,43 @@ describe "Koala::Facebook::TestUsers" do
       it "creates a test user when not given installed" do
         result = @test_users.create(false)
         @user1 = result["id"]
-        result.should be_a(Hash)
-        (result["id"] && result["access_token"] && result["login_url"]).should
+        expect(result).to be_a(Hash)
+        expect(result["id"] && result["access_token"] && result["login_url"]).to be_truthy
       end
 
       it "creates a test user when not given installed, ignoring permissions" do
         result = @test_users.create(false, "read_stream")
         @user1 = result["id"]
-        result.should be_a(Hash)
-        (result["id"] && result["access_token"] && result["login_url"]).should
+        expect(result).to be_a(Hash)
+        expect(result["id"] && result["access_token"] && result["login_url"]).to be_truthy
       end
 
       it "accepts permissions as a string" do
-        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
+        expect(@test_users.graph_api).to receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
         result = @test_users.create(true, "read_stream,publish_stream")
       end
 
       it "accepts permissions as an array" do
-        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
+        expect(@test_users.graph_api).to receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
         result = @test_users.create(true, ["read_stream", "publish_stream"])
       end
 
       it "creates a test user when given installed and a permission" do
         result = @test_users.create(true, "read_stream")
         @user1 = result["id"]
-        result.should be_a(Hash)
-        (result["id"] && result["access_token"] && result["login_url"]).should
+        expect(result).to be_a(Hash)
+        expect(result["id"] && result["access_token"] && result["login_url"]).to be_truthy
       end
 
       it "lets you specify other graph arguments, like uid and access token" do
         args = {:uid => "some test user ID", :owner_access_token => "some owner access token"}
-        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
+        expect(@test_users.graph_api).to receive(:graph_call).with(anything, hash_including(args), anything, anything)
         @test_users.create(true, nil, args)
       end
 
       it "lets you specify http options that get passed through to the graph call" do
         options = {:some_http_option => true}
-        @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        expect(@test_users.graph_api).to receive(:graph_call).with(anything, anything, anything, options)
         @test_users.create(true, nil, {}, options)
       end
     end
@@ -142,16 +142,16 @@ describe "Koala::Facebook::TestUsers" do
 
       it "lists test users" do
         result = @test_users.list
-        result.should be_an(Array)
+        expect(result).to be_an(Array)
         first_user, second_user = result[0], result[1]
-        (first_user["id"] && first_user["access_token"] && first_user["login_url"]).should
-        (second_user["id"] && second_user["access_token"] && second_user["login_url"]).should
+        expect(first_user["id"] && first_user["access_token"] && first_user["login_url"]).to be_truthy
+        expect(second_user["id"] && second_user["access_token"] && second_user["login_url"]).to be_truthy
       end
 
       it "accepts http options" do
         @stubbed = true
         options = {:some_http_option => true}
-        @test_users.api.should_receive(:graph_call).with(anything, anything, anything, options)
+        expect(@test_users.api).to receive(:graph_call).with(anything, anything, anything, options)
         @test_users.list(options)
       end
     end
@@ -163,24 +163,24 @@ describe "Koala::Facebook::TestUsers" do
       end
 
       it "deletes a user by id" do
-        @test_users.delete(@user1['id']).should be_true
+        expect(@test_users.delete(@user1['id'])).to be_truthy
         @user1 = nil
       end
 
       it "deletes a user by hash" do
-        @test_users.delete(@user2).should be_true
+        expect(@test_users.delete(@user2)).to be_truthy
         @user2 = nil
       end
 
       it "does not delete users when provided a false ID" do
-        lambda { @test_users.delete("#{@user1['id']}1") }.should raise_exception(Koala::Facebook::APIError)
+        expect { @test_users.delete("#{@user1['id']}1") }.to raise_exception(Koala::Facebook::APIError)
       end
 
       it "lets you specify http options that get passed through to the graph call" do
         options = {:some_http_option => true}
         # technically this goes through delete_object, but this makes it less brittle
         @stubbed = true
-        @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        expect(@test_users.graph_api).to receive(:graph_call).with(anything, anything, anything, options)
         @test_users.delete("user", options)
       end
     end
@@ -188,24 +188,24 @@ describe "Koala::Facebook::TestUsers" do
     describe "#delete_all" do
       it "deletes the batch API to deleten all users found by the list commnand" do
         array = 200.times.collect { {"id" => rand}}
-        @test_users.should_receive(:list).and_return(array, [])
+        expect(@test_users).to receive(:list).and_return(array, [])
         batch_api = double("batch API")
         allow(@test_users.api).to receive(:batch).and_yield(batch_api)
-        array.each {|item| batch_api.should_receive(:delete_object).with(item["id"]) }
+        array.each {|item| expect(batch_api).to receive(:delete_object).with(item["id"]) }
         @test_users.delete_all
       end
 
       it "accepts http options that get passed to both list and the batch call" do
         options = {:some_http_option => true}
-        @test_users.should_receive(:list).with(options).and_return([{"id" => rand}], [])
-        @test_users.api.should_receive(:batch).with(options)
+        expect(@test_users).to receive(:list).with(options).and_return([{"id" => rand}], [])
+        expect(@test_users.api).to receive(:batch).with(options)
         @test_users.delete_all(options)
       end
 
       it "breaks if Facebook sends back the same list twice" do
         list = [{"id" => rand}]
         allow(@test_users).to receive(:list).and_return(list)
-        @test_users.api.should_receive(:batch).once
+        expect(@test_users.api).to receive(:batch).once
         @test_users.delete_all
       end
 
@@ -213,7 +213,7 @@ describe "Koala::Facebook::TestUsers" do
         list1 = [{"id" => 123}]
         list2 = [{"id" => 123, "name" => "foo"}]
         allow(@test_users).to receive(:list).twice.and_return(list1, list2)
-        @test_users.api.should_receive(:batch).once
+        expect(@test_users.api).to receive(:batch).once
         @test_users.delete_all
       end
     end
@@ -227,20 +227,20 @@ describe "Koala::Facebook::TestUsers" do
 
       it "makes a POST with the test user Graph API " do
         @user1 = @test_users2.create(true)
-        @test_users2.graph_api.should_receive(:graph_call).with(anything, anything, "post", anything)
+        expect(@test_users2.graph_api).to receive(:graph_call).with(anything, anything, "post", anything)
         @test_users2.update(@user1, @updates)
       end
 
       it "makes a request to the test user with the update params " do
         @user1 = @test_users2.create(true)
-        @test_users2.graph_api.should_receive(:graph_call).with(@user1["id"], @updates, anything, anything)
+        expect(@test_users2.graph_api).to receive(:graph_call).with(@user1["id"], @updates, anything, anything)
         @test_users2.update(@user1, @updates)
       end
 
       it "accepts an options hash" do
         options = {:some_http_option => true}
         @stubbed = true
-        @test_users2.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        expect(@test_users2.graph_api).to receive(:graph_call).with(anything, anything, anything, options)
         @test_users2.update("foo", @updates, options)
       end
 
@@ -248,7 +248,7 @@ describe "Koala::Facebook::TestUsers" do
         @user1 = @test_users.create(true)
         @test_users.update(@user1, @updates)
         user_info = Koala::Facebook::API.new(@user1["access_token"]).get_object(@user1["id"])
-        user_info["name"].should == @updates[:name]
+        expect(user_info["name"]).to eq(@updates[:name])
       end
     end
 
@@ -260,7 +260,7 @@ describe "Koala::Facebook::TestUsers" do
 
       it "makes two users into friends with string hashes" do
         result = @test_users.befriend(@user1, @user2)
-        result.should be_true
+        expect(result).to be_truthy
       end
 
       it "makes two users into friends with symbol hashes" do
@@ -270,18 +270,18 @@ describe "Koala::Facebook::TestUsers" do
         @user2.each_pair {|k, v| new_user_2[k.to_sym] = v}
 
         result = @test_users.befriend(new_user_1, new_user_2)
-        result.should be_true
+        expect(result).to be_truthy
       end
 
       it "does not accept user IDs anymore" do
-        lambda { @test_users.befriend(@user1["id"], @user2["id"]) }.should raise_exception
+        expect { @test_users.befriend(@user1["id"], @user2["id"]) }.to raise_exception
       end
 
       it "accepts http options passed to both calls" do
         options = {:some_http_option => true}
         # should come twice, once for each user
         @stubbed = true
-        Koala.http_service.should_receive(:make_request).with(anything, anything, anything, options).twice.and_return(Koala::HTTPService::Response.new(200, "{}", {}))
+        expect(Koala.http_service).to receive(:make_request).with(anything, anything, anything, options).twice.and_return(Koala::HTTPService::Response.new(200, "{}", {}))
         @test_users.befriend(@user1, @user2, options)
       end
     end
@@ -289,7 +289,7 @@ describe "Koala::Facebook::TestUsers" do
 
   describe "#test_user_accounts_path" do
     it "returns the app_id/accounts/test-users" do
-      @test_users.test_user_accounts_path.should == "/#{@app_id}/accounts/test-users"
+      expect(@test_users.test_user_accounts_path).to eq("/#{@app_id}/accounts/test-users")
     end
   end
 
@@ -299,12 +299,12 @@ describe "Koala::Facebook::TestUsers" do
 
       if KoalaTest.mock_interface?
         id_counter = 999999900
-        @test_users.stub(:create).and_return do
+        allow(@test_users).to receive(:create).and_return do
           id_counter += 1
           {"id" => id_counter, "access_token" => @token, "login_url" => "https://www.facebook.com/platform/test_account.."}
         end
-        @test_users.stub(:befriend).and_return(true)
-        @test_users.stub(:delete).and_return(true)
+        allow(@test_users).to receive(:befriend).and_return(true)
+        allow(@test_users).to receive(:delete).and_return(true)
       end
     end
 
@@ -312,15 +312,15 @@ describe "Koala::Facebook::TestUsers" do
       it "creates a 5 person network" do
         size = 5
         @network = @test_users.create_network(size)
-        @network.should be_a(Array)
-        @network.size.should == size
+        expect(@network).to be_a(Array)
+        expect(@network.size).to eq(size)
       end
     end
 
     it "has no built-in network size limit" do
       times = 100
-      @test_users.should_receive(:create).exactly(times).times
-      @test_users.stub(:befriend)
+      expect(@test_users).to receive(:create).exactly(times).times
+      allow(@test_users).to receive(:befriend)
       @test_users.create_network(times)
     end
 
@@ -328,17 +328,17 @@ describe "Koala::Facebook::TestUsers" do
       perms = ["read_stream", "offline_access"]
       installed = false
       count = 25
-      @test_users.should_receive(:create).exactly(count).times.with(installed, perms, anything)
-      @test_users.stub(:befriend)
+      expect(@test_users).to receive(:create).exactly(count).times.with(installed, perms, anything)
+      allow(@test_users).to receive(:befriend)
       @test_users.create_network(count, installed, perms)
     end
 
     it "accepts http options that are passed to both the create and befriend calls" do
       count = 25
       options = {:some_http_option => true}
-      @test_users.should_receive(:create).exactly(count).times.with(anything, anything, options).and_return({})
+      expect(@test_users).to receive(:create).exactly(count).times.with(anything, anything, options).and_return({})
       # there are more befriends than creates, but we don't need to do the extra work to calculate out the exact #
-      @test_users.should_receive(:befriend).at_least(count).times.with(anything, anything, options)
+      expect(@test_users).to receive(:befriend).at_least(count).times.with(anything, anything, options)
       @test_users.create_network(count, true, "", options)
     end
   end # when creating network