jira-ruby 2.1.3

data/spec/jira/http_error_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe JIRA::HTTPError do
+  let(:response) do
+    response = double('response')
+    allow(response).to receive(:code).and_return(401)
+    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
+    expect(subject.response).to eq(response)
+  end
+
+  it 'has a code method' do
+    expect(subject.code).to eq(response.code)
+  end
+
+  it 'returns code and class from message' do
+    expect(subject.message).to eq(response.message)
+  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

data/spec/jira/oauth_client_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe JIRA::OauthClient do
+  let(:oauth_client) do
+    options = { consumer_key: 'foo', consumer_secret: 'bar' }
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(options)
+    JIRA::OauthClient.new(options)
+  end
+
+  let(:response) do
+    response = double('response')
+    allow(response).to receive(:is_a?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+
+  describe 'authenticating with oauth' do
+    it 'prepends the context path to all authorization and rest paths' do
+      options = %i[request_token_path authorize_path access_token_path]
+      defaults = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::OauthClient::DEFAULT_OPTIONS)
+      options.each do |key|
+        expect(oauth_client.options[key]).to eq(defaults[:context_path] + defaults[key])
+      end
+    end
+
+    it 'creates a Oauth::Consumer on initialize' do
+      expect(oauth_client.consumer.class).to eq(OAuth::Consumer)
+      expect(oauth_client.consumer.key).to eq(oauth_client.key)
+      expect(oauth_client.consumer.secret).to eq(oauth_client.secret)
+    end
+
+    it 'returns an OAuth request_token' do
+      # Cannot just check for method delegation as http connection will be attempted
+      request_token = OAuth::RequestToken.new(oauth_client.consumer)
+      allow(oauth_client).to receive(:get_request_token).and_return(request_token)
+      expect(oauth_client.get_request_token).to eq(request_token)
+    end
+
+    it 'allows setting the request token' do
+      token = double
+      expect(OAuth::RequestToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+
+      request_token = oauth_client.set_request_token('foo', 'bar')
+
+      expect(request_token).to eq(token)
+      expect(oauth_client.request_token).to eq(token)
+    end
+
+    it 'allows setting the consumer key' do
+      expect(oauth_client.key).to eq('foo')
+    end
+
+    it 'allows setting the consumer secret' do
+      expect(oauth_client.secret).to eq('bar')
+    end
+
+    describe 'the access token' do
+      it 'initializes' do
+        request_token = OAuth::RequestToken.new(oauth_client.consumer)
+        allow(oauth_client).to receive(:get_request_token).and_return(request_token)
+        mock_access_token = double
+        expect(request_token).to receive(:get_access_token).with(oauth_verifier: 'abc123').and_return(mock_access_token)
+        oauth_client.init_access_token(oauth_verifier: 'abc123')
+        expect(oauth_client.access_token).to eq(mock_access_token)
+      end
+
+      it 'raises an exception when accessing without initialisation' do
+        expect do
+          oauth_client.access_token
+        end.to raise_exception(JIRA::OauthClient::UninitializedAccessTokenError,
+                               'init_access_token must be called before using the client')
+      end
+
+      it 'allows setting the access token' do
+        token = double
+        expect(OAuth::AccessToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+
+        access_token = oauth_client.set_access_token('foo', 'bar')
+
+        expect(access_token).to eq(token)
+        expect(oauth_client.access_token).to eq(token)
+      end
+    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
+        %i[delete get head].each do |method|
+          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(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
+        expect(access_token).to receive(:send).with(:get, '/foo', headers).and_return(response)
+
+
+        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
+      let(:oauth__2legged_client) do
+        options = { consumer_key: 'foo', consumer_secret: 'bar', auth_type: :oauth_2legged }
+        options = JIRA::Client::DEFAULT_OPTIONS.merge(options)
+        JIRA::OauthClient.new(options)
+      end
+
+      it 'responds to the http methods adding oauth_token parameter' do
+        headers = double
+        mock_access_token = double
+        allow(oauth__2legged_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?oauth_token=', headers).and_return(response)
+          oauth__2legged_client.make_request(method, '/path', '', headers)
+        end
+        %i[post put].each do |method|
+          expect(mock_access_token).to receive(method).with('/path?oauth_token=', '', headers).and_return(response)
+          oauth__2legged_client.make_request(method, '/path', '', headers)
+        end
+      end
+
+      it 'responds to the http methods adding oauth_token parameter to any existing parameters' do
+        headers = double
+        mock_access_token = double
+        allow(oauth__2legged_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?any_param=toto&oauth_token=', headers).and_return(response)
+          oauth__2legged_client.make_request(method, '/path?any_param=toto', '', headers)
+        end
+        %i[post put].each do |method|
+          expect(mock_access_token).to receive(method).with('/path?any_param=toto&oauth_token=', '', headers).and_return(response)
+          oauth__2legged_client.make_request(method, '/path?any_param=toto', '', headers)
+        end
+      end
+    end
+  end
+end

data/spec/jira/request_client_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe JIRA::RequestClient do
+  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

data/spec/jira/resource/agile_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Agile do
+  let(:client) do
+    client = double(options: { rest_base_path: '/jira/rest/api/2', context_path: '/jira' })
+    allow(client).to receive(:Issue).and_return(JIRA::Resource::IssueFactory.new(client))
+    client
+  end
+  let(:response) { double }
+
+  describe '#all' do
+    it 'should query url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.all(client)
+    end
+  end
+
+  describe '#get_backlog_issues' do
+    it 'should query the url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/backlog?maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_backlog_issues(client, 1)
+    end
+  end
+
+  describe '#get_board_issues' do
+    it 'should query correct url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/issue?').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1_issues.json'))
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/search?jql=id+IN%2810546%2C+10547%2C+10556%2C+10557%2C+10558%2C+10559%2C+10600%2C+10601%2C+10604%29').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1_issues.json'))
+
+      issues = JIRA::Resource::Agile.get_board_issues(client, 1)
+      expect(issues).to be_an(Array)
+      expect(issues.size).to eql(9)
+
+      issues.each do |issue|
+        expect(issue.class).to eq(JIRA::Resource::Issue)
+        expect(issue.expanded?).to be_falsey
+      end
+    end
+
+    it 'should query correct url with parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/issue?startAt=50').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1_issues.json'))
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/search?jql=id+IN%2810546%2C+10547%2C+10556%2C+10557%2C+10558%2C+10559%2C+10600%2C+10601%2C+10604%29').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1_issues.json'))
+
+      issues = JIRA::Resource::Agile.get_board_issues(client, 1, startAt: 50)
+      expect(issues).to be_an(Array)
+      expect(issues.size).to eql(9)
+
+      issues.each do |issue|
+        expect(issue.class).to eq(JIRA::Resource::Issue)
+        expect(issue.expanded?).to be_falsey
+      end
+    end
+  end
+
+  describe '#get_sprints' do
+    it 'should query correct url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/sprint?maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_sprints(client, 1)
+    end
+
+    it 'should query correct url with parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/sprint?startAt=50&maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_sprints(client, 1, startAt: 50)
+    end
+
+    it 'should work with pagination starting at 0' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/sprint?maxResults=1&startAt=0').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_sprints(client, 1, maxResults: 1, startAt: 0)
+    end
+
+    it 'should work with pagination not starting at 0' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/sprint?maxResults=1&startAt=1').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_sprints(client, 1, maxResults: 1, startAt: 1)
+    end
+  end
+
+  describe '#get_sprint_issues' do
+    it 'should query correct url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/sprint/1/issue?maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('sprint/1_issues.json'))
+
+      JIRA::Resource::Agile.get_sprint_issues(client, 1)
+    end
+
+    it 'should query correct url with parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/sprint/1/issue?startAt=50&maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('sprint/1_issues.json'))
+
+      JIRA::Resource::Agile.get_sprint_issues(client, 1, startAt: 50)
+    end
+  end
+
+  describe '#get_projects_full' do
+    it 'should query correct url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/project/full').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_projects_full(client, 1)
+    end
+  end
+
+  describe '#get_projects' do
+    it 'should query correct url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/project?maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_projects(client, 1)
+    end
+
+    it 'should query correct url with parameters' do
+      expect(client).to receive(:get).with('/jira/rest/agile/1.0/board/1/project?startAt=50&maxResults=100').and_return(response)
+      expect(response).to receive(:body).and_return(get_mock_response('board/1.json'))
+
+      JIRA::Resource::Agile.get_projects(client, 1, startAt: 50)
+    end
+  end
+end

