jira-ruby 2.3.0 → 3.2.0

data/spec/jira/resource/issue_spec.rb

@@ -7,25 +7,27 @@ describe JIRA::Resource::Issue do
   let(:client) do
     client = double(options: { rest_base_path: '/jira/rest/api/2' })
     allow(client).to receive(:Field).and_return(JIRA::Resource::FieldFactory.new(client))
-    allow(client).to receive(:cache).and_return(OpenStruct.new)
+    allow(client).to receive(:field_map_cache).and_return(nil)
     client
   end
 
   describe '#respond_to?' do
     describe 'when decorated by SimpleDelegator' do
-      before(:each) do
+      before do
         response = double
         allow(response).to receive(:body).and_return('{"key":"foo","id":"101"}')
-        allow(JIRA::Resource::Issue).to receive(:collection_path).and_return('/jira/rest/api/2/issue')
+        allow(described_class).to receive(:collection_path).and_return('/jira/rest/api/2/issue')
         allow(client).to receive(:get).with('/jira/rest/api/2/issue/101')
                                       .and_return(response)
 
-        issue = JIRA::Resource::Issue.find(client, 101)
+        issue = described_class.find(client, 101)
         @decorated = JIRAResourceDelegation.new(issue)
       end
+
       it 'responds to key' do
-        expect(@decorated.respond_to?(:key)).to eq(true)
+        expect(@decorated.respond_to?(:key)).to be(true)
       end
+
       it 'does not raise an error' do
         expect do
           @issue.respond_to?(:project)
@@ -34,123 +36,179 @@ describe JIRA::Resource::Issue do
     end
   end
 
-  it 'should find all issues' do
+  it 'finds all issues' do
     response = double
     empty_response = double
     issue = double
 
     allow(response).to receive(:body).and_return('{"issues":[{"id":"1","summary":"Bugs Everywhere"}]}')
-    expect(client).to receive(:get).with('/jira/rest/api/2/search?expand=transitions.fields&maxResults=1000&startAt=0')
+    expect(client).to receive(:get).with('/jira/rest/api/2/search/jql?expand=transitions.fields&maxResults=1000&startAt=0')
                                    .and_return(response)
     allow(empty_response).to receive(:body).and_return('{"issues":[]}')
-    expect(client).to receive(:get).with('/jira/rest/api/2/search?expand=transitions.fields&maxResults=1000&startAt=1')
+    expect(client).to receive(:get).with('/jira/rest/api/2/search/jql?expand=transitions.fields&maxResults=1000&startAt=1')
                                    .and_return(empty_response)
 
     expect(client).to receive(:Issue).and_return(issue)
     expect(issue).to receive(:build).with({ 'id' => '1', 'summary' => 'Bugs Everywhere' })
 
-    issues = JIRA::Resource::Issue.all(client)
+    described_class.all(client)
   end
 
-  it 'should find an issue by key or id' do
+  it 'finds an issue by key or id' do
     response = double
 
     allow(response).to receive(:body).and_return('{"key":"foo","id":"101"}')
-    allow(JIRA::Resource::Issue).to receive(:collection_path).and_return('/jira/rest/api/2/issue')
+    allow(described_class).to receive(:collection_path).and_return('/jira/rest/api/2/issue')
     expect(client).to receive(:get).with('/jira/rest/api/2/issue/foo')
                                    .and_return(response)
     expect(client).to receive(:get).with('/jira/rest/api/2/issue/101')
                                    .and_return(response)
 
-    issue_from_id = JIRA::Resource::Issue.find(client, 101)
-    issue_from_key = JIRA::Resource::Issue.find(client, 'foo')
+    issue_from_id = described_class.find(client, 101)
+    issue_from_key = described_class.find(client, 'foo')
 
     expect(issue_from_id.attrs).to eq(issue_from_key.attrs)
   end
 
-  it 'should search an issue with a jql query string' do
-    response = double
-    issue = double
+  describe '.jql' do
+    subject { described_class.jql(client, 'foo bar', args) }
 
-    allow(response).to receive(:body).and_return('{"issues": {"key":"foo"}}')
-    expect(client).to receive(:get).with('/jira/rest/api/2/search?jql=foo+bar')
-                                   .and_return(response)
-    expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
+    let(:args) { {} }
+    let(:issue) { double }
+    let(:response) { double }
+    let(:response_string) { '{"issues": {"key":"foo"}, "isLast": true}' }
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar')).to eq([''])
-  end
+    before do
+      allow(response).to receive(:body).and_return(response_string)
+      allow(client).to receive(:Issue).and_return(issue)
+      allow(issue).to receive(:build).with(%w[key foo]).and_return('')
+    end
 
