jira-ruby 2.3.0 → 3.0.0.beta2

data/spec/jira/client_spec.rb

@@ -28,7 +28,7 @@ RSpec.shared_examples 'Client Common Tests' do
       expect(subject).to receive(:merge_default_headers).exactly(3).times.with({})
 
       # response for merging headers for http methods with body
-      expect(subject).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
+      expect(subject).to receive(:merge_default_headers).twice.with(content_type_header)
 
       %i[delete get head].each { |method| subject.send(method, '/path', {}) }
       %i[post put].each { |method| subject.send(method, '/path', '', content_type_header) }
@@ -62,13 +62,22 @@ RSpec.shared_examples 'Client Common Tests' do
 
   describe 'SSL client options' do
     context 'without certificate and key' do
-      let(:options) { { use_client_cert: true } }
-      subject { JIRA::Client.new(options) }
+      let(:basic_options) { { use_client_cert: true } }
 
-      it 'raises an ArgumentError' do
-        expect { subject }.to raise_exception(ArgumentError, 'Options: :cert_path or :ssl_client_cert must be set when :use_client_cert is true')
-        options[:ssl_client_cert] = '<cert></cert>'
-        expect { subject }.to raise_exception(ArgumentError, 'Options: :key_path or :ssl_client_key must be set when :use_client_cert is true')
+      it 'raises an ArgumentError when cert is missing' do
+        expect do
+          JIRA::Client.new(basic_options)
+        end.to raise_exception(ArgumentError,
+                               'Options: :cert_path or :ssl_client_cert must be set when :use_client_cert is true')
+      end
+
+      it 'raises an ArgumentError when key is missing' do
+        options_with_cert = basic_options.merge(ssl_client_cert: '<cert></cert>')
+
+        expect do
+          JIRA::Client.new(options_with_cert)
+        end.to raise_exception(ArgumentError,
+                               'Options: :key_path or :ssl_client_key must be set when :use_client_cert is true')
       end
     end
   end
@@ -77,11 +86,13 @@ end
 RSpec.shared_examples 'HttpClient tests' do
   it 'makes a valid request' do
     %i[delete get head].each do |method|
