signet 0.5.1 → 0.6.0

data/spec/signet/oauth_1/server_spec.rb

@@ -79,16 +79,16 @@ describe Signet::OAuth1::Server, 'unconfigured' do
     @server = Signet::OAuth1::Server.new
   end
   it 'should not have a client_credential Proc' do
-    @server.client_credential.should == nil
+    expect(@server.client_credential).to eq nil
   end
   it 'should not have a token_credential Proc' do
-    @server.token_credential.should == nil
+    expect(@server.token_credential).to eq nil
   end
   it 'should not have a nonce_timestamp Proc' do
-    @server.nonce_timestamp.should == nil
+    expect(@server.nonce_timestamp).to eq nil
   end
   it 'should not have a verifier Proc' do
-    @server.verifier.should == nil
+    expect(@server.verifier).to eq nil
   end
 end
 
@@ -128,76 +128,76 @@ describe Signet::OAuth1::Server, 'configured' do
 
   it 'should raise an error if the client credential Proc is not set' do
     @server.client_credential = nil
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should raise an error if the token credential Proc is not set" do
     @server.token_credential = nil
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should raise an error if the temporary token credential Proc is not set" do
     @server.temporary_credential = nil
-    (lambda do
+    expect(lambda do
       @server.authenticate_token_credential_request
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should raise an error if the verifier Proc is not set for a token request" do
     @server.verifier = nil
-    (lambda do
+    expect(lambda do
       @server.authenticate_token_credential_request
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it 'should raise an error if no request is provided' do
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it 'should raise an error if a bogus request is provided' do
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request(
         :request => []
       )
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it 'should raise an error if no Authentication header is provided' do
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request(
         :method => 'GET',
         :uri => 'https://photos.example.net/photos',
         :headers => [['Authorization', '']],
         :body => ''
       )
-    end).should raise_error(Signet::MalformedAuthorizationError)
+    end).to raise_error(Signet::MalformedAuthorizationError)
   end
 
   it 'should raise an error if no URI is provided' do
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request(
         :method => 'GET',
         :headers => [],
         :body => ''
       )
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it 'should reject a request with the wrong signature method' do
     bad_method = 'FOO'
-    (lambda do
+    expect(lambda do
       @server.authenticate_resource_request(
         :method => 'GET',
         :uri => 'http://photos.example.net/photos',
         :headers=>make_oauth_token_header({'oauth_signature_method'=>bad_method})
       )
-    end).should raise_error(NotImplementedError,
+    end).to raise_error(NotImplementedError,
                              "Unsupported signature method: #{bad_method}"
                            )
   end
@@ -211,18 +211,18 @@ describe Signet::OAuth1::Server, 'configured' do
                             @temporary_credential_key, @temporary_credential_secret
                           )
         end
-      @server.find_temporary_credential(@temporary_credential_key).should ==
+      expect(@server.find_temporary_credential(@temporary_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@temporary_credential_key,
-                                       @temporary_credential_secret)
+                                       @temporary_credential_secret))
     end
     it 'should return a Signet credential if the Proc provides a key/secret pair' do
       @server.temporary_credential =
         lambda do |x|
           {:key=>@temporary_credential_key, :secret=>@temporary_credential_secret}
         end
-      @server.find_temporary_credential(@temporary_credential_key).should ==
+      expect(@server.find_temporary_credential(@temporary_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@temporary_credential_key,
-                                       @temporary_credential_secret)
+                                       @temporary_credential_secret))
     end
     it 'should return a Signet credential if the Proc provides ' +
        'a key/secret Enumerable' do
@@ -230,15 +230,14 @@ describe Signet::OAuth1::Server, 'configured' do
         lambda do |x|
           [@temporary_credential_key, @temporary_credential_secret]
         end
-      @server.find_temporary_credential(@temporary_credential_key).should ==
+      expect(@server.find_temporary_credential(@temporary_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@temporary_credential_key,
-                                       @temporary_credential_secret
-                                      )
+                                       @temporary_credential_secret))
     end
 
     it 'should return nil if the Proc does not provide a usable response' do
       @server.temporary_credential = lambda {|x| nil }
-      @server.find_temporary_credential(@temporary_credential_key).should == nil
+      expect(@server.find_temporary_credential(@temporary_credential_key)).to eq nil
     end
   end
 
@@ -250,18 +249,18 @@ describe Signet::OAuth1::Server, 'configured' do
           x.nil? ? nil : Signet::OAuth1::Credential.new(@client_credential_key,
                                                         @client_credential_secret)
         end