-  it 'should search an issue with a jql query string and fields' do
-    response = double
-    issue = double
+    it 'searches an issue with a jql query string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/search/jql?jql=foo+bar')
+                                     .and_return(response)
+      expect(described_class.jql(client, 'foo bar')).to eq([''])
+    end
 
-    allow(response).to receive(:body).and_return('{"issues": {"key":"foo"}}')
-    expect(client).to receive(:get)
-      .with('/jira/rest/api/2/search?jql=foo+bar&fields=foo,bar')
-      .and_return(response)
-    expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
+    it 'passes thorugh the reconcileIssues parameter' do
+      expect(client).to receive(:get)
+        .with('/jira/rest/api/2/search/jql?jql=foo+bar&reconcileIssues=true')
+        .and_return(response)
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar', fields: %w[foo bar])).to eq([''])
-  end
+      expect(described_class.jql(client, 'foo bar', reconcile_issues: true)).to eq([''])
+    end
 
-  it 'should search an issue with a jql query string, start at, and maxResults' do
-    response = double
-    issue = double
+    it 'searches an issue with a jql query string and fields' do
+      expect(client).to receive(:get)
+        .with('/jira/rest/api/2/search/jql?jql=foo+bar&fields=foo,bar')
+        .and_return(response)
 
-    allow(response).to receive(:body).and_return('{"issues": {"key":"foo"}}')
-    expect(client).to receive(:get)
-      .with('/jira/rest/api/2/search?jql=foo+bar&startAt=1&maxResults=3')
-      .and_return(response)
-    expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
+      expect(described_class.jql(client, 'foo bar', fields: %w[foo bar])).to eq([''])
+    end
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar', start_at: 1, max_results: 3)).to eq([''])
-  end
+    context 'when maxResults is provided' do
+      let(:args) { { max_results: } }
 
-  it 'should search an issue with a jql query string and maxResults equals zero and should return the count of tickets' do
-    response = double
-    issue = double
+      context 'with non-zero' do
+        let(:max_results) { 3 }
 
-    allow(response).to receive(:body).and_return('{"total": 1, "issues": []}')
-    expect(client).to receive(:get)
-      .with('/jira/rest/api/2/search?jql=foo+bar&maxResults=0')
-      .and_return(response)
+        it 'searches an issue with a jql query string and maxResults' do
+          expect(client).to receive(:get)
+            .with('/jira/rest/api/2/search/jql?jql=foo+bar&maxResults=3')
+            .and_return(response)
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar', max_results: 0)).to eq(1)
-  end
+          expect(subject).to eq([''])
+        end
+      end
 
-  it 'should search an issue with a jql query string and string expand' do
-    response = double
-    issue = double
+      context 'with zero' do
+        let(:response_string) { '{"total": 1, "issues": []}' }
+        let(:max_results) { 0 }
 
-    allow(response).to receive(:body).and_return('{"issues": {"key":"foo"}}')
-    expect(client).to receive(:get)
-      .with('/jira/rest/api/2/search?jql=foo+bar&expand=transitions')
-      .and_return(response)
-    expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
+        it 'searches an issue with a jql query string and should return the count of tickets' do
+          expect(client).to receive(:get)
+            .with('/jira/rest/api/2/search/jql?jql=foo+bar&maxResults=0')
+            .and_return(response)
+
+          expect(subject).to eq(1)
+        end
+      end
+    end
+
+    it 'searches an issue with a jql query string and string expand' do
+      expect(client).to receive(:get)
+        .with('/jira/rest/api/2/search/jql?jql=foo+bar&expand=transitions')
+        .and_return(response)
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar', expand: 'transitions')).to eq([''])
+      expect(described_class.jql(client, 'foo bar', expand: 'transitions')).to eq([''])
+    end
+
+    it 'searches an issue with a jql query string and array expand' do
+      expect(client).to receive(:get)
+        .with('/jira/rest/api/2/search/jql?jql=foo+bar&expand=transitions')
+        .and_return(response)
+
+      expect(described_class.jql(client, 'foo bar', expand: %w[transitions])).to eq([''])
+    end
+
+    context 'when pagination is required' do
+      let(:response_string) { '{"issues": [{"key":"foo"}], "isLast": false, "nextPageToken": "abc"}' }
+      let(:second_response_string) { '{"issues": [{"key":"bar"}], "isLast": true}' }
+
+      before do
+        allow(issue).to receive(:build).with({ 'key' => 'foo' }).and_return('1')
+        allow(issue).to receive(:build).with({ 'key' => 'bar' }).and_return('2')
+      end
+
+      it 'makes multiple requests' do
+        expect(client).to receive(:get)
+          .with('/jira/rest/api/2/search/jql?jql=foo+bar')
+          .and_return(response)
+        expect(client).to receive(:get)
+          .with('/jira/rest/api/2/search/jql?jql=foo+bar&nextPageToken=abc')
+          .and_return(double(body: second_response_string))
+
+        expect(subject).to eq(%w[1 2])
+      end
+    end
   end
 