data/spec/jira/resource/attachment_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Attachment do
+  subject(:attachment) do
+    JIRA::Resource::Attachment.new(
+        client,
+        issue: JIRA::Resource::Issue.new(client),
+        attrs: { 'author' => { 'foo' => 'bar' } }
+    )
+  end
+
+  let(:client) do
+    double(
+      'client',
+      options: {
+        rest_base_path: '/jira/rest/api/2'
+      },
+      request_client: double(
+        options: {
+          username: 'username',
+          password: 'password'
+        }
+      )
+    )
+  end
+
+  describe 'relationships' do
+    it 'has an author' do
+      expect(subject).to have_one(:author, JIRA::Resource::User)
+    end
+
+    it 'has the correct author name' do
+      expect(subject.author.foo).to eq('bar')
+    end
+  end
+
+  describe '.meta' do
+    subject { JIRA::Resource::Attachment.meta(client) }
+
+    let(:response) do
+      double(
+          'response',
+          body: '{"enabled":true,"uploadLimit":10485760}'
+      )
+    end
+
+    it 'returns meta information about attachment upload' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/attachment/meta').and_return(response)
+
+      subject
+    end
+
+    context 'the factory delegates correctly' do
+      subject { JIRA::Resource::AttachmentFactory.new(client) }
+
+      it 'delegates #meta to to target class' do
+        expect(subject).to respond_to(:meta)
+      end
+    end
+  end
+
+  describe '#save' do
+    subject { attachment.save('file' => path_to_file) }
+    let(:path_to_file) { './spec/mock_responses/issue.json' }
+    let(:response) do
+      double(
+        body: [
+          {
+            "id": 10_001,
+            "self": 'http://www.example.com/jira/rest/api/2.0/attachments/10000',
+            "filename": 'picture.jpg',
+            "created": '2017-07-19T12:23:06.572+0000',
+            "size": 23_123,
+            "mimeType": 'image/jpeg'
+          }
+        ].to_json
+      )
+    end
+    let(:issue) { JIRA::Resource::Issue.new(client) }
+
+    before do
+      allow(client).to receive(:post_multipart).and_return(response)
+    end
+
+    it 'successfully update the attachment' do
+      subject
+
+      expect(attachment.filename).to eq 'picture.jpg'
+      expect(attachment.mimeType).to eq 'image/jpeg'
+      expect(attachment.size).to eq 23_123
+    end
+  end
+
+  describe '#save!' do
+    subject { attachment.save!('file' => path_to_file) }
+
+    let(:path_to_file) { './spec/mock_responses/issue.json' }
+    let(:response) do
+      double(
+        body: [
+          {
+            "id": 10_001,
+            "self": 'http://www.example.com/jira/rest/api/2.0/attachments/10000',
+            "filename": 'picture.jpg',
+            "created": '2017-07-19T12:23:06.572+0000',
+            "size": 23_123,
+            "mimeType": 'image/jpeg'
+          }
+        ].to_json
+      )
+    end
+    let(:issue) { JIRA::Resource::Issue.new(client) }
+
+    before do
+      allow(client).to receive(:post_multipart).and_return(response)
+    end
+
+    it 'successfully update the attachment' do
+      subject
+
+      expect(attachment.filename).to eq 'picture.jpg'
+      expect(attachment.mimeType).to eq 'image/jpeg'
+      expect(attachment.size).to eq 23_123
+    end
+
+    context 'when passing in a symbol as file key' do
+      subject { attachment.save!(file: path_to_file) }
+
+      it 'successfully update the attachment' do
+        subject
+
+        expect(attachment.filename).to eq 'picture.jpg'
+        expect(attachment.mimeType).to eq 'image/jpeg'
+        expect(attachment.size).to eq 23_123
+      end
+    end
+  end
+end