jira-ruby 1.5.0 → 1.6.0

data/spec/jira/client_spec.rb

@@ -16,7 +16,7 @@ RSpec.shared_examples 'Client Common Tests' do
   end
 
   it 'merges headers' do
-    expect(subject.send(:merge_default_headers, {})).to eq({'Accept' => 'application/json'})
+    expect(subject.send(:merge_default_headers, {})).to eq('Accept' => 'application/json')
   end
 
   describe 'http methods' do
@@ -30,17 +30,17 @@ RSpec.shared_examples 'Client Common Tests' do
       # response for merging headers for http methods with body
       expect(subject).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
 
-      [:delete, :get, :head].each { |method| subject.send(method, '/path', {}) }
-      [:post, :put].each {|method| subject.send(method, '/path', '', 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) }
     end
 
     it 'calls the generic request method' do
-      [:delete, :get, :head].each do |method|
+      %i[delete get head].each do |method|
         expect(subject).to receive(:request).with(method, '/path', nil, headers).and_return(successful_response)
         subject.send(method, '/path', {})
       end
 
-      [:post, :put].each do |method|
+      %i[post put].each do |method|
         expect(subject).to receive(:request).with(method, '/path', '', merged_headers)
         subject.send(method, '/path', '', {})
       end
@@ -63,11 +63,11 @@ end
 
 RSpec.shared_examples 'HttpClient tests' do
   it 'makes a valid request' do