-  it 'should search an issue with a jql query string and array expand' do
-    response = double
-    issue = double
+  describe '.jql_paged' do
+    let(:issue) { double }
+    let(:response) { double }
 
-    allow(response).to receive(:body).and_return('{"issues": {"key":"foo"}}')
-    expect(client).to receive(:get)
-      .with('/jira/rest/api/2/search?jql=foo+bar&expand=transitions')
-      .and_return(response)
-    expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
+    before do
+      allow(response).to receive(:body).and_return(response_string)
+      allow(client).to receive(:Issue).and_return(issue)
+      allow(issue).to receive(:build).with({ 'key' => 'foo' }).and_return('1')
+      allow(issue).to receive(:build).with({ 'key' => 'bar' }).and_return('2')
+      allow(issue).to receive(:build).with({ 'key' => 'baz' }).and_return('3')
+    end
+
+    context 'without next_page_token (first page)' do
+      subject { described_class.jql_paged(client, 'foo bar', page_size: 2) }
+
+      before { expect(client).to receive(:get).with('/jira/rest/api/2/search/jql?jql=foo+bar').and_return(response) }
+
+      let(:response) { double }
+      let(:response_string) { '{"issues": [{"key":"foo"},{"key":"bar"}], "isLast": false, "nextPageToken": "abc"}' }
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar', expand: %w[transitions])).to eq([''])
+      it { is_expected.to eq(issues: %w[1 2], next_page_token: 'abc', total: nil) }
+    end
+
+    context 'with next_page_token' do
+      subject { described_class.jql_paged(client, 'foo bar', page_size: 2, next_page_token: 'abc') }
+
+      let(:response_string) { '{"issues": [{"key":"baz"}], "isLast": true}' }
+
+      before { expect(client).to receive(:get).with('/jira/rest/api/2/search/jql?jql=foo+bar&nextPageToken=abc').and_return(double(body: response_string)) }
+
+      it { is_expected.to eq(issues: %w[3], next_page_token: nil, total: nil) }
+    end
   end
 
-  it 'should return meta data available for editing an issue' do
-    subject = JIRA::Resource::Issue.new(client, attrs: { 'fields' => { 'key' => 'TST=123' } })
+  it 'returns meta data available for editing an issue' do
+    subject = described_class.new(client, attrs: { 'fields' => { 'key' => 'TST=123' } })
     response = double
 
     allow(response).to receive(:body).and_return(
@@ -164,29 +222,31 @@ describe JIRA::Resource::Issue do
   end
 
   it 'provides direct accessors to the fields' do
-    subject = JIRA::Resource::Issue.new(client, attrs: { 'fields' => { 'foo' => 'bar' } })
+    subject = described_class.new(client, attrs: { 'fields' => { 'foo' => 'bar' } })
     expect(subject).to respond_to(:foo)
     expect(subject.foo).to eq('bar')
   end
 
   describe 'relationships' do
     subject do
-      JIRA::Resource::Issue.new(client, attrs: {
-                                  'id' => '123',
-                                  'fields' => {
-                                    'reporter' => { 'foo' => 'bar' },
-                                    'assignee'    => { 'foo' => 'bar' },
-                                    'project'     => { 'foo' => 'bar' },
-                                    'priority'    => { 'foo' => 'bar' },
-                                    'issuetype'   => { 'foo' => 'bar' },
-                                    'status'      => { 'foo' => 'bar' },
-                                    'components'  => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
-                                    'versions'    => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
-                                    'comment'     => { 'comments' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }] },
-                                    'attachment'  => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
-                                    'worklog'     => { 'worklogs' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }] }
-                                  }
-                                })
+      described_class.new(client, attrs: {
+                            'id' => '123',
+                            'fields' => {
+                              'reporter' => { 'foo' => 'bar' },
+                              'assignee' => { 'foo' => 'bar' },
+                              'project' => { 'foo' => 'bar' },
+                              'priority' => { 'foo' => 'bar' },
+                              'issuetype' => { 'foo' => 'bar' },
+                              'status' => { 'foo' => 'bar' },
+                              'resolution' => { 'foo' => 'bar' },
+                              'components' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
+                              'versions' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
+                              'comment' => { 'comments' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }] },
+                              'attachment' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
+                              'worklog' => { 'worklogs' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }] }
+                            },
+                            'properties' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }]
+                          })
     end
 
     it 'has the correct relationships' do