-      expect(subject.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(successful_response)
+      expect(subject.request_client).to receive(:make_request).with(method, '/path', nil,
+                                                                    headers).and_return(successful_response)
       subject.send(method, '/path', headers)
     end
     %i[post put].each do |method|
-      expect(subject.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(successful_response)
+      expect(subject.request_client).to receive(:make_request).with(method, '/path', '',
+                                                                    merged_headers).and_return(successful_response)
       subject.send(method, '/path', '', headers)
     end
   end
@@ -96,21 +107,23 @@ RSpec.shared_examples 'OAuth Common Tests' do
     token = double
     expect(OAuth::AccessToken).to receive(:new).with(subject.consumer, '', '').and_return(token)
 
-    expect(subject.authenticated?).to be_falsey
+    expect(subject).not_to be_authenticated
     access_token = subject.set_access_token('', '')
     expect(access_token).to eq(token)
     expect(subject.access_token).to eq(token)
-    expect(subject.authenticated?).to be_truthy
+    expect(subject).to be_authenticated
   end
 
   describe 'that call a oauth client' do
     specify 'which makes a request' do
       %i[delete get head].each do |method|
-        expect(subject.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(successful_response)
+        expect(subject.request_client).to receive(:make_request).with(method, '/path', nil,
+                                                                      headers).and_return(successful_response)
         subject.send(method, '/path', {})
       end
       %i[post put].each do |method|
-        expect(subject.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(successful_response)
+        expect(subject.request_client).to receive(:make_request).with(method, '/path', '',
+                                                                      merged_headers).and_return(successful_response)
         subject.send(method, '/path', '', {})
       end
     end
@@ -128,22 +141,24 @@ describe JIRA::Client do
   let(:headers) { { 'Accept' => 'application/json' } }
   let(:merged_headers) { headers.merge(content_type_header) }
 
-  context 'behaviour that applies to all client classes irrespective of authentication method' do
+  context 'without regard to the authentication method, this behaviour applies to all client classes' do
     it 'allows the overriding of some options' do
-      client = JIRA::Client.new(consumer_key: 'foo', consumer_secret: 'bar', site: 'http://foo.com/')
+      client = described_class.new(consumer_key: 'foo', consumer_secret: 'bar', site: '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
   end
 
   context 'with basic http authentication' do
-    subject { JIRA::Client.new(username: 'foo', password: 'bar', auth_type: :basic) }
+    subject { described_class.new(username: 'foo', password: 'bar', auth_type: :basic) }
 
-    before(:each) do
-      stub_request(:get, 'https://foo:bar@localhost:2990/jira/rest/api/2/project')
+    before do
+      stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
+        .with(headers: { 'Authorization' => "Basic #{Base64.strict_encode64('foo:bar').chomp}" })
         .to_return(status: 200, body: '[]', headers: {})
 
-      stub_request(:get, 'https://foo:badpassword@localhost:2990/jira/rest/api/2/project')
+      stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
+        .with(headers: { 'Authorization' => "Basic #{Base64.strict_encode64('foo:badpassword').chomp}" })
         .to_return(status: 401, headers: {})
     end
 
@@ -157,33 +172,33 @@ describe JIRA::Client do
       expect(subject.options[:password]).to eq('bar')
     end
 
-    it 'fails with wrong user name and password' do
-      bad_login = JIRA::Client.new(username: 'foo', password: 'badpassword', auth_type: :basic)
-      expect(bad_login.authenticated?).to be_falsey
-      expect { bad_login.Project.all }.to raise_error JIRA::HTTPError
-    end
-
     it 'only returns a true for #authenticated? once we have requested some data' do
-      expect(subject.authenticated?).to be_falsey
+      expect(subject.authenticated?).to be_nil
       expect(subject.Project.all).to be_empty
-      expect(subject.authenticated?).to be_truthy
+      expect(subject).to be_authenticated
+    end
+
+    it 'fails with wrong user name and password' do
+      bad_login = described_class.new(username: 'foo', password: 'badpassword', auth_type: :basic)
+      expect(bad_login).not_to be_authenticated
+      expect { bad_login.Project.all }.to raise_error JIRA::HTTPError
     end
   end
 
   context 'with cookie authentication' do
-    subject { JIRA::Client.new(username: 'foo', password: 'bar', auth_type: :cookie) }
+    subject { described_class.new(username: 'foo', password: 'bar', auth_type: :cookie) }
 
     let(:session_cookie) { '6E3487971234567896704A9EB4AE501F' }
     let(:session_body) do
       {
-        'session': { 'name' => 'JSESSIONID', 'value' => session_cookie },
-        'loginInfo': { 'failedLoginCount' => 1, 'loginCount' => 2,
-                       'lastFailedLoginTime' => (DateTime.now - 2).iso8601,
-                       'previousLoginTime' => (DateTime.now - 5).iso8601 }
+        session: { 'name' => 'JSESSIONID', 'value' => session_cookie },
+        loginInfo: { 'failedLoginCount' => 1, 'loginCount' => 2,
+                     'lastFailedLoginTime' => (DateTime.now - 2).iso8601,
+                     'previousLoginTime' => (DateTime.now - 5).iso8601 }
       }
     end
 
-    before(:each) do
+    before do
       # General case of API call with no authentication, or wrong authentication
       stub_request(:post, 'https://localhost:2990/jira/rest/auth/1/session')
         .to_return(status: 401, headers: {})
@@ -210,7 +225,7 @@ describe JIRA::Client do
     end
 
     it 'does not authenticate with an incorrect username and password' do
-      bad_client = JIRA::Client.new(username: 'foo', password: 'bad_password', auth_type: :cookie)
+      bad_client = described_class.new(username: 'foo', password: 'bad_password', auth_type: :cookie)
       expect(bad_client).not_to be_authenticated
     end
 
@@ -222,7 +237,7 @@ describe JIRA::Client do
 
   context 'with jwt authentication' do
     subject do
-      JIRA::Client.new(
+      described_class.new(
         issuer: 'foo',
         base_url: 'https://host.tld',
         shared_secret: 'shared_secret_key',
@@ -230,10 +245,10 @@ describe JIRA::Client do
       )
     end
 
-    before(:each) do
+    before do
       stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
-          .with(query: hash_including(:jwt))
-          .to_return(status: 200, body: '[]', headers: {})
+        .with(headers: { 'Authorization' => /JWT .+/ })
+        .to_return(status: 200, body: '[]', headers: {})
     end
 
     include_examples 'Client Common Tests'
@@ -248,12 +263,12 @@ describe JIRA::Client do
     context 'with a incorrect jwt key' do
       before do
         stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
-            .with(query: hash_including(:jwt))
-            .to_return(status: 401, body: '[]', headers: {})
+          .with(headers: { 'Authorization' => /JWT .+/ })
+          .to_return(status: 401, body: '[]', headers: {})
       end
 
       it 'is not authenticated' do
-        expect(subject.authenticated?).to be_falsey
+        expect(subject).not_to be_authenticated
       end
 
       it 'raises a JIRA::HTTPError when trying to fetch projects' do
@@ -262,27 +277,28 @@ describe JIRA::Client do
     end
 
     it 'only returns a true for #authenticated? once we have requested some data' do
-      expect(subject.authenticated?).to be_falsey
+      expect(subject).not_to be_authenticated
       expect(subject.Project.all).to be_empty
-      expect(subject.authenticated?).to be_truthy
+      expect(subject).to be_authenticated
     end
   end
 
-  context 'oauth authentication' do
-    subject { JIRA::Client.new(consumer_key: 'foo', consumer_secret: 'bar') }
+  context 'with oauth' do
+    subject { described_class.new(consumer_key: 'foo', consumer_secret: 'bar') }
 
     include_examples 'OAuth Common Tests'
   end
 
   context 'with oauth_2legged' do
-    subject { JIRA::Client.new(consumer_key: 'foo', consumer_secret: 'bar', auth_type: :oauth_2legged) }
+    subject { described_class.new(consumer_key: 'foo', consumer_secret: 'bar', auth_type: :oauth_2legged) }
 
     include_examples 'OAuth Common Tests'
   end
 
   context 'with unknown options' do
+    subject { described_class.new(options) }
+
     let(:options) { { 'username' => 'foo', 'password' => 'bar', auth_type: :basic } }
-    subject { JIRA::Client.new(options) }
 
     it 'raises an ArgumentError' do
       expect { subject }.to raise_exception(ArgumentError, 'Unknown option(s) given: ["username", "password"]')

data/spec/jira/has_many_proxy_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe JIRA::HasManyProxy do
   class Foo; end
 
-  subject { JIRA::HasManyProxy.new(parent, Foo, collection) }
+  subject { described_class.new(parent, Foo, collection) }
 
   let(:parent)      { double('parent') }
   let(:collection)  { double('collection') }
@@ -25,7 +25,7 @@ describe JIRA::HasManyProxy do
     foo = double('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(Foo).to receive(:new).with(client, attrs: { 'foo' => 'bar' }, parent:).and_return(foo)
     expect(collection).to receive(:<<).with(foo)
     expect(subject.build('foo' => 'bar')).to eq(foo)
   end
@@ -35,7 +35,7 @@ describe JIRA::HasManyProxy do
     client = double('client')
     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(Foo).to receive(:all).with(client, parent:).and_return(foo)
     expect(subject.all).to eq(foo)
   end
 

data/spec/jira/http_client_spec.rb

@@ -5,7 +5,7 @@ describe JIRA::HttpClient do
     options = JIRA::Client::DEFAULT_OPTIONS
               .merge(JIRA::HttpClient::DEFAULT_OPTIONS)
               .merge(basic_auth_credentials)
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:basic_cookie_client) do
@@ -13,12 +13,12 @@ describe JIRA::HttpClient do
               .merge(JIRA::HttpClient::DEFAULT_OPTIONS)
               .merge(use_cookies: true)
               .merge(basic_auth_credentials)
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:custom_ssl_version_client) do
     options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(ssl_version: :TLSv1_2)
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:basic_cookie_client_with_context_path) do
@@ -26,7 +26,7 @@ describe JIRA::HttpClient do
       use_cookies: true,
       context_path: '/context'
     )
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:basic_cookie_client_with_additional_cookies) do
@@ -37,7 +37,7 @@ describe JIRA::HttpClient do
                 additional_cookies: ['sessionToken=abc123', 'internal=true']
               )
               .merge(basic_auth_credentials)
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:basic_client_cert_client) do
@@ -46,13 +46,13 @@ describe JIRA::HttpClient do
       cert: 'public certificate contents',
       key: 'private key contents'
     )
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:basic_client_with_no_auth_credentials) do
     options = JIRA::Client::DEFAULT_OPTIONS
               .merge(JIRA::HttpClient::DEFAULT_OPTIONS)
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
   end
 
   let(:basic_auth_credentials) do
