jira-ruby 1.5.0 → 1.6.0

data/spec/jira/oauth_client_spec.rb

@@ -1,43 +1,42 @@
 require 'spec_helper'
 
 describe JIRA::OauthClient do
-
   let(:oauth_client) do
-    options = { :consumer_key => 'foo', :consumer_secret => 'bar' }
+    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(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    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 = [:request_token_path, :authorize_path, :access_token_path]
+  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
+    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
+    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()
+    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')
@@ -46,34 +45,33 @@ describe JIRA::OauthClient do
       expect(oauth_client.request_token).to eq(token)
     end
 
-    it "allows setting the consumer key" do
+    it 'allows setting the consumer key' do
       expect(oauth_client.key).to eq('foo')
     end
 
-    it "allows setting the consumer secret" do
+    it 'allows setting the consumer secret' do
       expect(oauth_client.secret).to eq('bar')
     end
 
-    describe "the access token" do
-
-      it "initializes" do
+    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')
+        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 {
+      it 'raises an exception when accessing without initialisation' do
+        expect do
           oauth_client.access_token
-        }.to raise_exception(JIRA::OauthClient::UninitializedAccessTokenError,
-                             "init_access_token must be called before using the client")
+        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()
+      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')
@@ -83,61 +81,61 @@ describe JIRA::OauthClient do
       end
     end
 
-    describe "http" do
-      it "responds to the http methods" do
-        headers = double()
-        mock_access_token = double()
+    describe 'http' do
+      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)
-        [:delete, :get, :head].each do |method|
+        %i[delete get head].each do |method|
           expect(mock_access_token).to receive(method).with('/path', headers).and_return(response)
           oauth_client.make_request(method, '/path', '', headers)
         end
-        [:post, :put].each do |method|
+        %i[post put].each do |method|
           expect(mock_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
+      it 'performs a request' do
         body = nil
-        headers = double()
-        access_token = double()
+        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
     end
 
-    describe "auth type is oauth_2legged" do
+    describe 'auth type is oauth_2legged' do
       let(:oauth__2legged_client) do
-        options = { :consumer_key => 'foo', :consumer_secret => 'bar', :auth_type => :oauth_2legged }
+        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()
+      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)
-        [:delete, :get, :head].each do |method|
+        %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
-        [:post, :put].each do |method|
+        %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()
+      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)
-        [:delete, :get, :head].each do |method|
+        %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
-        [:post, :put].each do |method|
+        %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

data/spec/jira/request_client_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe JIRA::RequestClient do
-
-  it "raises an exception for non success responses" do
-    response = double()
+  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 {
+
+    expect do
       rc.request(:get, '/foo', '', {})
-    }.to raise_exception(JIRA::HTTPError)
+    end.to raise_exception(JIRA::HTTPError)
   end
 end

data/spec/jira/resource/agile_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe JIRA::Resource::Agile do
   let(:client) do
-    client = double(options: {rest_base_path: '/jira/rest/api/2', context_path: '/jira'})
+    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
@@ -42,7 +42,6 @@ describe JIRA::Resource::Agile do
         expect(issue.class).to eq(JIRA::Resource::Issue)
         expect(issue.expanded?).to be_falsey
       end
-
     end
 
     it 'should query correct url with parameters' do
@@ -60,7 +59,6 @@ describe JIRA::Resource::Agile do
         expect(issue.class).to eq(JIRA::Resource::Issue)
         expect(issue.expanded?).to be_falsey
       end
-
     end
   end
 
@@ -78,18 +76,18 @@ describe JIRA::Resource::Agile do
 
       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

data/spec/jira/resource/attachment_spec.rb

@@ -1,42 +1,41 @@
 require 'spec_helper'
 
 describe JIRA::Resource::Attachment do
