jira-ruby 1.6.0 → 2.3.0

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/issue_picker_suggestions.rb

@@ -0,0 +1,24 @@
+module JIRA
+  module Resource
+    class IssuePickerSuggestionsFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class IssuePickerSuggestions < JIRA::Base
+      has_many :sections, class: JIRA::Resource::IssuePickerSuggestionsIssue
+
+      def self.all(client, query = '', options = { current_jql: nil, current_issue_key: nil, current_project_id: nil, show_sub_tasks: nil, show_sub_tasks_parent: nil })
+        url = client.options[:rest_base_path] + "/issue/picker?query=#{CGI.escape(query)}"
+
+        url << "&currentJQL=#{CGI.escape(options[:current_jql])}" if options[:current_jql]
+        url << "&currentIssueKey=#{CGI.escape(options[:current_issue_key])}" if options[:current_issue_key]
+        url << "&currentProjectId=#{CGI.escape(options[:current_project_id])}" if options[:current_project_id]
+        url << "&showSubTasks=#{options[:show_sub_tasks]}" if options[:show_sub_tasks]
+        url << "&showSubTaskParent=#{options[:show_sub_task_parent]}" if options[:show_sub_task_parent]
+
+        response = client.get(url)
+        json = parse_json(response.body)
+        client.IssuePickerSuggestions.build(json)
+      end
+    end
+  end
+end

data/lib/jira/resource/issue_picker_suggestions_issue.rb

@@ -0,0 +1,10 @@
+module JIRA
+  module Resource
+    class IssuePickerSuggestionsIssueFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class IssuePickerSuggestionsIssue < JIRA::Base
+      has_many :issues, class: JIRA::Resource::SuggestedIssue
+    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/suggested_issue.rb

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

data/lib/jira/resource/user.rb

@@ -18,7 +18,7 @@ module JIRA
 
       # Cannot retrieve more than 1,000 users through the api, please see: https://jira.atlassian.com/browse/JRASERVER-65089
       def self.all(client)
-        response  = client.get("/rest/api/2/user/search?username=_&maxResults=#{MAX_RESULTS}")
+        response  = client.get("/rest/api/2/users/search?username=_&maxResults=#{MAX_RESULTS}")
         all_users = JSON.parse(response.body)
 
         all_users.flatten.uniq.map do |user|

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.3.0'.freeze
 end

data/lib/jira-ruby.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH << __dir__
 
+require 'active_support'
 require 'active_support/inflector'
 ActiveSupport::Inflector.inflections do |inflector|
   inflector.singular /status$/, 'status'
@@ -25,6 +26,9 @@ require 'jira/resource/worklog'
 require 'jira/resource/applinks'
 require 'jira/resource/issuelinktype'
 require 'jira/resource/issuelink'
+require 'jira/resource/suggested_issue'
+require 'jira/resource/issue_picker_suggestions_issue'
+require 'jira/resource/issue_picker_suggestions'
 require 'jira/resource/remotelink'
 require 'jira/resource/sprint'
 require 'jira/resource/sprint_report'
@@ -38,10 +42,12 @@ require 'jira/resource/createmeta'
 require 'jira/resource/webhook'
 require 'jira/resource/agile'
 require 'jira/resource/board'
+require 'jira/resource/board_configuration'
 
 require 'jira/request_client'
 require 'jira/oauth_client'
 require 'jira/http_client'
+require 'jira/jwt_client'
 require 'jira/client'
 
 require 'jira/railtie' if defined?(Rails)

data/spec/integration/user_spec.rb

@@ -21,18 +21,18 @@ describe JIRA::Resource::User do
     describe '#all' do
       let(:client) do
         client = double(options: { rest_base_path: '/jira/rest/api/2' })
-        allow(client).to receive(:get).with('/rest/api/2/user/search?username=_&maxResults=1000').and_return(JIRA::Resource::UserFactory.new(client))
+        allow(client).to receive(:get).with('/rest/api/2/users/search?username=_&maxResults=1000').and_return(JIRA::Resource::UserFactory.new(client))
         client
       end
 
       before do
         allow(client).to receive(:get)