@@ -66,7 +66,14 @@ describe JIRA::HttpClient do
       proxy_username: 'proxyUsername',
       proxy_password: 'proxyPassword'
     )
-    JIRA::HttpClient.new(options)
+    described_class.new(options)
+  end
+
+  let(:basic_client_with_max_retries) do
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
+      max_retries: 2
+    )
+    described_class.new(options)
   end
 
   let(:response) do
@@ -81,6 +88,35 @@ describe JIRA::HttpClient do
     response
   end
 
+  context 'with a simple client' do
+    let(:client) do
+      options_local = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
+        proxy_address: 'proxyAddress',
+        proxy_port: 42,
+        proxy_username: 'proxyUsername',
+        proxy_password: 'proxyPassword'
+      )
+      described_class.new(options_local)
+    end
+
+    describe 'HttpClient#basic_auth_http_conn' do
+      subject(:http_conn) { basic_client.basic_auth_http_conn }
+
+      it 'creates an instance of Net:HTTP for a basic auth client' do
+        expect(http_conn.class).to eq(Net::HTTP)
+      end
+
+      it 'the connection created has no proxy' do
+        http_conn
+
+        expect(http_conn.proxy_address).to be_nil
+        expect(http_conn.proxy_port).to be_nil
+        expect(http_conn.proxy_user).to be_nil
+        expect(http_conn.proxy_pass).to be_nil
+      end
+    end
+  end
+
   it 'creates an instance of Net:HTTP for a basic auth client' do
     expect(basic_client.basic_auth_http_conn.class).to eq(Net::HTTP)
   end
