jira-ruby 1.6.0 → 2.1.0

data/lib/jira/request_client.rb

@@ -1,7 +1,6 @@
 require 'oauth'
 require 'json'
 require 'net/https'
-# require 'pry'
 
 module JIRA
   class RequestClient
@@ -11,9 +10,22 @@ module JIRA
 
     def request(*args)
       response = make_request(*args)
-      # binding.pry unless response.kind_of?(Net::HTTPSuccess)
       raise HTTPError, response unless response.is_a?(Net::HTTPSuccess)
       response
     end
+
+    def request_multipart(*args)
+      response = make_multipart_request(*args)
+      raise HTTPError, response unless response.is_a?(Net::HTTPSuccess)
+      response
+    end
+
+    def make_request(*args)
+      raise NotImplementedError
+    end
+
+    def make_multipart_request(*args)
+      raise NotImplementedError
+    end
   end
-end
+end

data/lib/jira/resource/attachment.rb

@@ -19,27 +19,32 @@ module JIRA
         parse_json(response.body)
       end
 
-      def save!(attrs)
-        headers = { 'X-Atlassian-Token' => 'nocheck' }
-        data = { 'file' => UploadIO.new(attrs['file'], 'application/binary', attrs['file']) }
-
-        request = Net::HTTP::Post::Multipart.new url, data, headers
-        request.basic_auth(client.request_client.options[:username],
-                           client.request_client.options[:password])
+      def save!(attrs, path = url)
+        file = attrs['file'] || attrs[:file] # Keep supporting 'file' parameter as a string for backward compatibility
+        mime_type = attrs[:mimeType] || 'application/binary'
 
-        response = client.request_client.basic_auth_http_conn.request(request)
+        headers = { 'X-Atlassian-Token' => 'nocheck' }
+        data = { 'file' => UploadIO.new(file, mime_type, file) }
 
-        set_attrs(attrs, false)
-        unless response.body.nil? || response.body.length < 2
-          json = self.class.parse_json(response.body)
-          attachment = json[0]
+        response = client.post_multipart(path, data , headers)
 
-          set_attrs(attachment)
-        end
+        set_attributes(attrs, response)
 
         @expanded = false
         true
       end
+
+      private
+
+      def set_attributes(attributes, response)
+        set_attrs(attributes, false)
+        return if response.body.nil? || response.body.length < 2
+
+        json = self.class.parse_json(response.body)
+        attachment = json[0]
+
+        set_attrs(attachment)
+      end
     end
   end
 end

data/lib/jira/resource/board.rb

@@ -31,7 +31,7 @@ module JIRA
       end
 
       def issues(params = {})
-        path = path_base(client) + "/board/#{id}/issue?"
+        path = path_base(client) + "/board/#{id}/issue"
         response = client.get(url_with_query_params(path, params))
         json = self.class.parse_json(response.body)
         results = json['issues']
@@ -46,6 +46,13 @@ module JIRA
         results.map { |issue| client.Issue.build(issue) }
       end
 
+      def configuration(params = {})
+        path = path_base(client) + "/board/#{id}/configuration"
+        response = client.get(url_with_query_params(path, params))
+        json = self.class.parse_json(response.body)
+        client.BoardConfiguration.build(json)
+      end
+
       # options
       #   - state ~ future, active, closed, you can define multiple states separated by commas, e.g. state=active,closed
       #   - maxResults ~ default: 50 (JIRA API), 1000 (this library)

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.6.0'.freeze
+  VERSION = '2.1.0'.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

@@ -207,6 +207,54 @@ describe JIRA::Client do
     end
   end
 
+  context 'with jwt authentication' do
+    subject do
+      JIRA::Client.new(
+        issuer: 'foo',
+        base_url: 'https://host.tld',
+        shared_secret: 'shared_secret_key',
+        auth_type: :jwt
+      )
+    end
+
+    before(:each) do
+      stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
+          .with(query: hash_including(:jwt))
+          .to_return(status: 200, body: '[]', headers: {})
+    end
+
+    include_examples 'Client Common Tests'
+    include_examples 'HttpClient tests'
+
+    specify { expect(subject.request_client).to be_a JIRA::JwtClient }
+
+    it 'sets the username and password' do
+      expect(subject.options[:shared_secret]).to eq('shared_secret_key')
+    end
+
+    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: {})
+      end
+
+      it 'is not authenticated' do
+        expect(subject.authenticated?).to be_falsey
+      end
+
+      it 'raises a JIRA::HTTPError when trying to fetch projects' do
+        expect { subject.Project.all }.to raise_error JIRA::HTTPError
+      end
+    end
+
+    it 'only returns a true for #authenticated? once we have requested some data' do
+      expect(subject.authenticated?).to be_falsey
+      expect(subject.Project.all).to be_empty
+      expect(subject.authenticated?).to be_truthy
+    end
+  end
+
   context 'oauth authentication' do
     subject { JIRA::Client.new(consumer_key: 'foo', consumer_secret: 'bar') }
 
@@ -218,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