-
-  let(:client) {
+  let(:client) do
     double(
       'client',
-      :options => {
-        :rest_base_path => '/jira/rest/api/2'
+      options: {
+        rest_base_path: '/jira/rest/api/2'
       },
-      :request_client => double(
-        :options => {
-          :username => 'username',
-          :password => 'password'
+      request_client: double(
+        options: {
+          username: 'username',
+          password: 'password'
         }
       )
     )
-  }
+  end
 
-  describe "relationships" do
-    subject {
+  describe 'relationships' do
+    subject do
       JIRA::Resource::Attachment.new(client,
-                                     :issue => JIRA::Resource::Issue.new(client),
-                                     :attrs => { 'author' => {'foo' => 'bar'} })
-    }
+                                     issue: JIRA::Resource::Issue.new(client),
+                                     attrs: { 'author' => { 'foo' => 'bar' } })
+    end
 
-    it "has the correct relationships" do
+    it 'has the correct relationships' do
       expect(subject).to have_one(:author, JIRA::Resource::User)
       expect(subject.author.foo).to eq('bar')
     end
   end
 
   describe '#meta' do
-    let(:response) {
+    let(:response) do
       double(
         'response',
-        :body => '{"enabled":true,"uploadLimit":10485760}'
+        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)
@@ -52,16 +51,16 @@ describe JIRA::Resource::Attachment do
 
   describe '#save!' do
     it 'successfully update the attachment' do
-      basic_auth_http_conn = double()
+      basic_auth_http_conn = double
       response = double(
         body: [
           {
-            "id": 10001,
-            "self": "http://www.example.com/jira/rest/api/2.0/attachments/10000",
-            "filename": "picture.jpg",
-            "created": "2017-07-19T12:23:06.572+0000",
-            "size": 23123,
-            "mimeType": "image/jpeg",
+            "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
       )
@@ -76,7 +75,7 @@ describe JIRA::Resource::Attachment do
 
       expect(attachment.filename).to eq 'picture.jpg'
       expect(attachment.mimeType).to eq 'image/jpeg'
-      expect(attachment.size).to eq 23123
+      expect(attachment.size).to eq 23_123
     end
   end
 end

data/spec/jira/resource/board_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'active_support/core_ext/hash'
+
+describe JIRA::Resource::Board do
+  class JIRAResourceDelegation < SimpleDelegator # :nodoc:
+  end
+
+  let(:client) do
+    double(options: {
+             rest_base_path: '/jira/rest/api/2',
+             context_path: ''
+           })
+  end
+
+  let(:board) do
+    response = double
+    api_json_board = "{
+      \"id\": 84,
+      \"self\": \"http://www.example.com/jira/rest/agile/1.0/board/84\",
+      \"name\": \"scrum board\",
+      \"type\": \"scrum\"
+    }"
+    allow(response).to receive(:body).and_return(api_json_board)
+    expect(client).to receive(:get).with('/rest/agile/1.0/board/84')
+                                   .and_return(response)
+
+    expect(client).to receive(:Board).and_return(JIRA::Resource::BoardFactory.new(client))
+    JIRA::Resource::Board.find(client, '84')
+  end
+
+  it 'should find all boards' do
+    response = double
+    api_json = <<eos
+    {
+         "maxResults": 50,
+         "startAt": 0,
+         "isLast": true,
+         "values": [
+            {
+                "id": 84,
+                "name": "scrum board",
+                "type": "scrum"
+            },
+            {
+                "id": 92,
+                "name": "kanban board",
+                "type": "kanban"
+            }
+        ]
+    }
+eos
+    allow(response).to receive(:body).and_return(api_json)
+    expect(client).to receive(:get).with('/rest/agile/1.0/board')
+                                   .and_return(response)
+    expect(client).to receive(:Board).twice.and_return(JIRA::Resource::BoardFactory.new(client))
+    boards = JIRA::Resource::Board.all(client)
+    expect(boards.count).to eq(2)
+  end
+
+  it 'should find one board by id' do
+    expect(board).to be_a(JIRA::Resource::Board)
+  end
+
+  describe '#issues' do
+    it 'should find all issues' do
+      issues_response = double
+
+      api_json_issues = <<eos
+    {
+        "expand": "names,schema",
+        "startAt": 0,
+        "maxResults": 50,
+        "total": 1,
+        "issues": [
+            {
+                "id": "10001",
+                "fields": {
+                    "sprint": {
+                        "id": 37,
+                        "state": "future",
+                        "name": "sprint 2"
+                    },
+                    "description": "example bug report"
+                }
+            }
+        ]
+    }
+eos
+
+      allow(issues_response).to receive(:body).and_return(api_json_issues)
+      allow(board).to receive(:id).and_return(84)
+      expect(client).to receive(:get).with('/rest/agile/1.0/board/84/issue?')
+                                     .and_return(issues_response)
+      expect(client).to receive(:Issue).and_return(JIRA::Resource::IssueFactory.new(client))
+
+      expect(board.issues.size).to be(1)
+    end
+
+    describe 'pagination' do
+      subject { described_class.new(client) }
+      let(:client) { JIRA::Client.new }
+
+      before do
+        allow(subject).to receive(:id).and_return('123')
+      end
+
+      context 'when there are multiple pages of results' do
+        let(:result_1) do
+          OpenStruct.new(body: {
+            'startAt' => 0,
+            'maxResults' => 1,
+            'total' => 2,
+            'issues' => []
+          }.to_json)
+        end
+        let(:result_2) do
+          OpenStruct.new(body: {
+            'startAt' => 1,
+            'maxResults' => 1,
+            'total' => 2,
+            'issues' => []
+          }.to_json)
+        end
+
+        it 'makes multiple requests and increments the startAt param' do
+          expect(client).to receive(:get).and_return(result_1)
+          expect(client).to receive(:get).and_return(result_2)
+          subject.issues
+        end
+      end
+
+      context 'when there is only one page of results' do
+        let(:result_1) do
+          OpenStruct.new(body: {
+            'startAt' => 0,
+            'maxResults' => 2,
+            'total' => 2,
+            'issues' => []
+          }.to_json)
+        end
+
+        it 'only requires one request' do
+          expect(client).to receive(:get).once.and_return(result_1)
+          subject.issues
+        end
+      end
+    end
+  end
+
+  it 'should get all sprints for a board' do
+    response = double
+
+    api_json = <<-eos
+    {
+        "values": [
+            {
+                "id": 37,
+                "state": "closed",
+                "name": "sprint 1"
+            },
+            {
+                "id": 72,
+                "state": "future",
+                "name": "sprint 2"
+            }
+        ]
+    }
+    eos
+    allow(response).to receive(:body).and_return(api_json)
+    allow(board).to receive(:id).and_return(84)
+    expect(client).to receive(:get).with('/rest/agile/1.0/board/84/sprint?').and_return(response)
+    expect(client).to receive(:Sprint).twice.and_return(JIRA::Resource::SprintFactory.new(client))
+    expect(board.sprints.size).to be(2)
+  end
+end