jira-ruby 1.7.1 → 2.1.2

data/lib/jira/resource/board_configuration.rb

@@ -0,0 +1,9 @@
+module JIRA
+  module Resource
+    class BoardConfigurationFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class BoardConfiguration < JIRA::Base
+    end
+  end
+end

data/lib/jira/resource/sprint.rb

@@ -5,7 +5,7 @@ module JIRA
 
     class Sprint < JIRA::Base
       def self.find(client, key)
-        response = client.get("#{client.options[:site]}/rest/agile/1.0/sprint/#{key}")
+        response = client.get(agile_path(client, key))
         json = parse_json(response.body)
         client.Sprint.build(json)
       end
@@ -19,7 +19,7 @@ module JIRA
 
       def add_issue(issue)
         request_body = { issues: [issue.id] }.to_json
-        response = client.post(client.options[:site] + "/rest/agile/1.0/sprint/#{id}/issue", request_body)
+        response = client.post("#{agile_path}/issue", request_body)
         true
       end
 
@@ -47,8 +47,8 @@ module JIRA
       end
 
       def get_sprint_details
-        search_url = client.options[:site] + '/rest/greenhopper/1.0/rapid/charts/sprintreport?rapidViewId=' +
-                     rapidview_id.to_s + '&sprintId=' + id.to_s
+        search_url =
+          "#{client.options[:site]}#{client.options[:client_path]}/rest/greenhopper/1.0/rapid/charts/sprintreport?rapidViewId=#{rapidview_id}&sprintId=#{id}"
         begin
           response = client.get(search_url)
         rescue StandardError
@@ -76,12 +76,12 @@ module JIRA
 
       def save(attrs = {}, _path = nil)
         attrs = @attrs if attrs.empty?
-        super(attrs, agile_url)
+        super(attrs, agile_path)
       end
 
       def save!(attrs = {}, _path = nil)
         attrs = @attrs if attrs.empty?
-        super(attrs, agile_url)
+        super(attrs, agile_path)
       end
 
       # WORK IN PROGRESS
@@ -93,8 +93,12 @@ module JIRA
 
       private
 
-      def agile_url
-        "#{client.options[:site]}/rest/agile/1.0/sprint/#{id}"
+      def agile_path
+        self.class.agile_path(client, id)
+      end
+
+      def self.agile_path(client, key)
+        "#{client.options[:context_path]}/rest/agile/1.0/sprint/#{key}"
       end
     end
   end

data/lib/jira/resource/watcher.rb

@@ -23,6 +23,13 @@ module JIRA
           issue.watchers.build(watcher)
         end
       end
+
+      def save!(user_id, path = nil)
+        path ||= new_record? ? url : patched_url
+        response = client.post(path, user_id.to_json)
+        true
+      end
+
     end
   end
 end

data/lib/jira/version.rb

@@ -1,3 +1,3 @@
 module JIRA
-  VERSION = '1.7.1'.freeze
+  VERSION = '2.1.2'.freeze
 end

data/spec/integration/watcher_spec.rb

@@ -33,21 +33,30 @@ describe JIRA::Resource::Watcher do
     end
 
     describe 'watchers' do
-      it 'should returns all the watchers' do
-        stub_request(:get,
-                     site_url + '/jira/rest/api/2/issue/10002')
+      before(:each) 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')
+          .to_return(status: 204, body: nil)
+      end
+
+      it 'should returns all the watchers' do
         issue = client.Issue.find('10002')
         watchers = client.Watcher.all(options = { issue: issue })
         expect(watchers.length).to eq(1)
       end
+
+      it 'should add a watcher' do
+        issue = client.Issue.find('10002')
+        watcher = JIRA::Resource::Watcher.new(client, issue: issue)
+        user_id = "tester"
+        watcher.save!(user_id)
+      end
     end
 
-    it_should_behave_like 'a resource'
   end
 end

data/spec/jira/base_spec.rb

@@ -369,6 +369,18 @@ describe JIRA::Base do
       expect(subject.url).to eq('http://foo/bar')
     end
 