@@ -111,7 +147,8 @@ describe JIRA::HttpClient do
     basic_auth_http_conn = double
     request = double
     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(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)
     %i[delete get head].each do |method|
       expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
@@ -130,7 +167,8 @@ describe JIRA::HttpClient do
     basic_auth_http_conn = double
     request = double
     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(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)
     %i[delete get head].each do |method|
@@ -151,7 +189,8 @@ describe JIRA::HttpClient do
     basic_auth_http_conn = double
     request = double
     allow(client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
-    expect(request).to receive(:basic_auth).with(client.options[:username], client.options[:password]).exactly(5).times.and_return(request)
+    expect(request).to receive(:basic_auth).with(client.options[:username],
+                                                 client.options[:password]).exactly(5).times.and_return(request)
     expect(request).to receive(:add_field).with('Cookie', 'sessionToken=abc123; internal=true').exactly(5).times
     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)
@@ -174,7 +213,8 @@ describe JIRA::HttpClient do
     expect(Net::HTTP::Get).to receive(:new).with('/foo', headers).and_return(http_request)
 
     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)
+    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
@@ -187,7 +227,8 @@ describe JIRA::HttpClient do
     expect(Net::HTTP::Get).to receive(:new).with('/foo', headers).and_return(http_request)
 
     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)
+    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, 'http://mydomain.com/foo', body, headers)
   end
@@ -254,19 +295,29 @@ describe JIRA::HttpClient do
     expect(proxy_configuration.proxy_pass).to be_nil
   end
 