-      @server.find_client_credential(@client_credential_key).should ==
+      expect(@server.find_client_credential(@client_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@client_credential_key,
-                                       @client_credential_secret)
+                                       @client_credential_secret))
     end
     it 'should return a Signet credential if the Proc provides a key/secret pair' do
       @server.client_credential =
         lambda do |x|
           {:key=>@client_credential_key, :secret=>@client_credential_secret}
         end
-      @server.find_client_credential(@client_credential_key).should ==
+      expect(@server.find_client_credential(@client_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@client_credential_key,
-                                       @client_credential_secret)
+                                       @client_credential_secret))
     end
     it 'should return a Signet credential if the Proc provides ' +
        'a key/secret Enumerable' do
@@ -269,14 +268,14 @@ describe Signet::OAuth1::Server, 'configured' do
         lambda do |x|
           [@client_credential_key, @client_credential_secret]
         end
-      @server.find_client_credential(@client_credential_key).should ==
+      expect(@server.find_client_credential(@client_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@client_credential_key,
-                                       @client_credential_secret)
+                                       @client_credential_secret))
     end
 
     it 'should return nil if the Proc does not provide a usable response' do
       @server.client_credential = lambda {|x| nil }
-      @server.find_client_credential(@client_credential_key).should == nil
+      expect(@server.find_client_credential(@client_credential_key)).to be_nil
     end
   end
 
@@ -288,9 +287,9 @@ describe Signet::OAuth1::Server, 'configured' do
           x.nil? ? nil : Signet::OAuth1::Credential.new(@token_credential_key,
                                                         @token_credential_secret)
         end
-      @server.find_token_credential(@token_credential_key).should ==
+      expect(@server.find_token_credential(@token_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@token_credential_key,
-                                       @token_credential_secret)
+                                       @token_credential_secret))
     end
 
     it 'should return a Signet credential if the Proc provides a key/secret pair' do
@@ -298,9 +297,9 @@ describe Signet::OAuth1::Server, 'configured' do
         lambda do |x|
           {:key=>@token_credential_key, :secret=>@token_credential_secret}
         end
-      @server.find_token_credential(@token_credential_key).should ==
+      expect(@server.find_token_credential(@token_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@token_credential_key,
-                                       @token_credential_secret)
+                                       @token_credential_secret))
     end
 
     it 'should return a Signet credential if the Proc provides ' +
@@ -309,14 +308,14 @@ describe Signet::OAuth1::Server, 'configured' do
         lambda do |x|
           [@token_credential_key, @token_credential_secret]
         end
-      @server.find_token_credential(@token_credential_key).should ==
+      expect(@server.find_token_credential(@token_credential_key)).to eq(
         Signet::OAuth1::Credential.new(@token_credential_key,
-                                       @token_credential_secret)
+                                       @token_credential_secret))
     end
 
     it 'should return nil if the Proc does not provide a usable response' do
       @server.token_credential = lambda {|x| nil }
-      @server.find_token_credential(@token_credential_key).should == nil
+      expect(@server.find_token_credential(@token_credential_key)).to be_nil
     end
   end
 
@@ -324,30 +323,30 @@ describe Signet::OAuth1::Server, 'configured' do
   describe 'calling find_verifier' do
     it 'should return false if server verifier returns false' do
       @server.verifier = lambda {|x| false }
-      @server.find_verifier(@verifier).should == false
+      expect(@server.find_verifier(@verifier)).to eq false
     end
     it 'should return false if server verifier returns nil' do
       @server.verifier = lambda {|x| nil }
-      @server.find_verifier(@verifier).should == false
+      expect(@server.find_verifier(@verifier)).to eq false
     end
     it 'should return true if server verifier returns a random object' do
       @server.verifier = lambda {|x| x.succ}
-      @server.find_verifier(@verifier).should == true
+      expect(@server.find_verifier(@verifier)).to eq true
     end
   end
 
   describe 'calling validate_nonce_timestamp' do
     it 'should return false if nonce_timestamp Proc returns false' do
       @server.nonce_timestamp = lambda {|n,t| false}
-      @server.validate_nonce_timestamp('nonce', 'timestamp'). should == false
+      expect(@server.validate_nonce_timestamp('nonce', 'timestamp')).to be false
     end
     it 'should return false if nonce_timestamp Proc returns nil' do
       @server.nonce_timestamp = lambda {|n,t| nil}