+    it 'returns path as the URL if set and site options is specified' do
+      allow(client).to receive(:options) { { 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/' } }
+      attrs['self'] = 'http://foo/bar'
+      expect(subject.url).to eq('/bar')
+    end
+
     it 'generates the URL from id if self not set' do
       attrs['self'] = nil
       attrs['id'] = '98765'

data/spec/jira/client_spec.rb

@@ -266,4 +266,13 @@ describe JIRA::Client do
 
     include_examples 'OAuth Common Tests'
   end
+
+  context 'with unknown options' do
+    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"]')
+    end
+  end
 end

data/spec/jira/http_client_spec.rb

@@ -2,12 +2,22 @@ require 'spec_helper'
 
 describe JIRA::HttpClient do
   let(:basic_client) do
-    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS)
+    options = JIRA::Client::DEFAULT_OPTIONS
+              .merge(JIRA::HttpClient::DEFAULT_OPTIONS)
+              .merge(basic_auth_credentials)
     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)
+              .merge(basic_auth_credentials)
+    JIRA::HttpClient.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)
   end
 
@@ -20,10 +30,13 @@ describe JIRA::HttpClient do
   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']
-    )
+    options = JIRA::Client::DEFAULT_OPTIONS
+              .merge(JIRA::HttpClient::DEFAULT_OPTIONS)
+              .merge(
+                use_cookies: true,
+                additional_cookies: ['sessionToken=abc123', 'internal=true']
+              )
+              .merge(basic_auth_credentials)
     JIRA::HttpClient.new(options)
   end
 
@@ -36,6 +49,26 @@ describe JIRA::HttpClient do
     JIRA::HttpClient.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)
+  end
+
+  let(:basic_auth_credentials) do
+    { username: 'donaldduck', password: 'supersecret' }
+  end
+
+  let(:proxy_client) do
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(
+      proxy_address: 'proxyAddress',
+      proxy_port: 42,
+      proxy_username: 'proxyUsername',
+      proxy_password: 'proxyPassword'
+    )
+    JIRA::HttpClient.new(options)
+  end
+
   let(:response) do
     response = double('response')
     allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
@@ -159,6 +192,19 @@ describe JIRA::HttpClient do
     basic_client.make_request(:get, 'http://mydomain.com/foo', body, headers)
   end
 
+  it 'does not try to use basic auth if the credentials are not set' do
+    body = nil
+    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)
+    expect(http_request).not_to receive(:basic_auth)
+    allow(basic_client_with_no_auth_credentials).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+    basic_client_with_no_auth_credentials.make_request(:get, '/foo', body, headers)
+  end
+
   it 'returns a URI' do
     uri = URI.parse(basic_client.options[:site])
     expect(basic_client.uri).to eq(uri)
@@ -178,6 +224,51 @@ describe JIRA::HttpClient do
     expect(basic_client.http_conn(uri)).to eq(http_conn)
   end
 
+  it 'sets the SSL version when one is provided' 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(:ssl_version=).with(custom_ssl_version_client.options[:ssl_version]).and_return(http_conn)
+    expect(http_conn).to receive(:read_timeout=).with(basic_client.options[:read_timeout]).and_return(http_conn)
+    expect(custom_ssl_version_client.http_conn(uri)).to eq(http_conn)
+  end
+
+  it 'sets up a non-proxied http connection by default' do
+    uri = double
+    host = double
+    port = double
+
+    expect(uri).to receive(:host).and_return(host)
+    expect(uri).to receive(:port).and_return(port)
+
+    proxy_configuration = basic_client.http_conn(uri).class
+    expect(proxy_configuration.proxy_address).to be_nil
+    expect(proxy_configuration.proxy_port).to be_nil
+    expect(proxy_configuration.proxy_user).to be_nil
+    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
+
+    expect(uri).to receive(:host).and_return(host)
+    expect(uri).to receive(:port).and_return(port)
+
+    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])
+  end
+
   it 'can use client certificates' do
     http_conn = double
     uri = double