@@ -208,6 +268,9 @@ describe JIRA::Resource::Issue do
       expect(subject).to have_one(:status, JIRA::Resource::Status)
       expect(subject.status.foo).to eq('bar')
 
+      expect(subject).to have_one(:resolution, JIRA::Resource::Resolution)
+      expect(subject.resolution.foo).to eq('bar')
+
       expect(subject).to have_many(:components, JIRA::Resource::Component)
       expect(subject.components.length).to eq(2)
 
@@ -222,6 +285,9 @@ describe JIRA::Resource::Issue do
 
       expect(subject).to have_many(:worklogs, JIRA::Resource::Worklog)
       expect(subject.worklogs.length).to eq(2)
+
+      expect(subject).to have_many(:properties, JIRA::Resource::Properties)
+      expect(subject.properties.length).to eq(2)
     end
   end
 end

data/spec/jira/resource/jira_picker_suggestions_issue_spec.rb

@@ -5,9 +5,9 @@ describe JIRA::Resource::IssuePickerSuggestionsIssue do
 
   describe 'relationships' do
     subject do
-      JIRA::Resource::IssuePickerSuggestionsIssue.new(client, attrs: {
-        'issues' => [{ 'id' => '1'}, { 'id' => '2' }]
-      })
+      described_class.new(client, attrs: {
+                            'issues' => [{ 'id' => '1' }, { 'id' => '2' }]
+                          })
     end
 
     it 'has the correct relationships' do

data/spec/jira/resource/project_factory_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
 describe JIRA::Resource::ProjectFactory do
+  subject       { described_class.new(client) }
+
   let(:client)  { double }
-  subject       { JIRA::Resource::ProjectFactory.new(client) }
 
   it 'initializes correctly' do
-    expect(subject.class).to eq(JIRA::Resource::ProjectFactory)
+    expect(subject.class).to eq(described_class)
     expect(subject.client).to eq(client)
   end
 end

data/spec/jira/resource/project_spec.rb

@@ -9,11 +9,11 @@ describe JIRA::Resource::Project do
 
   describe 'relationships' do
     subject do
-      JIRA::Resource::Project.new(client, attrs: {
-                                    'lead'        => { 'foo' => 'bar' },
-                                    'issueTypes'  => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
-                                    'versions'    => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }]
-                                  })
+      described_class.new(client, attrs: {
+                            'lead' => { 'foo' => 'bar' },
+                            'issueTypes' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
+                            'versions' => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }]
+                          })
     end
 
     it 'has the correct relationships' do
@@ -30,9 +30,9 @@ describe JIRA::Resource::Project do
 
   describe 'issues' do
     subject do
-      JIRA::Resource::Project.new(client, attrs: {
-                                    'key'         => 'test'
-                                  })
+      described_class.new(client, attrs: {
+                            'key' => 'test'
+                          })
     end
 
     it 'returns issues' do
@@ -42,7 +42,7 @@ describe JIRA::Resource::Project do
       issue_factory = double('issue factory')
 
       expect(client).to receive(:get)
-        .with('/jira/rest/api/2/search?jql=project%3D%22test%22')
+        .with('/jira/rest/api/2/search/jql?jql=project%3D%22test%22')
         .and_return(response)
       expect(client).to receive(:Issue).and_return(issue_factory)
       expect(issue_factory).to receive(:build)
@@ -58,7 +58,7 @@ describe JIRA::Resource::Project do
         issue_factory = double('issue factory')
 
         expect(client).to receive(:get)
-          .with('/jira/rest/api/2/search?jql=project%3D%22test%22&expand=changelog&startAt=1&maxResults=100')
+          .with('/jira/rest/api/2/search/jql?jql=project%3D%22test%22&expand=changelog&startAt=1&maxResults=100')
           .and_return(response)
         expect(client).to receive(:Issue).and_return(issue_factory)
         expect(issue_factory).to receive(:build)
@@ -69,12 +69,12 @@ describe JIRA::Resource::Project do
   end
 
   describe 'users' do
