jira-ruby 2.2.0 → 3.0.0.beta1

data/spec/jira/resource/attachment_spec.rb

@@ -2,10 +2,10 @@ 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' } }
+    described_class.new(
+      client,
+      issue: JIRA::Resource::Issue.new(client),
+      attrs: { 'author' => { 'foo' => 'bar' } }
     )
   end
 
@@ -35,12 +35,12 @@ describe JIRA::Resource::Attachment do
   end
 
   describe '.meta' do
-    subject { JIRA::Resource::Attachment.meta(client) }
+    subject { described_class.meta(client) }
 
     let(:response) do
       double(
-          'response',
-          body: '{"enabled":true,"uploadLimit":10485760}'
+        'response',
+        body: '{"enabled":true,"uploadLimit":10485760}'
       )
     end
 
@@ -59,79 +59,169 @@ describe JIRA::Resource::Attachment do
     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
+  context 'there is an attachment on an issue' do
+    subject(:attachment) do
+      described_class.new(
+        client,
+        issue: JIRA::Resource::Issue.new(client),
+        attrs: { 'author' => { 'foo' => 'bar' }, 'content' => attachment_url }
       )
     end
-    let(:issue) { JIRA::Resource::Issue.new(client) }
+
+    let(:client) do
+      JIRA::Client.new(username: 'username', password: 'password', auth_type: :basic, use_ssl: false)
+    end
+    let(:attachment_file_contents) { 'file contents' }
+    let(:attachment_url) { 'https://localhost:2990/secure/attachment/32323/myfile.txt' }
 
     before do
-      allow(client).to receive(:post_multipart).and_return(response)
+      stub_request(:get, attachment_url).to_return(body: attachment_file_contents)
     end
 
-    it 'successfully update the attachment' do
-      subject
+    describe '.download_file' do
+      it 'passes file object to block' do
+        expect(URI).to receive(:parse).with(attachment_url).and_call_original
 
-      expect(attachment.filename).to eq 'picture.jpg'
-      expect(attachment.mimeType).to eq 'image/jpeg'
-      expect(attachment.size).to eq 23_123
+        attachment.download_file do |file|
+          expect(file.read).to eq(attachment_file_contents)
+        end
+      end
     end
-  end
 
-  describe '#save!' do
-    subject { attachment.save!('file' => path_to_file) }
+    describe '.download_contents' do
+      it 'downloads the file contents as a string' do
+        expect(URI).to receive(:parse).with(attachment_url).and_call_original
+        expect(attachment.download_contents).to eq(attachment_file_contents)
+      end
+    end
+  end
 
-    let(:path_to_file) { './spec/mock_responses/issue.json' }
+  context 'when there is a local file' do
+    let(:file_name) { 'short.txt' }
+    let(:file_size) { 11 }
+    let(:file_mime_type) { 'text/plain' }
+    let(:path_to_file) { "./spec/data/files/#{file_name}" }
     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'
+            id: 10_001,
+            self: 'http://www.example.com/jira/rest/api/2.0/attachments/10000',
+            filename: file_name,
+            created: '2017-07-19T12:23:06.572+0000',
+            size: file_size,
+            mimeType: file_mime_type
           }
         ].to_json
       )
     end
     let(:issue) { JIRA::Resource::Issue.new(client) }
 
-    before do
-      allow(client).to receive(:post_multipart).and_return(response)
-    end
+    describe '#save' do
+      subject { attachment.save('file' => path_to_file) }
 
-    it 'successfully update the attachment' do
-      subject
+      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
+        expect(attachment.filename).to eq file_name
+        expect(attachment.mimeType).to eq file_mime_type
+        expect(attachment.size).to eq file_size
+      end
+
+      context 'when using custom client headers' do
+        subject(:bearer_attachment) do
+          described_class.new(
+            bearer_client,
+            issue: JIRA::Resource::Issue.new(bearer_client),
+            attrs: { 'author' => { 'foo' => 'bar' } }
+          )
+        end
+
+        let(:default_headers_given) do
+          {
+            'authorization' => 'Bearer 83CF8B609DE60036A8277BD0E96135751BBC07EB234256D4B65B893360651BF2'
+          }
+        end
+        let(:bearer_client) do
+          JIRA::Client.new(username: 'username', password: 'password', auth_type: :basic, use_ssl: false,
+                           default_headers: default_headers_given)
+        end
+        let(:merged_headers) do
+          {
+            'Accept' => 'application/json',
+            'X-Atlassian-Token' => 'nocheck'
+          }.merge(default_headers_given)
+        end
+
+        it 'passes the custom headers' do
+          expect(bearer_client.request_client).to receive(:request_multipart)
+            .with(anything, anything, merged_headers)
+            .and_return(response)
+
+          bearer_attachment.save('file' => path_to_file)
+        end
+      end
     end
 