-    [:delete, :get, :head].each do |method|
+    %i[delete get head].each do |method|
       expect(subject.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(successful_response)
       subject.send(method, '/path', headers)
     end
-    [:post, :put].each do |method|
+    %i[post put].each do |method|
       expect(subject.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(successful_response)
       subject.send(method, '/path', '', headers)
     end
@@ -92,11 +92,11 @@ RSpec.shared_examples 'OAuth Common Tests' do
 
   describe 'that call a oauth client' do
     specify 'which makes a request' do
-      [:delete, :get, :head].each do |method|
+      %i[delete get head].each do |method|
         expect(subject.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(successful_response)
         subject.send(method, '/path', {})
       end
-      [:post, :put].each do |method|
+      %i[post put].each do |method|
         expect(subject.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(successful_response)
         subject.send(method, '/path', '', {})
       end
@@ -108,16 +108,16 @@ describe JIRA::Client do
   let(:request) { subject.request_client.class }
   let(:successful_response) do
     response = double('response')
-    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    allow(response).to receive(:is_a?).with(Net::HTTPSuccess).and_return(true)
     response
   end
-  let(:content_type_header) { {'Content-Type' => 'application/json'} }
-  let(:headers) { {'Accept' => 'application/json'} }
+  let(:content_type_header) { { 'Content-Type' => 'application/json' } }
+  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
     it 'allows the overriding of some options' do
-      client = JIRA::Client.new({:consumer_key => 'foo', :consumer_secret => 'bar', :site => 'http://foo.com/'})
+      client = JIRA::Client.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
@@ -128,10 +128,10 @@ describe JIRA::Client do
 
     before(:each) do
       stub_request(:get, 'https://foo:bar@localhost:2990/jira/rest/api/2/project')
-        .to_return(status: 200, body: '[]', headers: {} )
+        .to_return(status: 200, body: '[]', headers: {})
 
-      stub_request(:get, 'https://foo:badpassword@localhost:2990/jira/rest/api/2/project').
-        to_return(status: 401, headers: {} )
+      stub_request(:get, 'https://foo:badpassword@localhost:2990/jira/rest/api/2/project')
+        .to_return(status: 401, headers: {})
     end
 
     include_examples 'Client Common Tests'
@@ -147,7 +147,7 @@ describe JIRA::Client do
     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
+      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
@@ -155,7 +155,6 @@ describe JIRA::Client do
       expect(subject.Project.all).to be_empty
       expect(subject.authenticated?).to be_truthy
     end
-
   end
 
   context 'with cookie authentication' do
@@ -164,27 +163,27 @@ describe JIRA::Client do
     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
       # 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: {} )
+      stub_request(:post, 'https://localhost:2990/jira/rest/auth/1/session')
+        .to_return(status: 401, headers: {})
 
       # Now special case of API with correct authentication.  This gets checked first by RSpec.
       stub_request(:post, 'https://localhost:2990/jira/rest/auth/1/session')
         .with(body: '{"username":"foo","password":"bar"}')
         .to_return(status: 200, body: session_body.to_json,
-                   headers: { 'Set-Cookie': "JSESSIONID=#{session_cookie}; Path=/; HttpOnly"})
+                   headers: { 'Set-Cookie': "JSESSIONID=#{session_cookie}; Path=/; HttpOnly" })
 
       stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
-        .with(headers: { cookie: "JSESSIONID=#{session_cookie}" } )
-        .to_return(status: 200, body: '[]', headers: {} )
+        .with(headers: { cookie: "JSESSIONID=#{session_cookie}" })
+        .to_return(status: 200, body: '[]', headers: {})
     end
 
     include_examples 'Client Common Tests'
@@ -220,4 +219,3 @@ describe JIRA::Client do
     include_examples 'OAuth Common Tests'
   end
 end
-

data/spec/jira/has_many_proxy_spec.rb

@@ -1,46 +1,45 @@
 require 'spec_helper'
 
 describe JIRA::HasManyProxy do
-
-  class Foo ; end
+  class Foo; end
 
   subject { JIRA::HasManyProxy.new(parent, Foo, collection) }
 
-  let(:parent)      { double("parent") }
-  let(:collection)  { double("collection") }
+  let(:parent)      { double('parent') }
+  let(:collection)  { double('collection') }
 
-  it "has a target class" do
+  it 'has a target class' do
     expect(subject.target_class).to eq(Foo)
   end
 
-  it "has a parent" do
+  it 'has a parent' do
     expect(subject.parent).to eq(parent)
   end
 
-  it "has a collection" do
+  it 'has a collection' do
     expect(subject.collection).to eq(collection)
   end
 
-  it "can build a new instance" do
+  it 'can build a new instance' do
     client = double('client')
     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: 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
+  it 'can get all the instances' do
     foo = double('foo')
     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: parent).and_return(foo)
     expect(subject.all).to eq(foo)
   end
 
-  it "delegates missing methods to the collection" do
+  it 'delegates missing methods to the collection' do
     expect(collection).to receive(:missing_method)
     subject.missing_method
   end

data/spec/jira/http_client_spec.rb

@@ -1,63 +1,62 @@
 require 'spec_helper'
 
 describe JIRA::HttpClient do
-
   let(:basic_client) do
     options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS)
     JIRA::HttpClient.new(options)
   end
 
   let(:basic_cookie_client) do
-    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(:use_cookies => true)
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(use_cookies: true)
     JIRA::HttpClient.new(options)
   end
 
   let(:basic_cookie_client_with_context_path) do
     options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
-      :use_cookies => true,
-      :context_path => '/context'
+      use_cookies: true,
+      context_path: '/context'
     )
     JIRA::HttpClient.new(options)
   end
 
   let(:basic_cookie_client_with_additional_cookies) do
     options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
-      :use_cookies => true,
-      :additional_cookies => ['sessionToken=abc123', 'internal=true']
+      use_cookies: true,
+      additional_cookies: ['sessionToken=abc123', 'internal=true']
     )
     JIRA::HttpClient.new(options)
   end
 
   let(:basic_client_cert_client) do
     options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
-      :use_client_cert => true,
-      :cert => 'public certificate contents',
-      :key => 'private key contents'
+      use_client_cert: true,
+      cert: 'public certificate contents',
+      key: 'private key contents'
     )
     JIRA::HttpClient.new(options)
   end
 
   let(:response) do
-    response = double("response")
+    response = double('response')
     allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
     response
   end
 
   let(:cookie_response) do