-    let(:project) { JIRA::Resource::Project.new(client, attrs: { 'key' => project_key }) }
+    let(:project) { described_class.new(client, attrs: { 'key' => project_key }) }
     let(:project_key) { SecureRandom.hex }
     let(:response) { double('response', body: '[{}]') }
 
-    context 'pagination' do
-      before(:each) do
+    context 'with pagination' do
+      before do
         user_factory = double('user factory')
         expect(client).to receive(:User).and_return(user_factory)
         expect(user_factory).to receive(:build).with(any_args)
@@ -95,7 +95,7 @@ describe JIRA::Resource::Project do
           .with("/jira/rest/api/2/user/assignable/search?project=#{project_key}&startAt=#{start_at}")
           .and_return(response)
 
-        project.users(start_at: start_at)
+        project.users(start_at:)
       end
 
       it 'accepts max_results option' do
@@ -105,7 +105,7 @@ describe JIRA::Resource::Project do
           .with("/jira/rest/api/2/user/assignable/search?project=#{project_key}&maxResults=#{max_results}")
           .and_return(response)
 
-        project.users(max_results: max_results)
+        project.users(max_results:)
       end
 
       it 'accepts start_at and max_results options' do
@@ -116,7 +116,7 @@ describe JIRA::Resource::Project do
           .with("/jira/rest/api/2/user/assignable/search?project=#{project_key}&startAt=#{start_at}&maxResults=#{max_results}")
           .and_return(response)
 
-        project.users(start_at: start_at, max_results: max_results)
+        project.users(start_at:, max_results:)
       end
     end
   end

data/spec/jira/resource/sprint_spec.rb

@@ -2,19 +2,32 @@ require 'spec_helper'
 
 describe JIRA::Resource::Sprint do
   let(:client) do
-    client = double(options: { site: 'https://foo.bar.com', context_path: '/jira' })
+    client = double(options: { rest_base_path: '/jira/rest/api/2', context_path: '/jira' })
     allow(client).to receive(:Sprint).and_return(JIRA::Resource::SprintFactory.new(client))
     client
   end
   let(:sprint) { described_class.new(client) }
-  let(:agile_sprint_path) { "#{sprint.client.options[:context_path]}/rest/agile/1.0/sprint/#{sprint.id}" }
+  let(:agile_sprint_path) { "/jira/rest/agile/1.0/sprint/#{sprint.id}" }
+  let(:response) { double }
+
+  describe 'get_sprint_details' do
+    let(:sprint) { described_class.find(client, '1') }
+
+    it 'check each of the date attributes' do
+      allow(client).to receive(:get).and_return(double(body: get_mock_response('sprint/1.json')))
+
+      expect(sprint.start_date).to eq Date.parse('2024-01-01T03:20:00.000Z')
+      expect(sprint.end_date).to eq Date.parse('2024-01-15T03:20:00.000Z')
+      expect(sprint.complete_date).to eq Date.parse('2024-01-16T03:48:00.000Z')
+    end
+  end
 
   describe '::find' do
     let(:response) { double('Response', body: '{"some_detail":"some detail"}') }
 
     it 'fetches the sprint from JIRA' do
       expect(client).to receive(:get).with('/jira/rest/agile/1.0/sprint/111').and_return(response)
-      expect(JIRA::Resource::Sprint.find(client, '111')).to be_a(JIRA::Resource::Sprint)
+      expect(described_class.find(client, '111')).to be_a(described_class)
     end
   end
 
@@ -30,7 +43,9 @@ describe JIRA::Resource::Sprint do
         let(:given_attrs) { { start_date: '2016-06-10' } }
 
         it 'calls save on the super class with the given attributes & agile url' do
-          expect_any_instance_of(JIRA::Base).to receive(:save).with(given_attrs, agile_sprint_path)
+          mock_response = double('response', body: '{"id":"123"}')
+
+          expect(client).to receive(:post).with(agile_sprint_path, given_attrs.to_json).and_return(mock_response)
 
           sprint.save(given_attrs)
         end
@@ -38,7 +53,9 @@ describe JIRA::Resource::Sprint do
 
       context 'when attributes are not specified' do
         it 'calls save on the super class with the instance attributes & agile url' do
-          expect_any_instance_of(JIRA::Base).to receive(:save).with(instance_attrs, agile_sprint_path)
+          mock_response = double('response', body: '{"id":"123"}')
+
+          expect(client).to receive(:post).with(agile_sprint_path, instance_attrs.to_json).and_return(mock_response)
 
           sprint.save
         end