-    context 'when passing in a symbol as file key' do
-      subject { attachment.save!(file: path_to_file) }
+    describe '#save!' do
+      subject { attachment.save!('file' => path_to_file) }
+
+      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
+        expect(attachment.filename).to eq file_name
+        expect(attachment.mimeType).to eq file_mime_type
+        expect(attachment.size).to eq file_size
+      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 file_name
+          expect(attachment.mimeType).to eq file_mime_type
+          expect(attachment.size).to eq file_size
+        end
+      end
+
+      context 'when using custom client headers' do
+        subject(:bearer_attachment) do
+          described_class.new(
+            bearer_client,
+            issue: JIRA::Resource::Issue.new(bearer_client),
+            attrs: { 'author' => { 'foo' => 'bar' } }
+          )
+        end
+
+        let(:default_headers_given) { { 'authorization' => 'Bearer 83CF8B609DE60036A8277BD0E96135751BBC07EB234256D4B65B893360651BF2' } }
+        let(:bearer_client) do
+          JIRA::Client.new(username: 'username', password: 'password', auth_type: :basic, use_ssl: false,
+                           default_headers: default_headers_given)
+        end
+        let(:merged_headers) do
+          {
+            'Accept' => 'application/json',
+            'X-Atlassian-Token' => 'nocheck'
+          }.merge(default_headers_given)
+        end
+
+        it 'passes the custom headers' do
+          expect(bearer_client.request_client).to receive(:request_multipart)
+            .with(anything, anything, merged_headers)
+            .and_return(response)
+
+          bearer_attachment.save!('file' => path_to_file)
+        end
       end
     end
   end

data/spec/jira/resource/board_spec.rb

@@ -21,16 +21,16 @@ describe JIRA::Resource::Board do
       \"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)
+    allow(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')
+    allow(client).to receive(:Board).and_return(JIRA::Resource::BoardFactory.new(client))
+    described_class.find(client, '84')
   end
 
-  it 'should find all boards' do
+  it 'finds all boards' do
     response = double
-    api_json = <<eos
+    api_json = <<EOS
     {
          "maxResults": 50,
          "startAt": 0,
@@ -48,24 +48,24 @@ describe JIRA::Resource::Board do
             }
         ]
     }
-eos
+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)
+    boards = described_class.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)
+  it 'finds one board by id' do
+    expect(board).to be_a(described_class)
   end
 
   describe '#issues' do
-    it 'should find all issues' do
+    it 'finds all issues' do
       issues_response = double
 
-      api_json_issues = <<eos
+      api_json_issues = <<EOS
     {
         "expand": "names,schema",
         "startAt": 0,
@@ -85,7 +85,7 @@ eos
             }
         ]
     }
-eos
+EOS
 
       allow(issues_response).to receive(:body).and_return(api_json_issues)
       allow(board).to receive(:id).and_return(84)
@@ -98,6 +98,7 @@ eos
 
     describe 'pagination' do
       subject { described_class.new(client) }
+
       let(:client) { JIRA::Client.new }
 
       before do
@@ -147,10 +148,10 @@ eos
     end
   end
 
-  it 'should get all sprints for a board' do
+  it 'gets all sprints for a board' do
     response = double
 
-    api_json = <<-eos
+    api_json = <<-EOS
     {
         "values": [
             {
@@ -165,7 +166,7 @@ eos
             }
         ]
     }
-    eos
+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)
@@ -173,10 +174,10 @@ eos
     expect(board.sprints.size).to be(2)
   end
 
-  it 'should get board configuration for a board' do
+  it 'gets board configuration for a board' do
     response = double
 
-    api_json = <<-eos
+    api_json = <<-EOS
       {
         "id":1,
         "name":"My Board",
@@ -214,11 +215,11 @@ eos
           "rankCustomFieldId":10011
         }
       }
