jira-ruby 0.1.10 → 0.1.11

data/spec/jira/client_spec.rb

@@ -14,85 +14,85 @@ describe JIRA::Client do
 
   let(:response) do
     response = double("response")
-    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
     response
   end
 
   let(:headers) { {'Accept' => 'application/json'} }
   let(:content_type_header) { {'Content-Type' => 'application/json'} }
   let(:merged_headers) { headers.merge(content_type_header) }
-  
+
   it "creates an instance" do
-    clients.each {|client| client.class.should == JIRA::Client }
+    clients.each {|client| expect(client.class).to eq(JIRA::Client) }
   end
 
   it "allows the overriding of some options" do
     client = JIRA::Client.new({:consumer_key => 'foo', :consumer_secret => 'bar', :site => 'http://foo.com/'})
-    client.options[:site].should == 'http://foo.com/'
-    JIRA::Client::DEFAULT_OPTIONS[:site].should_not == 'http://foo.com/'
+    expect(client.options[:site]).to eq('http://foo.com/')
+    expect(JIRA::Client::DEFAULT_OPTIONS[:site]).not_to eq('http://foo.com/')
   end
 
   it "prepends the context path to the rest base path" do
     options = [:rest_base_path]
     defaults = JIRA::Client::DEFAULT_OPTIONS
     options.each do |key|
-      clients.each { |client| client.options[key].should == defaults[:context_path] + defaults[key] }
+      clients.each { |client| expect(client.options[key]).to eq(defaults[:context_path] + defaults[key]) }
     end
   end
 
   # To avoid having to validate options after initialisation, e.g. setting
   # client.options[:invalid] = 'foo'
   it "freezes the options" do
-    clients.each { |client| client.options.should be_frozen }
+    clients.each { |client| expect(client.options).to be_frozen }
   end
 
   it "merges headers" do
-    clients.each { |client| client.send(:merge_default_headers, {}).should == {'Accept' => 'application/json'} }
+    clients.each { |client| expect(client.send(:merge_default_headers, {})).to eq({'Accept' => 'application/json'}) }
   end
 
   describe "creates instances of request clients" do
     specify "that are of the correct class" do
-      oauth_client.request_client.class.should == JIRA::OauthClient
-      basic_client.request_client.class.should == JIRA::HttpClient
+      expect(oauth_client.request_client.class).to eq(JIRA::OauthClient)
+      expect(basic_client.request_client.class).to eq(JIRA::HttpClient)
     end
 
     specify "which have a corresponding auth type option" do
-      oauth_client.options[:auth_type].should == :oauth
-      basic_client.options[:auth_type].should == :basic
+      expect(oauth_client.options[:auth_type]).to eq(:oauth)
+      expect(basic_client.options[:auth_type]).to eq(:basic)
     end
 
     describe "like oauth" do
 
       it "allows setting an access token" do
         token = double()