-    response = double("response")
+    response = double('response')
     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
+  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
 
-  it "makes a correct HTTP request for make_cookie_auth_request" do
-    request = double()
-    basic_auth_http_conn = double()
+  it 'makes a correct HTTP request for make_cookie_auth_request' do
+    request = double
+    basic_auth_http_conn = double
 
-    headers = {"Content-Type" => "application/json"}
+    headers = { 'Content-Type' => 'application/json' }
     expected_path = '/context/rest/auth/1/session'
     expected_body = '{"username":"","password":""}'
 
@@ -73,72 +72,72 @@ describe JIRA::HttpClient do
     basic_cookie_client_with_context_path.make_cookie_auth_request
   end
 
-  it "responds to the http methods" do
+  it 'responds to the http methods' do
     body = ''
-    headers = double()
-    basic_auth_http_conn = double()
-    request = double()
+    headers = double
+    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(basic_auth_http_conn).to receive(:request).exactly(5).times.with(request).and_return(response)
-    [:delete, :get, :head].each do |method|
+    %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)
       expect(basic_client.make_request(method, '/path', nil, headers)).to eq(response)
     end
-    [:post, :put].each do |method|
+    %i[post put].each do |method|
       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
 
-  it "gets and sets cookies" do
+  it 'gets and sets cookies' do
     body = ''
-    headers = double()
-    basic_auth_http_conn = double()
-    request = double()
+    headers = double
+    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(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|
+    %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)
       expect(basic_cookie_client.make_request(method, '/path', nil, headers)).to eq(cookie_response)
     end
-    [:post, :put].each do |method|
+    %i[post put].each do |method|
       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
 
-  it "sets additional cookies when they are provided" do
+  it 'sets additional cookies when they are provided' do
     client = basic_cookie_client_with_additional_cookies
     body = ''
-    headers = double()
-    basic_auth_http_conn = double()
-    request = double()
+    headers = double
+    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(:add_field).with("Cookie", "sessionToken=abc123; internal=true").exactly(5).times
+    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)
-    [:delete, :get, :head].each do |method|
+    %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)
       expect(client.make_request(method, '/path', nil, headers)).to eq(cookie_response)
     end
-    [:post, :put].each do |method|
+    %i[post put].each do |method|
       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(client.make_request(method, '/path', body, headers)).to eq(cookie_response)
     end
   end
 
-  it "performs a basic http client request" do
+  it 'performs a basic http client request' do
     body = nil
-    headers = double()
-    basic_auth_http_conn = double()
-    http_request = double()
+    headers = double
+    basic_auth_http_conn = double
+    http_request = double
     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)
@@ -147,11 +146,11 @@ describe JIRA::HttpClient do
     basic_client.make_request(:get, '/foo', body, headers)
   end
 
-  it "performs a basic http client request with a full domain" do
+  it 'performs a basic http client request with a full domain' do
     body = nil
-    headers = double()
-    basic_auth_http_conn = double()
-    http_request = double()
+    headers = double
+    basic_auth_http_conn = double
+    http_request = double
     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)
@@ -160,16 +159,16 @@ describe JIRA::HttpClient do
     basic_client.make_request(:get, 'http://mydomain.com/foo', body, headers)
   end
 
-  it "returns a URI" do
+  it 'returns a URI' do
     uri = URI.parse(basic_client.options[:site])
     expect(basic_client.uri).to eq(uri)
   end
 
-  it "sets up a http connection with options" do
-    http_conn = double()
-    uri = double()
-    host = double()
-    port = double()
+  it 'sets up a http connection with options' 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)
@@ -195,9 +194,9 @@ describe JIRA::HttpClient do
     expect(basic_client_cert_client.http_conn(uri)).to eq(http_conn)
   end
 
-  it "returns a http connection" do
-    http_conn = double()
-    uri = double()
+  it 'returns a http connection' do
+    http_conn = double
+    uri = double
     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)

data/spec/jira/http_error_spec.rb

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