-      @server.validate_nonce_timestamp('nonce', 'timestamp'). should == false
+      expect(@server.validate_nonce_timestamp('nonce', 'timestamp')).to be false
     end
     it 'should return true if nonce_timestamp Proc returns a random object' do
       @server.nonce_timestamp = lambda {|n,t| n+t.to_s}
-      @server.validate_nonce_timestamp('nonce', 'timestamp'). should == true
+      expect(@server.validate_nonce_timestamp('nonce', 'timestamp')).to be true
     end
   end
 
@@ -363,25 +362,25 @@ describe Signet::OAuth1::Server, 'configured' do
 
     it 'should raise an error if the client credential Proc is not set' do
       @server.client_credential = nil
-      (lambda do
+      expect(lambda do
         @server.authenticate_temporary_credential_request(
           :request=>make_temporary_credential_request(@client)
         )
-      end).should raise_error(ArgumentError)
+      end).to raise_error(ArgumentError)
     end
     it 'should reject an malformed request' do
       bad_request = make_temporary_credential_request(@client, nil, 'https://photos.example.net/photos')
       bad_request.headers['Authorization'].gsub!(/(OAuth)(.+)/, "#{$1}")
-      (lambda do
+      expect(lambda do
         @server.authenticate_temporary_credential_request(
           :request=>bad_request
         )
-      end).should raise_error(Signet::MalformedAuthorizationError)
+      end).to raise_error(Signet::MalformedAuthorizationError)
     end
 
     it 'should call a user-supplied Proc to validate a nonce/timestamp pair' do