-  it 'sets up a proxied http connection when using proxy options' do
-    uri = double
-    host = double
-    port = double
+  context 'when the client has proxy settings' do
+    subject(:proxy_conn) { proxy_client.basic_auth_http_conn }
+
+    let(:proxy_client) do
+      options_local = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
+        proxy_address: 'proxyAddress',
+        proxy_port: 42,
+        proxy_username: 'proxyUsername',
+        proxy_password: 'proxyPassword'
+      )
+      described_class.new(options_local)
+    end
 
-    expect(uri).to receive(:host).and_return(host)
-    expect(uri).to receive(:port).and_return(port)
+    describe 'HttpClient#basic_auth_http_conn' do
+      it 'creates a Net:HTTP instance for a basic auth client setting up a proxied http connection' do
+        expect(proxy_conn.class).to eq(Net::HTTP)
 
-    proxy_configuration = proxy_client.http_conn(uri).class
-    expect(proxy_configuration.proxy_address).to eq(proxy_client.options[:proxy_address])
-    expect(proxy_configuration.proxy_port).to eq(proxy_client.options[:proxy_port])
-    expect(proxy_configuration.proxy_user).to eq(proxy_client.options[:proxy_username])
-    expect(proxy_configuration.proxy_pass).to eq(proxy_client.options[:proxy_password])
+        expect(proxy_conn.proxy_address).to eq(proxy_client.options[:proxy_address])
+        expect(proxy_conn.proxy_port).to eq(proxy_client.options[:proxy_port])
+        expect(proxy_conn.proxy_user).to eq(proxy_client.options[:proxy_username])
+        expect(proxy_conn.proxy_pass).to eq(proxy_client.options[:proxy_password])
+      end
+    end
   end
 
   it 'can use client certificates' do
@@ -286,10 +337,25 @@ describe JIRA::HttpClient do
   end
 
   it 'can use a certificate authority file' do
-    client = JIRA::HttpClient.new(JIRA::Client::DEFAULT_OPTIONS.merge(ca_file: '/opt/custom.ca.pem'))
+    client = described_class.new(JIRA::Client::DEFAULT_OPTIONS.merge(ca_file: '/opt/custom.ca.pem'))
     expect(client.http_conn(client.uri).ca_file).to eql('/opt/custom.ca.pem')
   end
 
+  it 'allows overriding max_retries' do
+    http_conn = double
+    uri = double
+    host = double
+    port = double
+    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(http_conn).to receive(:read_timeout=).with(basic_client.options[:read_timeout]).and_return(http_conn)
+    expect(http_conn).to receive(:max_retries=).with(basic_client_with_max_retries.options[:max_retries]).and_return(http_conn)
+    expect(basic_client_with_max_retries.http_conn(uri)).to eq(http_conn)
+  end
+
   it 'returns a http connection' do
     http_conn = double
     uri = double
@@ -307,7 +373,7 @@ describe JIRA::HttpClient do
     let(:data) { {} }
     let(:headers) { { 'X-Atlassian-Token' => 'no-check' } }
     let(:basic_auth_http_conn) { double }
-    let(:request) { double('Http Request', path: path) }
+    let(:request) { double('Http Request', path:) }
     let(:response) { double('response') }
 
     before do
@@ -318,7 +384,8 @@ describe JIRA::HttpClient do
     end
 
     it 'performs a basic http client request' do
-      expect(request).to receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).and_return(request)
+      expect(request).to receive(:basic_auth).with(basic_client.options[:username],
+                                                   basic_client.options[:password]).and_return(request)
 
       subject
     end

data/spec/jira/http_error_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe JIRA::HTTPError do
+  subject { described_class.new(response) }
+
   let(:response) do
     response = double('response')
     allow(response).to receive(:code).and_return(401)
@@ -8,8 +10,6 @@ describe JIRA::HTTPError do
     response
   end
 
-  subject { described_class.new(response) }
-
   it 'takes the response object as an argument' do
     expect(subject.response).to eq(response)
   end

data/spec/jira/oauth_client_spec.rb

@@ -4,7 +4,7 @@ describe JIRA::OauthClient do
   let(:oauth_client) do
     options = { consumer_key: 'foo', consumer_secret: 'bar' }
     options = JIRA::Client::DEFAULT_OPTIONS.merge(options)