@@ -46,7 +63,9 @@ describe JIRA::Resource::Sprint do
 
       context 'when providing the path argument' do
         it 'ignores it' do
-          expect_any_instance_of(JIRA::Base).to receive(:save).with(instance_attrs, agile_sprint_path)
+          mock_response = double('response', body: '{"id":"123"}')
+
+          expect(client).to receive(:post).with(agile_sprint_path, instance_attrs.to_json).and_return(mock_response)
 
           sprint.save({}, 'mavenlink.com')
         end
@@ -64,7 +83,9 @@ describe JIRA::Resource::Sprint do
         let(:given_attrs) { { start_date: '2016-06-10' } }
 
         it 'calls save! on the super class with the given attributes & agile url' do
-          expect_any_instance_of(JIRA::Base).to receive(:save!).with(given_attrs, agile_sprint_path)
+          mock_response = double('response', body: '{"id":"123"}')
+
+          expect(client).to receive(:post).with(agile_sprint_path, given_attrs.to_json).and_return(mock_response)
 
           sprint.save!(given_attrs)
         end
@@ -72,7 +93,9 @@ describe JIRA::Resource::Sprint do
 
       context 'when attributes are not specified' do
         it 'calls save! on the super class with the instance attributes & agile url' do
-          expect_any_instance_of(JIRA::Base).to receive(:save!).with(instance_attrs, agile_sprint_path)
+          mock_response = double('response', body: '{"id":"123"}')
+
+          expect(client).to receive(:post).with(agile_sprint_path, instance_attrs.to_json).and_return(mock_response)
 
           sprint.save!
         end
@@ -80,11 +103,67 @@ describe JIRA::Resource::Sprint do
 
       context 'when providing the path argument' do
         it 'ignores it' do
-          expect_any_instance_of(JIRA::Base).to receive(:save!).with(instance_attrs, agile_sprint_path)
+          mock_response = double('response', body: '{"id":"123"}')
+
+          expect(client).to receive(:post).with(agile_sprint_path, instance_attrs.to_json).and_return(mock_response)
 
           sprint.save!({}, 'mavenlink.com')
         end
       end
     end
+
+    context 'when an issue exists' do
+      let(:issue_id) { 1001 }
+      let(:post_issue_path) do
+        described_class.agile_path(client, sprint.id)
+        '/jira/rest/agile/1.0/sprint//issue'
+      end
+      let(:issue) do
+        issue = double
+        allow(issue).to receive(:id).and_return(issue_id)
+        issue
+      end
+      let(:post_issue_input) do
+        { issues: [issue.id] }
+      end
+
+      describe '#add_issue' do
+        context 'when an issue is passed' do
+          it 'posts with the issue id' do
+            expect(client).to receive(:post).with(post_issue_path, post_issue_input.to_json)
+
+            expect(sprint.add_issue(issue)).to eq(issue)
+          end
+        end
+      end
+    end
+
+    context 'when multiple issues exist' do
+      let(:issue_ids) { [1001, 1012] }
+      let(:post_issue_path) do
+        described_class.agile_path(client, sprint.id)
+        '/jira/rest/agile/1.0/sprint//issue'
+      end
+      let(:issues) do
+        issue_ids.map do |issue_id|
+          issue = double
+          allow(issue).to receive(:id).and_return(issue_id)
+          issue
+        end
+      end
+      let(:post_issue_input) do
+        { issues: issue_ids }
+      end
+
+      describe '#add_issues' do
+        context 'when an issue is passed' do
+          it 'posts with the issue id' do
+            expect(client).to receive(:post).with(post_issue_path, post_issue_input.to_json)
+
+            expect(sprint.add_issues(issues)).to eq(issues)
+          end
+        end
+      end
+    end
   end
 end

data/spec/jira/resource/status_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Status do
+  let(:client) do
+    client = double(options: { rest_base_path: '/jira/rest/api/2' })
+    allow(client).to receive(:Field).and_return(JIRA::Resource::FieldFactory.new(client))
+    allow(client).to receive(:field_map_cache).and_return(nil)
+    client
+  end
+
+  describe '#status_category' do
+    subject do
+      described_class.new(client, attrs: JSON.parse(File.read('spec/mock_responses/status/1.json')))
+    end
+
+    it 'has a status_category relationship' do
+      expect(subject).to have_one(:status_category, JIRA::Resource::StatusCategory)
+      expect(subject.status_category.name).to eq('To Do')
+    end
+  end
+end