-    eos
+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/configuration').and_return(response)
     expect(client).to receive(:BoardConfiguration).and_return(JIRA::Resource::BoardConfigurationFactory.new(client))
-    expect(board.configuration).not_to be(nil)
+    expect(board.configuration).not_to be_nil
   end
 end

data/spec/jira/resource/createmeta_spec.rb

@@ -18,24 +18,24 @@ describe JIRA::Resource::Createmeta do
   end
 
   describe 'general' do
-    it 'should query correct url without parameters' do
+    it 'queries correct url without parameters' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta').and_return(response)
-      JIRA::Resource::Createmeta.all(client)
+      described_class.all(client)
     end
 
-    it 'should query correct url with `expand` parameter' do
+    it 'queries correct url with `expand` parameter' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?expand=projects.issuetypes.fields').and_return(response)
-      JIRA::Resource::Createmeta.all(client, expand: 'projects.issuetypes.fields')
+      described_class.all(client, expand: 'projects.issuetypes.fields')
     end
 
-    it 'should query correct url with `foo` parameter' do
+    it 'queries correct url with `foo` parameter' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?foo=bar').and_return(response)
-      JIRA::Resource::Createmeta.all(client, foo: 'bar')
+      described_class.all(client, foo: 'bar')
     end
 
-    it 'should return an array of createmeta objects' do
+    it 'returns an array of createmeta objects' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta').and_return(response)
-      createmetas = JIRA::Resource::Createmeta.all(client)
+      createmetas = described_class.all(client)
       expect(createmetas).to be_an Array
       createmeta = createmetas.first
       expect(createmeta.id).to eq '10200'
@@ -45,52 +45,52 @@ describe JIRA::Resource::Createmeta do
   end
 
   describe 'projectKeys' do
-    it 'should query correct url when only one `projectKeys` given as string' do
+    it 'queries correct url when only one `projectKeys` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PROJECT_1').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectKeys: 'PROJECT_1'
       )
     end
 
-    it 'should query correct url when multiple `projectKeys` given as string' do
+    it 'queries correct url when multiple `projectKeys` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PROJECT_1%2CPROJECT_2').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectKeys: %w[PROJECT_1 PROJECT_2]
       )
     end
 
-    it 'should query correct url when only one `projectKeys` given as Project' do
+    it 'queries correct url when only one `projectKeys` given as Project' do
       prj = JIRA::Resource::Project.new(client)
       allow(prj).to receive(:key).and_return('PRJ')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PRJ').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectKeys: prj
       )
     end
 
-    it 'should query correct url when multiple `projectKeys` given as Project' do
+    it 'queries correct url when multiple `projectKeys` given as Project' do
       prj_1 = JIRA::Resource::Project.new(client)
       allow(prj_1).to receive(:key).and_return('PRJ_1')
       prj_2 = JIRA::Resource::Project.new(client)
       allow(prj_2).to receive(:key).and_return('PRJ_2')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PRJ_2%2CPRJ_1').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectKeys: [prj_2, prj_1]
       )
     end
 
-    it 'should query correct url when multiple `projectKeys` given as different types' do
+    it 'queries correct url when multiple `projectKeys` given as different types' do
       prj_5 = JIRA::Resource::Project.new(client)
       allow(prj_5).to receive(:key).and_return('PRJ_5')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PROJECT_1%2CPRJ_5').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectKeys: ['PROJECT_1', prj_5]
       )
@@ -98,52 +98,52 @@ describe JIRA::Resource::Createmeta do
   end
 
   describe 'projectIds' do
-    it 'should query correct url when only one `projectIds` given as string' do
+    it 'queries correct url when only one `projectIds` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=10101').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectIds: '10101'
       )
     end
 
-    it 'should query correct url when multiple `projectIds` given as string' do
+    it 'queries correct url when multiple `projectIds` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=10101%2C20202').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectIds: %w[10101 20202]
       )
     end
 
-    it 'should query correct url when only one `projectIds` given as Project' do
+    it 'queries correct url when only one `projectIds` given as Project' do
       prj = JIRA::Resource::Project.new(client)
       allow(prj).to receive(:id).and_return('30303')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=30303').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectIds: prj
       )
     end
 