@@ -201,4 +292,37 @@ describe JIRA::HttpClient do
     expect(basic_client).to receive(:http_conn).and_return(http_conn)
     expect(basic_client.basic_auth_http_conn).to eq(http_conn)
   end
+
+  describe '#make_multipart_request' do
+    subject do
+      basic_client.make_multipart_request(path, data, headers)
+    end
+
+    let(:path) { '/foo' }
+    let(:data) { {} }
+    let(:headers) { { 'X-Atlassian-Token' => 'no-check' } }
+    let(:basic_auth_http_conn) { double }
+    let(:request) { double('Http Request', path: path) }
+    let(:response) { double('response') }
+
+    before do
+      allow(request).to receive(:basic_auth)
+      allow(Net::HTTP::Post::Multipart).to receive(:new).with(path, data, headers).and_return(request)
+      allow(basic_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+      allow(basic_auth_http_conn).to receive(:request).with(request).and_return(response)
+    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)
+
+      subject
+    end
+
+    it 'makes a correct HTTP request' do
+      expect(basic_auth_http_conn).to receive(:request).with(request).and_return(response)
+      expect(response).to receive(:is_a?).with(Net::HTTPOK)
+
+      subject
+    end
+  end
 end

data/spec/jira/oauth_client_spec.rb

@@ -82,28 +82,45 @@ describe JIRA::OauthClient do
     end
 
     describe 'http' do
+      let(:headers) { double }
+      let(:access_token) { double }
+      let(:body) { nil }
+
+      before do
+        allow(oauth_client).to receive(:access_token).and_return(access_token)
+      end
+
       it 'responds to the http methods' do
-        headers = double
-        mock_access_token = double
-        allow(oauth_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', headers).and_return(response)
+          expect(access_token).to receive(method).with('/path', headers).and_return(response)
           oauth_client.make_request(method, '/path', '', headers)
         end
         %i[post put].each do |method|
-          expect(mock_access_token).to receive(method).with('/path', '', headers).and_return(response)
+          expect(access_token).to receive(method).with('/path', '', headers).and_return(response)
           oauth_client.make_request(method, '/path', '', headers)
         end
       end
 
       it 'performs a request' do
-        body = nil
-        headers = double
-        access_token = double
         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
+
+      context 'for 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
+          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))
+
+          subject
+        end
+      end
     end
 
     describe 'auth type is oauth_2legged' do
@@ -142,4 +159,4 @@ describe JIRA::OauthClient do
       end
     end
   end
-end
+end

data/spec/jira/request_client_spec.rb

@@ -1,14 +1,41 @@
 require 'spec_helper'
 
 describe JIRA::RequestClient do
-  it 'raises an exception for non success responses' do
-    response = double
-    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(false)
-    rc = JIRA::RequestClient.new
-    expect(rc).to receive(:make_request).with(:get, '/foo', '', {}).and_return(response)
-
-    expect do
-      rc.request(:get, '/foo', '', {})
-    end.to raise_exception(JIRA::HTTPError)
+  let(:request_client) { JIRA::RequestClient.new }
+
+  describe '#request' do
+    subject(:request) { request_client.request(:get, '/foo', '', {}) }
+
+    context 'when doing a request fails' do
+      let(:response) { double }
+
+      before do
+        allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(false)
+        allow(request_client).to receive(:make_request).with(:get, '/foo', '', {}).and_return(response)
+      end
+
+      it 'raises an exception' do
+        expect{ subject }.to raise_exception(JIRA::HTTPError)
+      end
+    end
+  end
+
+  describe '#request_multipart' do
+    subject(:request) { request_client.request_multipart('/foo', data, {}) }
+
+    let(:data) { double }
+
+    context 'when doing a request fails' do
+      let(:response) { double }
+
+      before do
+        allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(false)
+        allow(request_client).to receive(:make_multipart_request).with('/foo', data, {}).and_return(response)
+      end
+
+      it 'raises an exception' do
+        expect{ subject }.to raise_exception(JIRA::HTTPError)
+      end
+    end
   end
-end
+end