jira-ruby 2.2.0 → 3.0.0.beta1

data/spec/integration/watcher_spec.rb

@@ -5,7 +5,7 @@ describe JIRA::Resource::Watcher do
     let(:client) { client }
     let(:site_url) { site_url }
 
-    let(:target) { JIRA::Resource::Watcher.new(client, attrs: { 'id' => '99999' }, issue_id: '10002') }
+    let(:target) { described_class.new(client, attrs: { 'id' => '99999' }, issue_id: '10002') }
 
     let(:belongs_to) do
       JIRA::Resource::Issue.new(client, attrs: {
@@ -19,44 +19,43 @@ describe JIRA::Resource::Watcher do
     let(:expected_attributes) do
       {
         'self' => 'http://localhost:2990/jira/rest/api/2/issue/10002/watchers',
-        "isWatching": false,
-        "watchCount": 1,
-        "watchers": [
+        isWatching: false,
+        watchCount: 1,
+        watchers: [
           {
-            "self": 'http://www.example.com/jira/rest/api/2/user?username=admin',
-            "name": 'admin',
-            "displayName": 'admin',
-            "active": false
+            self: 'http://www.example.com/jira/rest/api/2/user?username=admin',
+            name: 'admin',
+            displayName: 'admin',
+            active: false
           }
         ]
       }
     end
 
     describe 'watchers' do
-      before(:each) do
-        stub_request(:get, site_url + '/jira/rest/api/2/issue/10002')
+      before do
+        stub_request(:get, "#{site_url}/jira/rest/api/2/issue/10002")
           .to_return(status: 200, body: get_mock_response('issue/10002.json'))
 
-        stub_request(:get, site_url + '/jira/rest/api/2/issue/10002/watchers')
+        stub_request(:get, "#{site_url}/jira/rest/api/2/issue/10002/watchers")
           .to_return(status: 200, body: get_mock_response('issue/10002/watchers.json'))
 
-        stub_request(:post, site_url + '/jira/rest/api/2/issue/10002/watchers')
+        stub_request(:post, "#{site_url}/jira/rest/api/2/issue/10002/watchers")
           .to_return(status: 204, body: nil)
       end
 
-      it 'should returns all the watchers' do
+      it 'returnses all the watchers' do
         issue = client.Issue.find('10002')
-        watchers = client.Watcher.all(options = { issue: issue })
+        watchers = client.Watcher.all(options = { issue: })
         expect(watchers.length).to eq(1)
       end
 
-      it 'should add a watcher' do
+      it 'adds a watcher' do
         issue = client.Issue.find('10002')
-        watcher = JIRA::Resource::Watcher.new(client, issue: issue)
-        user_id = "tester"
+        watcher = described_class.new(client, issue:)
+        user_id = 'tester'
         watcher.save!(user_id)
       end
     end
-
   end
 end

data/spec/integration/webhook.rb

@@ -8,14 +8,15 @@ describe JIRA::Resource::Webhook do
     let(:key) { '2' }
 
     let(:expected_attributes) do
-      { 'name' => 'from API', 'url' => 'http://localhost:3000/webhooks/1', 'excludeBody' => false, 'filters' => { 'issue-related-events-section' => '' }, 'events' => [], 'enabled' => true, 'self' => 'http://localhost:2990/jira/rest/webhooks/1.0/webhook/2', 'lastUpdatedUser' => 'admin', 'lastUpdatedDisplayName' => 'admin', 'lastUpdated' => 1_453_306_520_188 }
+      { 'name' => 'from API', 'url' => 'http://localhost:3000/webhooks/1', 'excludeBody' => false,
+'filters' => { 'issue-related-events-section' => '' }, 'events' => [], 'enabled' => true, 'self' => 'http://localhost:2990/jira/rest/webhooks/1.0/webhook/2', 'lastUpdatedUser' => 'admin', 'lastUpdatedDisplayName' => 'admin', 'lastUpdated' => 1_453_306_520_188 }
     end
 
     let(:expected_collection_length) { 1 }
 
-    it_should_behave_like 'a resource'
-    it_should_behave_like 'a resource with a collection GET endpoint'
-    it_should_behave_like 'a resource with a singular GET endpoint'
+    it_behaves_like 'a resource'
+    it_behaves_like 'a resource with a collection GET endpoint'
+    it_behaves_like 'a resource with a singular GET endpoint'
 
     it 'returns a collection of components' do
       stub_request(:get, site_url + described_class.singular_path(client, key))

data/spec/integration/worklog_spec.rb

@@ -7,7 +7,7 @@ describe JIRA::Resource::Worklog do
 
     let(:key) { '10000' }
 
-    let(:target) { JIRA::Resource::Worklog.new(client, attrs: { 'id' => '99999' }, issue_id: '54321') }
+    let(:target) { described_class.new(client, attrs: { 'id' => '99999' }, issue_id: '54321') }
 
     let(:expected_collection_length) { 3 }
 
@@ -22,7 +22,7 @@ describe JIRA::Resource::Worklog do
     let(:expected_attributes) do
       {
         'self' => 'http://localhost:2990/jira/rest/api/2/issue/10002/worklog/10000',
-        'id'   => key,
+        'id' => key,
         'comment' => 'Some epic work.'
       }
     end
@@ -41,11 +41,11 @@ describe JIRA::Resource::Worklog do
       { 'id' => '10001', 'timeSpent' => '4d' }
     end
 
-    it_should_behave_like 'a resource'
-    it_should_behave_like 'a resource with a collection GET endpoint'
-    it_should_behave_like 'a resource with a singular GET endpoint'
-    it_should_behave_like 'a resource with a DELETE endpoint'
-    it_should_behave_like 'a resource with a POST endpoint'
-    it_should_behave_like 'a resource with a PUT endpoint'
+    it_behaves_like 'a resource'
+    it_behaves_like 'a resource with a collection GET endpoint'
+    it_behaves_like 'a resource with a singular GET endpoint'
+    it_behaves_like 'a resource with a DELETE endpoint'
+    it_behaves_like 'a resource with a POST endpoint'
+    it_behaves_like 'a resource with a PUT endpoint'
   end
 end

data/spec/jira/base_factory_spec.rb

@@ -4,9 +4,10 @@ describe JIRA::BaseFactory do
   class JIRA::Resource::FooFactory < JIRA::BaseFactory; end
   class JIRA::Resource::Foo; end
 
-  let(:client)  { double }
   subject       { JIRA::Resource::FooFactory.new(client) }
 
+  let(:client)  { double }
+
   it 'initializes correctly' do
     expect(subject.class).to        eq(JIRA::Resource::FooFactory)
     expect(subject.client).to       eq(client)

data/spec/jira/base_spec.rb

@@ -32,11 +32,11 @@ describe JIRA::Base do
              attribute_key: 'irregularlyNamedThings'
   end
 
+  subject { JIRA::Resource::Deadbeef.new(client, attrs:) }
+
   let(:client)  { double('client') }
   let(:attrs)   { {} }
 
-  subject { JIRA::Resource::Deadbeef.new(client, attrs: attrs) }
-
   let(:decorated) { JIRADelegation.new(subject) }
 
   describe '#respond_to?' do
@@ -44,6 +44,7 @@ describe JIRA::Base do
       it 'responds to client' do
         expect(decorated.respond_to?(:client)).to eq(true)
       end
+
       it 'does not raise an error' do
         expect do
           decorated.respond_to?(:client)
@@ -125,7 +126,7 @@ describe JIRA::Base do
   end
 
   describe 'collection_path' do
-    before(:each) do
+    before do
       expect(client).to receive(:options).and_return(rest_base_path: '/deadbeef/bar')
     end
 
@@ -147,8 +148,9 @@ describe JIRA::Base do
   end
 
   describe 'dynamic instance methods' do
+    subject     { JIRA::Resource::Deadbeef.new(client, attrs:) }
+
     let(:attrs) { { 'foo' => 'bar', 'flum' => 'goo', 'object_id' => 'dummy' } }
-    subject     { JIRA::Resource::Deadbeef.new(client, attrs: attrs) }
 
     it 'responds to each of the top level attribute names' do
       expect(subject).to respond_to(:foo)
@@ -169,7 +171,7 @@ describe JIRA::Base do
     subject { JIRA::Resource::Deadbeef.new(client, attrs: { 'id' => '98765' }) }
 
     describe 'not cached' do
-      before(:each) do
+      before do
         response = instance_double('Response', body: '{"self":"http://deadbeef/","id":"98765"}')
         expect(client).to receive(:get).with('/jira/rest/api/2/deadbeef/98765').and_return(response)
         expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
@@ -222,17 +224,17 @@ describe JIRA::Base do
   end
 
   describe 'save' do
-    let(:response) { double }
-
     subject { JIRA::Resource::Deadbeef.new(client) }
 
-    before(:each) do
+    let(:response) { double }
+
+    before do
       expect(subject).to receive(:url).and_return('/foo/bar')
     end
 
     it 'POSTs a new record' do
       response = instance_double('Response', body: '{"id":"123"}')
-      allow(subject).to receive(:new_record?) { true }
+      allow(subject).to receive(:new_record?).and_return(true)
       expect(client).to receive(:post).with('/foo/bar', '{"foo":"bar"}').and_return(response)
       expect(subject.save('foo' => 'bar')).to be_truthy
       expect(subject.id).to eq('123')
@@ -241,7 +243,7 @@ describe JIRA::Base do
 
     it 'PUTs an existing record' do
       response = instance_double('Response', body: nil)
-      allow(subject).to receive(:new_record?) { false }
+      allow(subject).to receive(:new_record?).and_return(false)
       expect(client).to receive(:put).with('/foo/bar', '{"foo":"bar"}').and_return(response)
       expect(subject.save('foo' => 'bar')).to be_truthy
       expect(subject.expanded).to be_falsey
@@ -255,14 +257,17 @@ describe JIRA::Base do
       expect(subject.foo).to eq('bar' => 'baz', 'fum' => 'dum')
     end
 
-    it 'returns false when an invalid field is set' do # The JIRA REST API apparently ignores fields that you aren't allowed to set manually
+    it 'returns false when an invalid field is set' do
+      # The JIRA REST API apparently ignores fields that you aren't allowed to set manually
       response = instance_double('Response', body: '{"errorMessages":["blah"]}', status: 400)
-      allow(subject).to receive(:new_record?) { false }
-      expect(client).to receive(:put).with('/foo/bar', '{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
+      allow(subject).to receive(:new_record?).and_return(false)
+      expect(client).to receive(:put).with('/foo/bar',
+                                           '{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
       expect(subject.save('invalid_field' => 'foobar')).to be_falsey
     end
 
-    it 'returns false with exception details when non json response body (unauthorized)' do # Unauthorized requests return a non-json body. This makes sure we can handle non-json bodies on HTTPError
+    it 'returns false with exception details when non json response body (unauthorized)' do
+      # Unauthorized requests return a non-json body. This makes sure we can handle non-json bodies on HTTPError
       response = double('Response', body: 'totally invalid json', code: 401, message: 'Unauthorized')
       expect(client).to receive(:post).with('/foo/bar', '{"foo":"bar"}').and_raise(JIRA::HTTPError.new(response))
       expect(subject.save('foo' => 'bar')).to be_falsey
@@ -272,17 +277,17 @@ describe JIRA::Base do
   end
 
   describe 'save!' do
-    let(:response) { double }
-
     subject { JIRA::Resource::Deadbeef.new(client) }
 
-    before(:each) do
+    let(:response) { double }
+
+    before do
       expect(subject).to receive(:url).and_return('/foo/bar')
     end
 
     it 'POSTs a new record' do
       response = instance_double('Response', body: '{"id":"123"}')
-      allow(subject).to receive(:new_record?) { true }
+      allow(subject).to receive(:new_record?).and_return(true)
       expect(client).to receive(:post).with('/foo/bar', '{"foo":"bar"}').and_return(response)
       expect(subject.save!('foo' => 'bar')).to be_truthy
       expect(subject.id).to eq('123')
@@ -291,7 +296,7 @@ describe JIRA::Base do
 
     it 'PUTs an existing record' do
       response = instance_double('Response', body: nil)
-      allow(subject).to receive(:new_record?) { false }
+      allow(subject).to receive(:new_record?).and_return(false)
       expect(client).to receive(:put).with('/foo/bar', '{"foo":"bar"}').and_return(response)
       expect(subject.save!('foo' => 'bar')).to be_truthy
       expect(subject.expanded).to be_falsey
@@ -299,9 +304,10 @@ describe JIRA::Base do
 
     it 'throws an exception when an invalid field is set' do
       response = instance_double('Response', body: '{"errorMessages":["blah"]}', status: 400)
-      allow(subject).to receive(:new_record?) { false }
-      expect(client).to receive(:put).with('/foo/bar', '{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
-      expect(-> { subject.save!('invalid_field' => 'foobar') }).to raise_error(JIRA::HTTPError)
+      allow(subject).to receive(:new_record?).and_return(false)
+      expect(client).to receive(:put).with('/foo/bar',
+                                           '{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
+      expect { subject.save!('invalid_field' => 'foobar') }.to raise_error(JIRA::HTTPError)
     end
   end
 
@@ -320,9 +326,9 @@ describe JIRA::Base do
   end
 
   describe 'delete' do
-    before(:each) do
+    before do
       expect(client).to receive(:delete).with('/foo/bar')
-      allow(subject).to receive(:url) { '/foo/bar' }
+      allow(subject).to receive(:url).and_return('/foo/bar')
     end
 
     it 'flags itself as deleted' do
@@ -360,8 +366,8 @@ describe JIRA::Base do
   end
 
   describe 'url' do
-    before(:each) do
-      allow(client).to receive(:options) { { rest_base_path: '/foo/bar' } }
+    before do
+      allow(client).to receive(:options).and_return({ rest_base_path: '/foo/bar' })
     end
 
     it 'returns self as the URL if set' do
@@ -370,13 +376,13 @@ describe JIRA::Base do
     end
 
     it 'returns path as the URL if set and site options is specified' do
-      allow(client).to receive(:options) { { site: 'http://foo' } }
+      allow(client).to receive(:options).and_return({ site: 'http://foo' })
       attrs['self'] = 'http://foo/bar'
       expect(subject.url).to eq('/bar')
     end
 
     it 'returns path as the URL if set and site options is specified and ends with a slash' do
-      allow(client).to receive(:options) { { site: 'http://foo/' } }
+      allow(client).to receive(:options).and_return({ site: 'http://foo/' })
       attrs['self'] = 'http://foo/bar'
       expect(subject.url).to eq('/bar')
     end
@@ -428,7 +434,7 @@ describe JIRA::Base do
 
     h       = { 'key' => subject }
     h_attrs = { 'key' => subject.attrs }
-    expect(h.to_json).to eq(h_attrs.to_json)
+    expect(h['key'].to_json).to eq(h_attrs['key'].to_json)
   end
 
   describe 'extract attrs from response' do
@@ -487,7 +493,9 @@ describe JIRA::Base do
     end
 
     it 'allows the has_many attributes to be nested inside another attribute' do
-      subject = JIRA::Resource::HasManyExample.new(client, attrs: { 'nested' => { 'brunchmuffins' => [{ 'id' => '123' }, { 'id' => '456' }] } })
+      subject = JIRA::Resource::HasManyExample.new(client,
+                                                   attrs: { 'nested' => { 'brunchmuffins' => [{ 'id' => '123' },
+                                                                                              { 'id' => '456' }] } })
       expect(subject.brunchmuffins.length).to eq(2)
       subject.brunchmuffins.each do |brunchmuffin|
         expect(brunchmuffin.class).to eq(JIRA::Resource::Deadbeef)
@@ -495,9 +503,12 @@ describe JIRA::Base do
     end
 
     it 'allows it to be deeply nested' do
-      subject = JIRA::Resource::HasManyExample.new(client, attrs: { 'nested' => {
-                                                     'breakfastscone' => { 'breakfastscones' => [{ 'id' => '123' }, { 'id' => '456' }] }
-                                                   } })
+      subject = JIRA::Resource::HasManyExample.new(
+        client,
+        attrs: {
+          'nested' => { 'breakfastscone' => { 'breakfastscones' => [{ 'id' => '123' }, { 'id' => '456' }] } }
+        }
+      )
       expect(subject.breakfastscones.length).to eq(2)
       subject.breakfastscones.each do |breakfastscone|
         expect(breakfastscone.class).to eq(JIRA::Resource::Deadbeef)
@@ -512,7 +523,9 @@ describe JIRA::Base do
     end
 
     it 'allows the attribute key to be specified' do
-      subject = JIRA::Resource::HasManyExample.new(client, attrs: { 'irregularlyNamedThings' => [{ 'id' => '123' }, { 'id' => '456' }] })
+      subject = JIRA::Resource::HasManyExample.new(client,
+                                                   attrs: { 'irregularlyNamedThings' => [{ 'id' => '123' },
+                                                                                         { 'id' => '456' }] })
       expect(subject.irregularly_named_things.length).to eq(2)
       subject.irregularly_named_things.each do |thing|
         expect(thing.class).to eq(JIRA::Resource::Deadbeef)
@@ -545,7 +558,8 @@ describe JIRA::Base do
     end
 
     it 'allows the has_one attributes to be nested inside another attribute' do
-      subject = JIRA::Resource::HasOneExample.new(client, attrs: { 'nested' => { 'brunchmuffin' => { 'id' => '123' } } })
+      subject = JIRA::Resource::HasOneExample.new(client,
+                                                  attrs: { 'nested' => { 'brunchmuffin' => { 'id' => '123' } } })
       expect(subject.brunchmuffin.class).to eq(JIRA::Resource::Deadbeef)
       expect(subject.brunchmuffin.id).to eq('123')
     end
@@ -570,27 +584,27 @@ describe JIRA::Base do
       belongs_to :deadbeef
     end
 
-    let(:deadbeef) { JIRA::Resource::Deadbeef.new(client, attrs: { 'id' => '999' }) }
+    subject { JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' }, deadbeef:) }
 
-    subject { JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' }, deadbeef: deadbeef) }
+    let(:deadbeef) { JIRA::Resource::Deadbeef.new(client, attrs: { 'id' => '999' }) }
 
     it 'sets up an accessor for the belongs to relationship' do
       expect(subject.deadbeef).to eq(deadbeef)
     end
 
     it 'raises an exception when initialized without a belongs_to instance' do
-      expect(lambda {
+      expect do
         JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' })
-      }).to raise_exception(ArgumentError, 'Required option :deadbeef missing')
+      end.to raise_exception(ArgumentError, 'Required option :deadbeef missing')
     end
 
     it 'returns the right url' do
-      allow(client).to receive(:options) { { rest_base_path: '/foo' } }
+      allow(client).to receive(:options).and_return({ rest_base_path: '/foo' })
       expect(subject.url).to eq('/foo/deadbeef/999/belongstoexample/123')
     end
 
     it 'can be initialized with an instance or a key value' do
-      allow(client).to receive(:options) { { rest_base_path: '/foo' } }
+      allow(client).to receive(:options).and_return({ rest_base_path: '/foo' })
       subject = JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' }, deadbeef_id: '987')
       expect(subject.url).to eq('/foo/deadbeef/987/belongstoexample/123')
     end

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,20 @@ 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(: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')
+        expect do
+          subject
+        end.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')
+        expect do
+          subject
+        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 +84,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
@@ -106,11 +115,13 @@ RSpec.shared_examples 'OAuth Common Tests' do
   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
@@ -130,20 +141,22 @@ describe JIRA::Client do
 
   context 'behaviour that applies to all client classes irrespective of authentication method' 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 +170,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
     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.authenticated?).to be_falsey
+      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,
+        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 +223,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 +235,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 +243,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,8 +261,8 @@ 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
@@ -269,20 +282,21 @@ describe JIRA::Client do
   end
 
   context 'oauth authentication' do
-    subject { JIRA::Client.new(consumer_key: 'foo', consumer_secret: 'bar') }
+    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