-    it 'should query correct url when multiple `projectIds` given as Project' do
+    it 'queries correct url when multiple `projectIds` given as Project' do
       prj_1 = JIRA::Resource::Project.new(client)
       allow(prj_1).to receive(:id).and_return('30303')
       prj_2 = JIRA::Resource::Project.new(client)
       allow(prj_2).to receive(:id).and_return('50505')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=50505%2C30303').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectIds: [prj_2, prj_1]
       )
     end
 
-    it 'should query correct url when multiple `projectIds` given as different types' do
+    it 'queries correct url when multiple `projectIds` given as different types' do
       prj_5 = JIRA::Resource::Project.new(client)
       allow(prj_5).to receive(:id).and_return('60606')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=10101%2C60606').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         projectIds: ['10101', prj_5]
       )
@@ -151,52 +151,52 @@ describe JIRA::Resource::Createmeta do
   end
 
   describe 'issuetypeNames' do
-    it 'should query correct url when only one `issuetypeNames` given as string' do
+    it 'queries correct url when only one `issuetypeNames` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Feature').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeNames: 'Feature'
       )
     end
 
-    it 'should query correct url when multiple `issuetypeNames` given as string' do
+    it 'queries correct url when multiple `issuetypeNames` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Feature%2CBug').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeNames: %w[Feature Bug]
       )
     end
 
-    it 'should query correct url when only one `issuetypeNames` given as Issuetype' do
+    it 'queries correct url when only one `issuetypeNames` given as Issuetype' do
       issue_type = JIRA::Resource::Issuetype.new(client)
       allow(issue_type).to receive(:name).and_return('Epic')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Epic').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeNames: issue_type
       )
     end
 
-    it 'should query correct url when multiple `issuetypeNames` given as Issuetype' do
+    it 'queries correct url when multiple `issuetypeNames` given as Issuetype' do
       issue_type_1 = JIRA::Resource::Issuetype.new(client)
       allow(issue_type_1).to receive(:name).and_return('Epic')
       issue_type_2 = JIRA::Resource::Issuetype.new(client)
       allow(issue_type_2).to receive(:name).and_return('Sub-Task')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Sub-Task%2CEpic').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeNames: [issue_type_2, issue_type_1]
       )
     end
 
-    it 'should query correct url when multiple `issuetypeNames` given as different types' do
+    it 'queries correct url when multiple `issuetypeNames` given as different types' do
       issue_type = JIRA::Resource::Issuetype.new(client)
       allow(issue_type).to receive(:name).and_return('Epic')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Feature%2CEpic').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeNames: ['Feature', issue_type]
       )
@@ -204,52 +204,52 @@ describe JIRA::Resource::Createmeta do
   end
 
   describe 'issuetypeIds' do
-    it 'should query correct url when only one `issuetypeIds` given as string' do
+    it 'queries correct url when only one `issuetypeIds` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=10101').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeIds: '10101'
       )
     end
 
-    it 'should query correct url when multiple `issuetypeIds` given as string' do
+    it 'queries correct url when multiple `issuetypeIds` given as string' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=10101%2C20202').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeIds: %w[10101 20202]
       )
     end
 
-    it 'should query correct url when only one `issuetypeIds` given as Issuetype' do
+    it 'queries correct url when only one `issuetypeIds` given as Issuetype' do
       issue_type = JIRA::Resource::Issuetype.new(client)
       allow(issue_type).to receive(:id).and_return('30303')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=30303').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeIds: issue_type
       )
     end
 
-    it 'should query correct url when multiple `issuetypeIds` given as Issuetype' do
+    it 'queries correct url when multiple `issuetypeIds` given as Issuetype' do
       issue_type_1 = JIRA::Resource::Issuetype.new(client)
       allow(issue_type_1).to receive(:id).and_return('30303')
       issue_type_2 = JIRA::Resource::Issuetype.new(client)
       allow(issue_type_2).to receive(:id).and_return('50505')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=50505%2C30303').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeIds: [issue_type_2, issue_type_1]
       )
     end
 
-    it 'should query correct url when multiple `issuetypeIds` given as different types' do
+    it 'queries correct url when multiple `issuetypeIds` given as different types' do
       issue_type = JIRA::Resource::Issuetype.new(client)
       allow(issue_type).to receive(:id).and_return('30303')
 
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=10101%2C30303').and_return(response)
-      JIRA::Resource::Createmeta.all(
+      described_class.all(
         client,
         issuetypeIds: ['10101', issue_type]
       )