-          .with('/rest/api/2/user/search?username=_&maxResults=1000') { OpenStruct.new(body: '["User1"]') }
+          .with('/rest/api/2/users/search?username=_&maxResults=1000') { OpenStruct.new(body: '["User1"]') }
         allow(client).to receive_message_chain(:User, :build).with('users') { [] }
       end
 
       it 'gets users with maxResults of 1000' do
-        expect(client).to receive(:get).with('/rest/api/2/user/search?username=_&maxResults=1000')
+        expect(client).to receive(:get).with('/rest/api/2/users/search?username=_&maxResults=1000')
         expect(client).to receive_message_chain(:User, :build).with('User1')
         JIRA::Resource::User.all(client)
       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

@@ -59,6 +59,19 @@ RSpec.shared_examples 'Client Common Tests' do
       expect(subject.Project.find('123')).to eq(find_result)
     end
   end
+
+  describe 'SSL client options' do
+    context 'without certificate and key' do
+      let(:options) { { use_client_cert: true } }
+      subject { JIRA::Client.new(options) }
+
+      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')
+      end
+    end
+  end
 end
 
 RSpec.shared_examples 'HttpClient tests' do
@@ -207,6 +220,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 +279,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
@@ -189,11 +280,16 @@ describe JIRA::HttpClient do
     expect(http_conn).to receive(:use_ssl=).with(basic_client.options[:use_ssl])
     expect(http_conn).to receive(:verify_mode=).with(basic_client.options[:ssl_verify_mode])
     expect(http_conn).to receive(:read_timeout=).with(basic_client.options[:read_timeout])
-    expect(http_conn).to receive(:cert=).with(basic_client_cert_client.options[:cert])
-    expect(http_conn).to receive(:key=).with(basic_client_cert_client.options[:key])
+    expect(http_conn).to receive(:cert=).with(basic_client_cert_client.options[:ssl_client_cert])
+    expect(http_conn).to receive(:key=).with(basic_client_cert_client.options[:ssl_client_key])
     expect(basic_client_cert_client.http_conn(uri)).to eq(http_conn)
   end
 
+  it 'can use a certificate authority file' do
+    client = JIRA::HttpClient.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 'returns a http connection' do
     http_conn = double
     uri = double
@@ -201,4 +297,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/jwt_uri_builder_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe JIRA::JwtClient::JwtUriBuilder do
+  subject(:url_builder) do
+    JIRA::JwtClient::JwtUriBuilder.new(url, http_method, shared_secret, site, issuer)
+  end
+
+  let(:url) { '/foo' }
+  let(:http_method) { :get }
+  let(:shared_secret) { 'shared_secret' }
+  let(:site) { 'http://localhost:2990' }
+  let(:issuer) { nil }
+
+  describe '#build' do
+    subject { url_builder.build }
+
+    it 'includes the jwt param' do
+      expect(subject).to include('?jwt=')
+    end
+
+    context 'when the url already contains params' do
+      let(:url) { '/foo?expand=projects.issuetypes.fields' }
+
+      it 'includes the jwt param' do
+        expect(subject).to include('&jwt=')
+      end
+    end
+
+    context 'with a complete url' do
+      let(:url) { 'http://localhost:2990/rest/api/2/issue/createmeta' }
+
+      it 'includes the jwt param' do
+        expect(subject).to include('?jwt=')
+      end
+
+      it { is_expected.to start_with('/') }
+
+      it 'contains only one ?' do
+        expect(subject.count('?')).to eq(1)
+      end
+    end
+
+    context 'with a complete url containing a param' do
+      let(:url) do
+        'http://localhost:2990/rest/api/2/issue/createmeta?expand=projects.issuetypes.fields'
+      end
+
+      it 'includes the jwt param' do
+        expect(subject).to include('&jwt=')
+      end
+
+      it { is_expected.to start_with('/') }
+
+      it 'contains only one ?' do
+        expect(subject.count('?')).to eq(1)
+      end
+    end
+  end
+end