-    JIRA::OauthClient.new(options)
+    described_class.new(options)
   end
 
   let(:response) do
@@ -37,7 +37,7 @@ describe JIRA::OauthClient do
 
     it 'could pre-process the response body in a block' do
       response = Net::HTTPSuccess.new(1.0, '200', 'OK')
-      allow_any_instance_of(OAuth::Consumer).to receive(:request).and_return(response)
+      allow(oauth_client.consumer).to receive(:request).and_return(response)
       allow(response).to receive(:body).and_return('&oauth_token=token&oauth_token_secret=secret&password=top_secret')
 
       result = oauth_client.request_token do |response_body|
@@ -124,19 +124,23 @@ describe JIRA::OauthClient do
       it 'performs a request' do
         expect(access_token).to receive(:send).with(:get, '/foo', headers).and_return(response)
 
-
         oauth_client.request(:get, '/foo', body, headers)
       end
 
-      context 'for a multipart request' do
+      context 'when a multipart request' do
         subject { oauth_client.make_multipart_request('/path', data, headers) }
 
         let(:data) { {} }
         let(:headers) { {} }
 
         it 'signs the access_token and performs the request' do
+          http_mock = double('HTTP')
+
+          consumer_mock = oauth_client.consumer
+
           expect(access_token).to receive(:sign!).with(an_instance_of(Net::HTTP::Post::Multipart))
-          expect(oauth_client.consumer).to receive_message_chain(:http, :request).with(an_instance_of(Net::HTTP::Post::Multipart))
+          expect(consumer_mock).to receive(:http).and_return(http_mock)
+          expect(http_mock).to receive(:request).with(an_instance_of(Net::HTTP::Post::Multipart))
 
           subject
         end
@@ -147,7 +151,7 @@ describe JIRA::OauthClient do
       let(:oauth__2legged_client) do
         options = { consumer_key: 'foo', consumer_secret: 'bar', auth_type: :oauth_2legged }
         options = JIRA::Client::DEFAULT_OPTIONS.merge(options)
-        JIRA::OauthClient.new(options)
+        described_class.new(options)
       end
 
       it 'responds to the http methods adding oauth_token parameter' do
@@ -169,11 +173,13 @@ describe JIRA::OauthClient do
         mock_access_token = double
         allow(oauth__2legged_client).to receive(:access_token).and_return(mock_access_token)
         %i[delete get head].each do |method|
-          expect(mock_access_token).to receive(method).with('/path?any_param=toto&oauth_token=', headers).and_return(response)
+          expect(mock_access_token).to receive(method).with('/path?any_param=toto&oauth_token=',
+                                                            headers).and_return(response)
           oauth__2legged_client.make_request(method, '/path?any_param=toto', '', headers)
         end
         %i[post put].each do |method|
-          expect(mock_access_token).to receive(method).with('/path?any_param=toto&oauth_token=', '', headers).and_return(response)
+          expect(mock_access_token).to receive(method).with('/path?any_param=toto&oauth_token=', '',
+                                                            headers).and_return(response)
           oauth__2legged_client.make_request(method, '/path?any_param=toto', '', headers)
         end
       end

data/spec/jira/request_client_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe JIRA::RequestClient do
-  let(:request_client) { JIRA::RequestClient.new }
+  let(:request_client) { described_class.new }
 
   describe '#request' do
     subject(:request) { request_client.request(:get, '/foo', '', {}) }
@@ -15,7 +15,7 @@ describe JIRA::RequestClient do
       end
 
       it 'raises an exception' do
-        expect{ subject }.to raise_exception(JIRA::HTTPError)
+        expect { subject }.to raise_exception(JIRA::HTTPError)
       end
     end
   end
@@ -34,8 +34,8 @@ describe JIRA::RequestClient do
       end
 
       it 'raises an exception' do
-        expect{ subject }.to raise_exception(JIRA::HTTPError)
+        expect { subject }.to raise_exception(JIRA::HTTPError)
       end
     end
   end
-end
+end