-        OAuth::AccessToken.should_receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+        expect(OAuth::AccessToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
         access_token = oauth_client.set_access_token('foo', 'bar')
 
-        access_token.should         == token
-        oauth_client.access_token.should == token
+        expect(access_token).to eq(token)
+        expect(oauth_client.access_token).to eq(token)
       end
 
       it "allows initializing the access token" do
         request_token = OAuth::RequestToken.new(oauth_client.consumer)
-        oauth_client.consumer.stub(:get_request_token => request_token)
+        allow(oauth_client.consumer).to receive(:get_request_token).and_return(request_token)
         mock_access_token = double()
-        request_token.should_receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
+        expect(request_token).to receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
         oauth_client.init_access_token(:oauth_verifier => 'abc123')
-        oauth_client.access_token.should == mock_access_token
+        expect(oauth_client.access_token).to eq(mock_access_token)
       end
 
       specify "that has specific default options" do
         options = [:signature_method, :private_key_file]
         options.each do |key|
-          oauth_client.options[key].should == JIRA::Client::DEFAULT_OPTIONS[key]
+          expect(oauth_client.options[key]).to eq(JIRA::Client::DEFAULT_OPTIONS[key])
         end
       end
     end
 
     describe "like basic http" do
       it "sets the username and password" do
-        basic_client.options[:username].should == 'foo'
-        basic_client.options[:password].should == 'bar'
+        expect(basic_client.options[:username]).to eq('foo')
+        expect(basic_client.options[:password]).to eq('bar')
       end
     end
   end
@@ -104,16 +104,16 @@ describe JIRA::Client do
 
     specify "that merge default headers" do
       # stubbed response for generic client request method
-      oauth_client.should_receive(:request).exactly(5).times.and_return(response)
-      basic_client.should_receive(:request).exactly(5).times.and_return(response)
+      expect(oauth_client).to receive(:request).exactly(5).times.and_return(response)
+      expect(basic_client).to receive(:request).exactly(5).times.and_return(response)
 
       # response for merging headers for http methods with no body
-      oauth_client.should_receive(:merge_default_headers).exactly(3).times.with({})
-      basic_client.should_receive(:merge_default_headers).exactly(3).times.with({})
+      expect(oauth_client).to receive(:merge_default_headers).exactly(3).times.with({})
+      expect(basic_client).to receive(:merge_default_headers).exactly(3).times.with({})
 
       # response for merging headers for http methods with body
-      oauth_client.should_receive(:merge_default_headers).exactly(2).times.with(content_type_header)
-      basic_client.should_receive(:merge_default_headers).exactly(2).times.with(content_type_header)
+      expect(oauth_client).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
+      expect(basic_client).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
 
       [:delete, :get, :head].each do |method|
         oauth_client.send(method, '/path', {})
@@ -128,15 +128,15 @@ describe JIRA::Client do
 
     specify "that call the generic request method" do
       [:delete, :get, :head].each do |method|
-        oauth_client.should_receive(:request).with(method, '/path', nil, headers).and_return(response)
-        basic_client.should_receive(:request).with(method, '/path', nil, headers).and_return(response)
+        expect(oauth_client).to receive(:request).with(method, '/path', nil, headers).and_return(response)
+        expect(basic_client).to receive(:request).with(method, '/path', nil, headers).and_return(response)
         oauth_client.send(method, '/path', {})
         basic_client.send(method, '/path', {})
       end
 
       [:post, :put].each do |method|
-        oauth_client.should_receive(:request).with(method, '/path', '', merged_headers)
-        basic_client.should_receive(:request).with(method, '/path', '', merged_headers)
+        expect(oauth_client).to receive(:request).with(method, '/path', '', merged_headers)
+        expect(basic_client).to receive(:request).with(method, '/path', '', merged_headers)
         oauth_client.send(method, '/path', '', {})
         basic_client.send(method, '/path', '', {})
       end
@@ -145,44 +145,44 @@ describe JIRA::Client do
     describe "that call a oauth client" do
       specify "which makes a request" do
         [:delete, :get, :head].each do |method|
-          oauth_client.request_client.should_receive(:make_request).with(method, '/path', nil, headers).and_return(response)
+          expect(oauth_client.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(response)
           oauth_client.send(method, '/path', {})
         end
         [:post, :put].each do |method|
-          oauth_client.request_client.should_receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
+          expect(oauth_client.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
           oauth_client.send(method, '/path', '', {})
         end
       end
     end
-    
+
     describe "that call a http client" do
       it "which makes a request" do
         [:delete, :get, :head].each do |method|
-          basic_client.request_client.should_receive(:make_request).with(method, '/path', nil, headers).and_return(response)
+          expect(basic_client.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(response)
           basic_client.send(method, '/path', headers)
         end
         [:post, :put].each do |method|
-          basic_client.request_client.should_receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
+          expect(basic_client.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
           basic_client.send(method, '/path', '', headers)
         end
       end
     end
   end
-  
+
   describe "Resource Factories" do
     it "gets all projects" do
-      JIRA::Resource::Project.should_receive(:all).with(oauth_client).and_return([])
-      JIRA::Resource::Project.should_receive(:all).with(basic_client).and_return([])
-      oauth_client.Project.all.should == []
-      basic_client.Project.all.should == []
+      expect(JIRA::Resource::Project).to receive(:all).with(oauth_client).and_return([])
+      expect(JIRA::Resource::Project).to receive(:all).with(basic_client).and_return([])
+      expect(oauth_client.Project.all).to eq([])
+      expect(basic_client.Project.all).to eq([])
     end
 
     it "finds a single project" do
       find_result = double()
-      JIRA::Resource::Project.should_receive(:find).with(oauth_client, '123').and_return(find_result)
-      JIRA::Resource::Project.should_receive(:find).with(basic_client, '123').and_return(find_result)
-      oauth_client.Project.find('123').should == find_result
-      basic_client.Project.find('123').should == find_result
+      expect(JIRA::Resource::Project).to receive(:find).with(oauth_client, '123').and_return(find_result)
+      expect(JIRA::Resource::Project).to receive(:find).with(basic_client, '123').and_return(find_result)
+      expect(oauth_client.Project.find('123')).to eq(find_result)
+      expect(basic_client.Project.find('123')).to eq(find_result)
     end
   end
 end

data/spec/jira/has_many_proxy_spec.rb

@@ -10,36 +10,38 @@ describe JIRA::HasManyProxy do
   let(:collection)  { double("collection") }
 
   it "has a target class" do
-    subject.target_class.should == Foo
+    expect(subject.target_class).to eq(Foo)
   end
 
   it "has a parent" do
-    subject.parent.should == parent
+    expect(subject.parent).to eq(parent)
   end
 
   it "has a collection" do
-    subject.collection.should == collection
+    expect(subject.collection).to eq(collection)
   end
 
   it "can build a new instance" do
     client = double('client')
     foo = double('foo')
-    parent.stub(:client => client, :to_sym => :parent)
-    Foo.should_receive(:new).with(client, :attrs => {'foo' => 'bar'}, :parent => parent).and_return(foo)
-    collection.should_receive(:<<).with(foo)
-    subject.build('foo' => 'bar').should == foo
+    allow(parent).to receive(:client).and_return(client)
+    allow(parent).to receive(:to_sym).and_return(:parent)
+    expect(Foo).to receive(:new).with(client, :attrs => {'foo' => 'bar'}, :parent => parent).and_return(foo)
+    expect(collection).to receive(:<<).with(foo)
+    expect(subject.build('foo' => 'bar')).to eq(foo)
   end
 
   it "can get all the instances" do
     foo = double('foo')
     client = double('client')
-    parent.stub(:client => client, :to_sym => :parent)
-    Foo.should_receive(:all).with(client, :parent => parent).and_return(foo)
-    subject.all.should == foo
+    allow(parent).to receive(:client).and_return(client)
+    allow(parent).to receive(:to_sym).and_return(:parent)
+    expect(Foo).to receive(:all).with(client, :parent => parent).and_return(foo)
+    expect(subject.all).to eq(foo)
   end
 
   it "delegates missing methods to the collection" do
-    collection.should_receive(:missing_method)
+    expect(collection).to receive(:missing_method)
     subject.missing_method
   end
 end

data/spec/jira/http_client_spec.rb

@@ -14,18 +14,18 @@ describe JIRA::HttpClient do
 
   let(:response) do
     response = double("response")
-    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
     response
   end
 
   let(:cookie_response) do
     response = double("response")
-    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
     response
   end
 
   it "creates an instance of Net:HTTP for a basic auth client" do
-    basic_client.basic_auth_http_conn.class.should == Net::HTTP
+    expect(basic_client.basic_auth_http_conn.class).to eq(Net::HTTP)
   end
 
   it "responds to the http methods" do
@@ -33,17 +33,17 @@ describe JIRA::HttpClient do
     headers = double()
     basic_auth_http_conn = double()
     request = double()
-    basic_client.stub(:basic_auth_http_conn => basic_auth_http_conn)
-    request.should_receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).exactly(5).times.and_return(request)
-    basic_auth_http_conn.should_receive(:request).exactly(5).times.with(request).and_return(response)
+    allow(basic_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+    expect(request).to receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).exactly(5).times.and_return(request)
+    expect(basic_auth_http_conn).to receive(:request).exactly(5).times.with(request).and_return(response)
     [:delete, :get, :head].each do |method|
-      Net::HTTP.const_get(method.to_s.capitalize).should_receive(:new).with('/path', headers).and_return(request)
-      basic_client.make_request(method, '/path', nil, headers).should == response
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(basic_client.make_request(method, '/path', nil, headers)).to eq(response)
     end
     [:post, :put].each do |method|
-      Net::HTTP.const_get(method.to_s.capitalize).should_receive(:new).with('/path', headers).and_return(request)
-      request.should_receive(:body=).with(body).and_return(request)
-      basic_client.make_request(method, '/path', body, headers).should == response
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(request).to receive(:body=).with(body).and_return(request)
+      expect(basic_client.make_request(method, '/path', body, headers)).to eq(response)
     end
   end
 
@@ -52,18 +52,18 @@ describe JIRA::HttpClient do
     headers = double()
     basic_auth_http_conn = double()
     request = double()
-    basic_cookie_client.stub(:basic_auth_http_conn => basic_auth_http_conn)
-    request.should_receive(:basic_auth).with(basic_cookie_client.options[:username], basic_cookie_client.options[:password]).exactly(5).times.and_return(request)
-    cookie_response.should_receive(:get_fields).with('set-cookie').exactly(5).times
-    basic_auth_http_conn.should_receive(:request).exactly(5).times.with(request).and_return(cookie_response)
+    allow(basic_cookie_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+    expect(request).to receive(:basic_auth).with(basic_cookie_client.options[:username], basic_cookie_client.options[:password]).exactly(5).times.and_return(request)
+    expect(cookie_response).to receive(:get_fields).with('set-cookie').exactly(5).times
+    expect(basic_auth_http_conn).to receive(:request).exactly(5).times.with(request).and_return(cookie_response)
     [:delete, :get, :head].each do |method|
-      Net::HTTP.const_get(method.to_s.capitalize).should_receive(:new).with('/path', headers).and_return(request)
-      basic_cookie_client.make_request(method, '/path', nil, headers).should == cookie_response
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(basic_cookie_client.make_request(method, '/path', nil, headers)).to eq(cookie_response)
     end
     [:post, :put].each do |method|
-      Net::HTTP.const_get(method.to_s.capitalize).should_receive(:new).with('/path', headers).and_return(request)
-      request.should_receive(:body=).with(body).and_return(request)
-      basic_cookie_client.make_request(method, '/path', body, headers).should == cookie_response
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(request).to receive(:body=).with(body).and_return(request)
+      expect(basic_cookie_client.make_request(method, '/path', body, headers)).to eq(cookie_response)
     end
   end
 
@@ -73,17 +73,17 @@ describe JIRA::HttpClient do
     headers = double()
     basic_auth_http_conn = double()
     http_request = double()
-    Net::HTTP::Get.should_receive(:new).with('/foo', headers).and_return(http_request)
+    expect(Net::HTTP::Get).to receive(:new).with('/foo', headers).and_return(http_request)
 
-    basic_auth_http_conn.should_receive(:request).with(http_request).and_return(response)
-    http_request.should_receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).and_return(http_request)
-    basic_client.stub(:basic_auth_http_conn => basic_auth_http_conn)
+    expect(basic_auth_http_conn).to receive(:request).with(http_request).and_return(response)
+    expect(http_request).to receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).and_return(http_request)
+    allow(basic_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
     basic_client.make_request(:get, '/foo', body, headers)
   end
 
   it "returns a URI" do
     uri = URI.parse(basic_client.options[:site])
-    basic_client.uri.should == uri
+    expect(basic_client.uri).to eq(uri)
   end
 
   it "sets up a http connection with options" do
@@ -91,19 +91,19 @@ describe JIRA::HttpClient do
     uri = double()
     host = double()
     port = double()
-    uri.should_receive(:host).and_return(host)
-    uri.should_receive(:port).and_return(port)
-    Net::HTTP.should_receive(:new).with(host, port).and_return(http_conn)
-    http_conn.should_receive(:use_ssl=).with(basic_client.options[:use_ssl]).and_return(http_conn)
-    http_conn.should_receive(:verify_mode=).with(basic_client.options[:ssl_verify_mode]).and_return(http_conn)
-    basic_client.http_conn(uri).should == http_conn
+    expect(uri).to receive(:host).and_return(host)
+    expect(uri).to receive(:port).and_return(port)
+    expect(Net::HTTP).to receive(:new).with(host, port).and_return(http_conn)
+    expect(http_conn).to receive(:use_ssl=).with(basic_client.options[:use_ssl]).and_return(http_conn)
+    expect(http_conn).to receive(:verify_mode=).with(basic_client.options[:ssl_verify_mode]).and_return(http_conn)
+    expect(basic_client.http_conn(uri)).to eq(http_conn)
   end
 
   it "returns a http connection" do
     http_conn = double()
     uri = double()
-    basic_client.should_receive(:uri).and_return(uri)
-    basic_client.should_receive(:http_conn).and_return(http_conn)
-    basic_client.basic_auth_http_conn.should == http_conn
+    expect(basic_client).to receive(:uri).and_return(uri)
+    expect(basic_client).to receive(:http_conn).and_return(http_conn)
+    expect(basic_client.basic_auth_http_conn).to eq(http_conn)
   end
 end

data/spec/jira/http_error_spec.rb

@@ -2,24 +2,25 @@ require 'spec_helper'
 
 describe JIRA::HTTPError do
 
-  let(:response)  { 
-    response = double("response") 
-    response.stub(:code => 401)
-    response.stub(:message => "A MESSAGE WOO")
+  let(:response)  {
+    response = double("response")
+    allow(response).to receive(:code).and_return(401)
+    allow(response).to receive(:message).and_return("A MESSAGE WOO")
     response
   }
+
   subject { described_class.new(response) }
 
   it "takes the response object as an argument" do
-    subject.response.should == response
+    expect(subject.response).to eq(response)
   end
 
   it "has a code method" do
-    subject.code.should == response.code
+    expect(subject.code).to eq(response.code)
   end
 
   it "returns code and class from message" do
-    subject.message.should == response.message
+    expect(subject.message).to eq(response.message)
   end
 
 end

data/spec/jira/oauth_client_spec.rb

@@ -10,76 +10,76 @@ describe JIRA::OauthClient do
 
   let(:response) do
     response = double("response")
-    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
     response
   end
-  
+
   describe "authenticating with oauth" do
     it "prepends the context path to all authorization and rest paths" do
       options = [:request_token_path, :authorize_path, :access_token_path]
       defaults = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::OauthClient::DEFAULT_OPTIONS)
       options.each do |key|
-        oauth_client.options[key].should == defaults[:context_path] + defaults[key]
+        expect(oauth_client.options[key]).to eq(defaults[:context_path] + defaults[key])
       end
     end
 
     it "creates a Oauth::Consumer on initialize" do
-      oauth_client.consumer.class.should == OAuth::Consumer
-      oauth_client.consumer.key.should == oauth_client.key
-      oauth_client.consumer.secret.should == oauth_client.secret
+      expect(oauth_client.consumer.class).to eq(OAuth::Consumer)
+      expect(oauth_client.consumer.key).to eq(oauth_client.key)
+      expect(oauth_client.consumer.secret).to eq(oauth_client.secret)
     end
 
     it "returns an OAuth request_token" do
       # Cannot just check for method delegation as http connection will be attempted
       request_token = OAuth::RequestToken.new(oauth_client.consumer)
-      oauth_client.consumer.stub(:get_request_token => request_token)
-      oauth_client.get_request_token.should == request_token
+      allow(oauth_client).to receive(:get_request_token).and_return(request_token)
+      expect(oauth_client.get_request_token).to eq(request_token)
     end
 
     it "allows setting the request token" do
       token = double()
-      OAuth::RequestToken.should_receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+      expect(OAuth::RequestToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
 
       request_token = oauth_client.set_request_token('foo', 'bar')
 
-      request_token.should == token
-      oauth_client.request_token.should == token
+      expect(request_token).to eq(token)
+      expect(oauth_client.request_token).to eq(token)
     end
 
     it "allows setting the consumer key" do
-      oauth_client.key.should == 'foo'
+      expect(oauth_client.key).to eq('foo')
     end
 
     it "allows setting the consumer secret" do
-      oauth_client.secret.should == 'bar'
+      expect(oauth_client.secret).to eq('bar')
     end
 
     describe "the access token" do
 
       it "initializes" do
         request_token = OAuth::RequestToken.new(oauth_client.consumer)
-        oauth_client.consumer.stub(:get_request_token => request_token)
+        allow(oauth_client).to receive(:get_request_token).and_return(request_token)
         mock_access_token = double()
-        request_token.should_receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
+        expect(request_token).to receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
         oauth_client.init_access_token(:oauth_verifier => 'abc123')
-        oauth_client.access_token.should == mock_access_token
+        expect(oauth_client.access_token).to eq(mock_access_token)
       end
 
       it "raises an exception when accessing without initialisation" do
         expect {
           oauth_client.access_token
-        }.to raise_exception(JIRA::OauthClient::UninitializedAccessTokenError, 
+        }.to raise_exception(JIRA::OauthClient::UninitializedAccessTokenError,
                              "init_access_token must be called before using the client")
       end
 
       it "allows setting the access token" do
         token = double()
-        OAuth::AccessToken.should_receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+        expect(OAuth::AccessToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
 
         access_token = oauth_client.set_access_token('foo', 'bar')
 
-        access_token.should         == token
-        oauth_client.access_token.should == token
+        expect(access_token).to eq(token)
+        expect(oauth_client.access_token).to eq(token)
       end
     end
 
@@ -87,13 +87,13 @@ describe JIRA::OauthClient do
       it "responds to the http methods" do
         headers = double()
         mock_access_token = double()
-        oauth_client.stub(:access_token => mock_access_token)
+        allow(oauth_client).to receive(:access_token).and_return(mock_access_token)
         [:delete, :get, :head].each do |method|
-          mock_access_token.should_receive(method).with('/path', headers).and_return(response)
+          expect(mock_access_token).to receive(method).with('/path', headers).and_return(response)
           oauth_client.make_request(method, '/path', '', headers)
         end
         [:post, :put].each do |method|
-          mock_access_token.should_receive(method).with('/path', '', headers).and_return(response)
+          expect(mock_access_token).to receive(method).with('/path', '', headers).and_return(response)
           oauth_client.make_request(method, '/path', '', headers)
         end
       end
@@ -102,8 +102,8 @@ describe JIRA::OauthClient do
         body = nil
         headers = double()
         access_token = double()
-        access_token.should_receive(:send).with(:get, '/foo', headers).and_return(response)
-        oauth_client.stub(:access_token => access_token)
+        expect(access_token).to receive(:send).with(:get, '/foo', headers).and_return(response)
+        allow(oauth_client).to receive(:access_token).and_return(access_token)
         oauth_client.request(:get, '/foo', body, headers)
       end
     end