-      nonce_callback = mock('nonce')
-      nonce_callback.should_receive(:call).once.with(an_instance_of(String),
+      nonce_callback = double('nonce')
+      expect(nonce_callback).to receive(:call).once.with(an_instance_of(String),
                                                      an_instance_of(String)
                                                     ).and_return(true)
 
@@ -393,44 +392,44 @@ describe Signet::OAuth1::Server, 'configured' do
 
     it "should return 'oob' for a valid request without an oauth_callback" do
       bad_request = make_temporary_credential_request(@client)
-      @server.authenticate_temporary_credential_request(
+      expect(@server.authenticate_temporary_credential_request(
         :request=>bad_request
-      ).should == 'oob'
+      )).to eq 'oob'
     end
     it 'should return the oauth_callback for a valid request ' +
        'with an oauth_callback' do
       callback = 'http://printer.example.com/ready'
-      @server.authenticate_temporary_credential_request(
+      expect(@server.authenticate_temporary_credential_request(
         :request=>make_temporary_credential_request(@client, callback)
-      ).should == callback
+      )).to eq callback
     end
     it 'should return false for an unauthenticated request' do
       bad_request = make_temporary_credential_request(@client)
       bad_request.headers["Authorization"].gsub!(/oauth_signature=\".+\"/,
                                                   "oauth_signature=\"foobar\"")
-      @server.authenticate_temporary_credential_request(
+      expect(@server.authenticate_temporary_credential_request(
         :request=>bad_request
-      ).should == false
+      )).to eq false
     end
     it 'should return nil from #request_realm if no realm is provided' do
       req = make_temporary_credential_request(@client)
-      @server.request_realm(
+      expect(@server.request_realm(
         :request=>req
-      ).should == nil
+      )).to eq nil
     end
 
     describe 'with a Realm provided' do
       it 'should return the realm from #request_realm' do
         req = make_temporary_credential_request(@client, nil, nil, 'Photos')
-        @server.request_realm(
+        expect(@server.request_realm(
           :request=>req
-        ).should == 'Photos'
+        )).to eq 'Photos'
       end
       it 'should return "oob" with a valid request without an oauth_callback' do
         req = make_temporary_credential_request(@client, nil, nil, 'Photos')
-        @server.authenticate_temporary_credential_request(
+        expect(@server.authenticate_temporary_credential_request(
           :request=>req
-        ).should == 'oob'
+        )).to eq 'oob'
       end
     end
 
@@ -456,15 +455,15 @@ describe Signet::OAuth1::Server, 'configured' do
       bad_request = make_token_credential_request(@client)
       bad_request.headers["Authorization"].gsub!(/(OAuth)(.+)/, "#{$1}")
 
-      (lambda do
+      expect(lambda do
         @server.authenticate_token_credential_request(
           :request=>bad_request
         )
-      end).should raise_error(Signet::MalformedAuthorizationError)
+      end).to raise_error(Signet::MalformedAuthorizationError)
     end
     it 'should call a user-supplied Proc to validate a nonce/timestamp pair' do
-      nonce_callback = mock('nonce')
-      nonce_callback.should_receive(:call).once.with(
+      nonce_callback = double('nonce')
+      expect(nonce_callback).to receive(:call).once.with(
         an_instance_of(String), an_instance_of(String)
       ).and_return(true)
       @server.nonce_timestamp = nonce_callback
@@ -473,23 +472,23 @@ describe Signet::OAuth1::Server, 'configured' do
       )
     end
     it 'should return an informational hash for a valid request' do
-      @server.authenticate_token_credential_request(
+      expect(@server.authenticate_token_credential_request(
         :request=>make_token_credential_request(@client)
-      ).should == @return_hash
+      )).to eq @return_hash
     end
     it 'should return nil for an unauthenticated request' do
       bad_request = make_token_credential_request(@client)
       bad_request.headers["Authorization"].gsub!(/oauth_signature=\".+\"/,
                                  "oauth_signature=\"foobar\"")
-      @server.authenticate_token_credential_request(
+      expect(@server.authenticate_token_credential_request(
         :request=>bad_request
-      ).should == nil
+      )).to eq nil
     end
     it 'should call a user-supplied Proc to fetch the client credential' do
       client_cred = Signet::OAuth1::Credential.new(@client_credential_key,
                                                    @client_credential_secret )
-      key_callback = mock('client_cred')
-      key_callback.should_receive(:call).at_least(:once).with(
+      key_callback = double('client_cred')
+      expect(key_callback).to receive(:call).at_least(:once).with(
         @client_credential_key
       ).and_return(client_cred)
 
@@ -502,8 +501,8 @@ describe Signet::OAuth1::Server, 'configured' do
     it 'should call a user-supplied Proc to fetch the temporary token credential' do
       temp_cred = Signet::OAuth1::Credential.new(@temporary_credential_key,
                                                  @temporary_credential_secret)
-      temp_callback = mock('temp_cred')
-      temp_callback.should_receive(:call).at_least(:once).with(
+      temp_callback = double('temp_cred')
+      expect(temp_callback).to receive(:call).at_least(:once).with(
         @temporary_credential_key
       ).and_return(temp_cred)
 
@@ -514,9 +513,9 @@ describe Signet::OAuth1::Server, 'configured' do
     end
     it 'should return nil from #request_realm if no realm is provided' do
       req = make_token_credential_request(@client)
-      @server.request_realm(
+      expect(@server.request_realm(
         :request=>req
-      ).should == nil
+      )).to eq nil
     end
 
     describe 'with a Realm provided' do
@@ -526,15 +525,15 @@ describe Signet::OAuth1::Server, 'configured' do
       end
       it 'should return the realm from #request_realm' do
         req = make_token_credential_request(@client, nil, @realm)
-        @server.request_realm(
+        expect(@server.request_realm(
           :request=>req
-        ).should == @realm
+        )).to eq @realm
       end
       it 'should an informational hash with a valid request' do
         req = make_token_credential_request(@client, nil, @realm)
-        @server.authenticate_token_credential_request(
+        expect(@server.authenticate_token_credential_request(
           :request=>req
-        ).should == @return_hash
+        )).to eq @return_hash
       end
     end
 
@@ -562,7 +561,7 @@ describe Signet::OAuth1::Server, 'configured' do
         :body => ['A chunked body.'],
         :headers => make_oauth_signature_header
       )
-      approved.should == nil
+      expect(approved).to eq nil
     end
 
     it 'should not raise an error if a request body is chunked(as StringIO)' do
@@ -575,18 +574,18 @@ describe Signet::OAuth1::Server, 'configured' do
         :body => chunked_body,
         :headers => make_oauth_signature_header
       )
-      approved.should == nil
+      expect(approved).to eq nil
     end
 
     it 'should raise an error if a request body is of a bogus type' do
-      (lambda do
+      expect(lambda do
         @server.authenticate_resource_request(
           :method => 'POST',
           :uri => 'https://photos.example.net/photos',
           :body => 42,
           :headers => make_oauth_signature_header
         )
-      end).should raise_error(TypeError)
+      end).to raise_error(TypeError)
     end
     it 'should use form parameters in signature if request is a POSTed form' do
       req = make_resource_request(
@@ -594,7 +593,7 @@ describe Signet::OAuth1::Server, 'configured' do
         {:method=>'POST',
         :headers=>{'Content-Type'=>'application/x-www-form-urlencoded'},
         :body=>'c2&a3=2+q'})
-      @server.authenticate_resource_request(:request=>req).should == @return_hash
+      expect(@server.authenticate_resource_request(:request=>req)).to eq @return_hash
     end
     it 'should raise an error if signature is x-www-form-encoded ' +
        'but does not send form parameters in header' do
@@ -609,17 +608,17 @@ describe Signet::OAuth1::Server, 'configured' do
 
       req.headers["Authorization"].gsub!(/c2=\"\", a3=\"2%20q\", /, '')
 
-      (lambda do
+      expect(lambda do
         @server.authenticate_resource_request(:request=>req)
-      end).should raise_error(Signet::MalformedAuthorizationError,
+      end).to raise_error(Signet::MalformedAuthorizationError,
             'Request is of type application/x-www-form-urlencoded but ' +
             'Authentication header did not include form values'
           )
     end
 
     it 'should call a user-supplied Proc to validate a nonce/timestamp pair' do
-      nonce_callback = mock('nonce')
-      nonce_callback.should_receive(:call).once.with(
+      nonce_callback = double('nonce')
+      expect(nonce_callback).to receive(:call).once.with(
         an_instance_of(String), an_instance_of(String)
       ).and_return(true)
 
@@ -632,8 +631,8 @@ describe Signet::OAuth1::Server, 'configured' do
     it 'should call a user-supplied Proc to fetch the client credential' do
       client_cred =  Signet::OAuth1::Credential.new(@client_credential_key,
                                                     @client_credential_secret )
-      key_callback = mock('client_cred' )
-      key_callback.should_receive(:call).at_least(:once).with(
+      key_callback = double('client_cred' )
+      expect(key_callback).to receive(:call).at_least(:once).with(
         @client_credential_key
       ).and_return(client_cred)
 
@@ -646,8 +645,8 @@ describe Signet::OAuth1::Server, 'configured' do
     it 'should call a user-supplied Proc to fetch the token credential' do
       token_cred = Signet::OAuth1::Credential.new(@token_credential_key,
                                                   @token_credential_secret)
-      key_callback = mock('token_cred' )
-      key_callback.should_receive(:call).at_least(:once).with(
+      key_callback = double('token_cred' )
+      expect(key_callback).to receive(:call).at_least(:once).with(
         @token_credential_key
       ).and_return(token_cred)
 
@@ -658,21 +657,21 @@ describe Signet::OAuth1::Server, 'configured' do
     end
 
     it 'should return a Hash for a valid request' do
-      @server.authenticate_resource_request(
+      expect(@server.authenticate_resource_request(
         :request=>make_resource_request(@client)
-      ).should == @return_hash
+      )).to eq @return_hash
     end
     it 'should return nil for a unauthenticated request' do
       bad_request = make_resource_request(@client)
       bad_request.headers["Authorization"].gsub!(/oauth_signature=\".+\"/,
                                  "oauth_signature=\"foobar\"")
-      @server.authenticate_resource_request(:request=>bad_request).should == nil
+      expect(@server.authenticate_resource_request(:request=>bad_request)).to eq nil
     end
     it 'should return nil from #request_realm if no realm is provided' do
       req = make_resource_request(@client)
-      @server.request_realm(
+      expect(@server.request_realm(
         :request=>req
-      ).should == nil
+      )).to eq nil
     end
 
     describe 'with a Realm provided' do
@@ -682,15 +681,15 @@ describe Signet::OAuth1::Server, 'configured' do
       end
       it 'should return the realm from #request_realm' do
         req = make_resource_request(@client, {}, @realm)
-        @server.request_realm(
+        expect(@server.request_realm(
           :request=>req
-        ).should == @realm
+        )).to eq @realm
       end
       it 'should return a hash containing the realm with a valid request' do
         req = make_resource_request(@client, {}, @realm)
-        @server.authenticate_resource_request(
+        expect(@server.authenticate_resource_request(
           :request=>req
-        ).should == @return_hash
+        )).to eq @return_hash
       end
     end
 
@@ -717,7 +716,7 @@ describe Signet::OAuth1::Server, 'configured' do
         :headers => make_oauth_signature_header,
         :two_legged=>true
       )
-      approved.should == nil
+      expect(approved).to eq nil
     end
 
     it 'should not raise an error if a request body is chunked(as StringIO)' do
@@ -731,11 +730,11 @@ describe Signet::OAuth1::Server, 'configured' do
         :headers => make_oauth_signature_header,
         :two_legged=>true
       )
-      approved.should == nil
+      expect(approved).to eq nil
     end
 
     it 'should raise an error if a request body is of a bogus type' do
-      (lambda do
+      expect(lambda do
         @server.authenticate_resource_request(
           :method => 'POST',
           :uri => 'https://photos.example.net/photos',
@@ -743,7 +742,7 @@ describe Signet::OAuth1::Server, 'configured' do
           :headers => make_oauth_signature_header,
           :two_legged=>true
         )
-      end).should raise_error(TypeError)
+      end).to raise_error(TypeError)
     end
     it 'should use form parameters in signature if request is a POSTed form' do
       req = make_resource_request(
@@ -752,9 +751,9 @@ describe Signet::OAuth1::Server, 'configured' do
         :headers=>{'Content-Type'=>'application/x-www-form-urlencoded'},
         :body=>'c2&a3=2+q'}
       )
-      @server.authenticate_resource_request(
+      expect(@server.authenticate_resource_request(
         :request=>req, :two_legged=>true
-      ).should == @return_hash
+      )).to eq @return_hash
     end
     it 'should raise an error if signature is x-www-form-encoded '+
        'but does not send form parameters in header' do
@@ -770,17 +769,17 @@ describe Signet::OAuth1::Server, 'configured' do
 
       req.headers["Authorization"].gsub!(/c2=\"\", a3=\"2%20q\", /, '')
 
-      (lambda do
+      expect(lambda do
         @server.authenticate_resource_request(:request=>req, :two_legged=>true)
-      end).should raise_error(Signet::MalformedAuthorizationError,
+      end).to raise_error(Signet::MalformedAuthorizationError,
             'Request is of type application/x-www-form-urlencoded but '+
             'Authentication header did not include form values'
           )
     end
 
     it 'should call a user-supplied Proc to validate a nonce/timestamp pair' do
-      nonce_callback = mock('nonce')
-      nonce_callback.should_receive(:call).once.with(
+      nonce_callback = double('nonce')
+      expect(nonce_callback).to receive(:call).once.with(
         an_instance_of(String), an_instance_of(String)
       ).and_return(true)
 
@@ -793,8 +792,8 @@ describe Signet::OAuth1::Server, 'configured' do
     it 'should call a user-supplied Proc to fetch the client credential' do
       client_cred = Signet::OAuth1::Credential.new(@client_credential_key,
                                                    @client_credential_secret )
-      key_callback = mock('client_cred')
-      key_callback.should_receive(:call).at_least(:once).with(
+      key_callback = double('client_cred')
+      expect(key_callback).to receive(:call).at_least(:once).with(
         @client_credential_key
       ).and_return(client_cred)
 
@@ -805,21 +804,21 @@ describe Signet::OAuth1::Server, 'configured' do
     end
 
     it 'should return a informational hash for a valid request' do
-      @server.authenticate_resource_request(
+      expect(@server.authenticate_resource_request(
         :request=>make_resource_request(@client), :two_legged=>true
-      ).should == @return_hash
+      )).to eq @return_hash
     end
     it 'should return false for a unauthenticated request' do
       bad_request = make_resource_request(@client)
       bad_request.headers["Authorization"].gsub!(/oauth_signature=\".+\"/,
                                  "oauth_signature=\"foobar\"")
-      @server.authenticate_resource_request(:request=>bad_request).should == nil
+      expect(@server.authenticate_resource_request(:request=>bad_request)).to eq nil
     end
     it 'should return nil from #request_realm if no realm is provided' do
       req = make_resource_request(@client)
-      @server.request_realm(
+      expect(@server.request_realm(
         :request=>req
-      ).should == nil
+      )).to eq nil
     end
     describe 'with a Realm provided' do
       before do
@@ -828,16 +827,16 @@ describe Signet::OAuth1::Server, 'configured' do
       end
       it 'should return the realm from #request_realm' do
         req = make_resource_request(@client, {}, @realm)
-        @server.request_realm(
+        expect(@server.request_realm(
           :request=>req, :two_legged=>true
-        ).should == @realm
+        )).to eq @realm
       end
 
       it 'should return a hash containing the realm with a valid request' do
         req = make_resource_request(@client, {}, @realm)
-        @server.authenticate_resource_request(
+        expect(@server.authenticate_resource_request(
           :request=>req, :two_legged=>true
-        ).should == @return_hash
+        )).to eq @return_hash
       end
     end