jira-ruby 1.1.3 → 2.3.0

data/spec/jira/resource/issue_spec.rb

@@ -1,153 +1,157 @@
 require 'spec_helper'
 
 describe JIRA::Resource::Issue do
-
   class JIRAResourceDelegation < SimpleDelegator # :nodoc:
   end
 
   let(:client) do
-    client = double(options: {rest_base_path: '/jira/rest/api/2'}  )
+    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)
     client
   end
 
-  describe "#respond_to?" do
-    describe "when decorated by SimpleDelegator" do
+  describe '#respond_to?' do
+    describe 'when decorated by SimpleDelegator' do
       before(:each) do
-        response = double()
+        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(client).to receive(:get).with('/jira/rest/api/2/issue/101').
-          and_return(response)
+        allow(client).to receive(:get).with('/jira/rest/api/2/issue/101')
+                                      .and_return(response)
 
-        issue = JIRA::Resource::Issue.find(client,101)
-        @decorated = JIRAResourceDelegation.new( issue )
+        issue = JIRA::Resource::Issue.find(client, 101)
+        @decorated = JIRAResourceDelegation.new(issue)
       end
-      it "responds to key" do
+      it 'responds to key' do
         expect(@decorated.respond_to?(:key)).to eq(true)
       end
-      it "does not raise an error" do
-        expect {
+      it 'does not raise an error' do
+        expect do
           @issue.respond_to?(:project)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
   end
 
-  it "should find all issues" do
-    response = double()
-    issue = double()
+  it 'should find 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').
-      and_return(response)
+    expect(client).to receive(:get).with('/jira/rest/api/2/search?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')
+                                   .and_return(empty_response)
+
     expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with({"id"=>"1","summary"=>"Bugs Everywhere"})
+    expect(issue).to receive(:build).with({ 'id' => '1', 'summary' => 'Bugs Everywhere' })
 
     issues = JIRA::Resource::Issue.all(client)
   end
 
-  it "should find an issue by key or id" do
-    response = double()
+  it 'should find 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')
-    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)
+    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 = JIRA::Resource::Issue.find(client, 101)
+    issue_from_key = JIRA::Resource::Issue.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()
+  it 'should search an issue with a jql query string' do
+    response = double
+    issue = 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').
-      and_return(response)
+    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(["key", "foo"]).and_return('')
+    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
 
-    expect(JIRA::Resource::Issue.jql(client,'foo bar')).to eq([''])
+    expect(JIRA::Resource::Issue.jql(client, 'foo bar')).to eq([''])
   end
 
-  it "should search an issue with a jql query string and fields" do
-    response = double()
-    issue = double()
+  it 'should search an issue with a jql query string and fields' do
+    response = double
+    issue = 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&fields=foo,bar')
       .and_return(response)
     expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(["key", "foo"]).and_return('')
+    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
 
-    expect(JIRA::Resource::Issue.jql(client, 'foo bar', fields: ['foo','bar'])).to eq([''])
+    expect(JIRA::Resource::Issue.jql(client, 'foo bar', fields: %w[foo bar])).to eq([''])
   end
 
-  it "should search an issue with a jql query string, start at, and maxResults" do
-    response = double()
-    issue = double()
+  it 'should search an issue with a jql query string, start at, and maxResults' do
+    response = double
+    issue = 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&startAt=1&maxResults=3')
       .and_return(response)
     expect(client).to receive(:Issue).and_return(issue)
-    expect(issue).to receive(:build).with(["key", "foo"]).and_return('')
+    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
 
-    expect(JIRA::Resource::Issue.jql(client,'foo bar', start_at: 1, max_results: 3)).to eq([''])
+    expect(JIRA::Resource::Issue.jql(client, 'foo bar', start_at: 1, max_results: 3)).to eq([''])
   end
 
-  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()
+  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
 
     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)
 
-    expect(JIRA::Resource::Issue.jql(client,'foo bar', max_results: 0)).to eq(1)
+    expect(JIRA::Resource::Issue.jql(client, 'foo bar', max_results: 0)).to eq(1)
   end
 
-  it "should search an issue with a jql query string and string expand" do
-    response = double()
-    issue = double()
+  it 'should search an issue with a jql query string and string expand' do
+    response = double
+    issue = 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(["key", "foo"]).and_return('')
+    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
 
-    expect(JIRA::Resource::Issue.jql(client,'foo bar', expand: 'transitions')).to eq([''])
+    expect(JIRA::Resource::Issue.jql(client, 'foo bar', expand: 'transitions')).to eq([''])
   end
 
-  it "should search an issue with a jql query string and array expand" do
-    response = double()
-    issue = double()
+  it 'should search an issue with a jql query string and array expand' do
+    response = double
+    issue = 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(["key", "foo"]).and_return('')
+    expect(issue).to receive(:build).with(%w[key foo]).and_return('')
 
-    expect(JIRA::Resource::Issue.jql(client,'foo bar', expand: %w(transitions))).to eq([''])
+    expect(JIRA::Resource::Issue.jql(client, 'foo bar', expand: %w[transitions])).to eq([''])
   end
 
   it 'should return meta data available for editing an issue' do
-    subject = JIRA::Resource::Issue.new(client, :attrs => {'fields' => {'key' =>'TST=123'}})
-    response = double()
+    subject = JIRA::Resource::Issue.new(client, attrs: { 'fields' => { 'key' => 'TST=123' } })
+    response = double
 
     allow(response).to receive(:body).and_return(
       '{"fields":{"summary":{"required":true,"name":"Summary","operations":["set"]}}}'
@@ -156,37 +160,36 @@ describe JIRA::Resource::Issue do
       .with('/jira/rest/api/2/issue/TST=123/editmeta')
       .and_return(response)
 
-    expect(subject.editmeta).to eq({'summary' => {'required' => true, 'name' => 'Summary', 'operations' => ['set']}})
+    expect(subject.editmeta).to eq('summary' => { 'required' => true, 'name' => 'Summary', 'operations' => ['set'] })
   end
 
-
-  it "provides direct accessors to the fields" do
-    subject = JIRA::Resource::Issue.new(client, :attrs => {'fields' => {'foo' =>'bar'}})
+  it 'provides direct accessors to the fields' do
+    subject = JIRA::Resource::Issue.new(client, attrs: { 'fields' => { 'foo' => 'bar' } })
     expect(subject).to respond_to(:foo)
     expect(subject.foo).to eq('bar')
   end
 
-  describe "relationships" do
-    subject {
-      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'}]},
-        }
-      })
-    }
-
-    it "has the correct relationships" do
+  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' }] }
+                                  }
+                                })
+    end
+
+    it 'has the correct relationships' do
       expect(subject).to have_one(:reporter, JIRA::Resource::User)
       expect(subject.reporter.foo).to eq('bar')
 

data/spec/jira/resource/issuelink_spec.rb

@@ -11,4 +11,4 @@
 #       )
 #     }
 #   end
-# end
+# end

data/spec/jira/resource/jira_picker_suggestions_issue_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe JIRA::Resource::IssuePickerSuggestionsIssue do
+  let(:client) { double('client') }
+
+  describe 'relationships' do
+    subject do
+      JIRA::Resource::IssuePickerSuggestionsIssue.new(client, attrs: {
+        'issues' => [{ 'id' => '1'}, { 'id' => '2' }]
+      })
+    end
+
+    it 'has the correct relationships' do
+      expect(subject).to have_many(:issues, JIRA::Resource::SuggestedIssue)
+      expect(subject.issues.length).to eq(2)
+    end
+  end
+end

data/spec/jira/resource/project_factory_spec.rb

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

data/spec/jira/resource/project_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
 describe JIRA::Resource::Project do
+  let(:client) do
+    double('client', options: {
+             rest_base_path: '/jira/rest/api/2'
+           })
+  end
+
+  describe 'relationships' do
+    subject do
+      JIRA::Resource::Project.new(client, attrs: {
+                                    'lead'        => { 'foo' => 'bar' },
+                                    'issueTypes'  => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }],
+                                    'versions'    => [{ 'foo' => 'bar' }, { 'baz' => 'flum' }]
+                                  })
+    end
 
-  let(:client) { double("client", :options => {
-                          :rest_base_path => '/jira/rest/api/2'
-                        })
-  }
-
-  describe "relationships" do
-    subject {
-      JIRA::Resource::Project.new(client, :attrs => {
-          'lead'        => {'foo' => 'bar'},
-          'issueTypes'  => [{'foo' =>'bar'},{'baz' => 'flum'}],
-          'versions'    => [{'foo' =>'bar'},{'baz' => 'flum'}],
-      })
-    }
-
-    it "has the correct relationships" do
+    it 'has the correct relationships' do
       expect(subject).to have_one(:lead, JIRA::Resource::User)
       expect(subject.lead.foo).to eq('bar')
 
@@ -28,42 +28,95 @@ describe JIRA::Resource::Project do
     end
   end
 
-  describe "issues" do
-    subject {
-      JIRA::Resource::Project.new(client, :attrs => {
-          'key'         => 'test'
-        })
-    }
+  describe 'issues' do
+    subject do
+      JIRA::Resource::Project.new(client, attrs: {
+                                    'key'         => 'test'
+                                  })
+    end
 
-    it "returns issues" do
+    it 'returns issues' do
       response_body = '{"expand":"schema,names","startAt":0,"maxResults":1,"total":1,"issues":[{"expand":"editmeta,renderedFields,transitions,changelog,operations","id":"53062","self":"/rest/api/2/issue/53062","key":"test key","fields":{"summary":"test summary"}}]}'
-      response = double("response",
-        :body => response_body)
-      issue_factory = double("issue factory")
+      response = double('response',
+                        body: response_body)
+      issue_factory = double('issue factory')
 
       expect(client).to receive(:get)
         .with('/jira/rest/api/2/search?jql=project%3D%22test%22')
         .and_return(response)
       expect(client).to receive(:Issue).and_return(issue_factory)
       expect(issue_factory).to receive(:build)
-        .with(JSON.parse(response_body)["issues"][0])
+        .with(JSON.parse(response_body)['issues'][0])
       subject.issues
     end
 
-    context "with changelog" do
-      it "returns issues" do
+    context 'with changelog' do
+      it 'returns issues' do
         response_body = '{"expand":"schema,names","startAt":0,"maxResults":1,"total":1,"issues":[{"expand":"editmeta,renderedFields,transitions,changelog,operations","id":"53062","self":"/rest/api/2/issue/53062","key":"test key","fields":{"summary":"test summary"},"changelog":{}}]}'
-        response = double("response",
-          :body => response_body)
-        issue_factory = double("issue factory")
+        response = double('response',
+                          body: response_body)
+        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')
           .and_return(response)
         expect(client).to receive(:Issue).and_return(issue_factory)
         expect(issue_factory).to receive(:build)
-          .with(JSON.parse(response_body)["issues"][0])
-        subject.issues({expand:'changelog', startAt:1, maxResults:100})
+          .with(JSON.parse(response_body)['issues'][0])
+        subject.issues(expand: 'changelog', startAt: 1, maxResults: 100)
+      end
+    end
+  end
+
+  describe 'users' do
+    let(:project) { JIRA::Resource::Project.new(client, attrs: { 'key' => project_key }) }
+    let(:project_key) { SecureRandom.hex }
+    let(:response) { double('response', body: '[{}]') }
+
+    context 'pagination' do
+      before(:each) do
+        user_factory = double('user factory')
+        expect(client).to receive(:User).and_return(user_factory)
+        expect(user_factory).to receive(:build).with(any_args)
+      end
+
+      it 'doesn\'t use pagination parameters by default' do
+        expect(client).to receive(:get)
+          .with("/jira/rest/api/2/user/assignable/search?project=#{project_key}")
+          .and_return(response)
+
+        project.users
+      end
+
+      it 'accepts start_at option' do
+        start_at = rand(1000)
+
+        expect(client).to receive(:get)
+          .with("/jira/rest/api/2/user/assignable/search?project=#{project_key}&startAt=#{start_at}")
+          .and_return(response)
+
+        project.users(start_at: start_at)
+      end
+
+      it 'accepts max_results option' do
+        max_results = rand(1000)
+
+        expect(client).to receive(:get)
+          .with("/jira/rest/api/2/user/assignable/search?project=#{project_key}&maxResults=#{max_results}")
+          .and_return(response)
+
+        project.users(max_results: max_results)
+      end
+
+      it 'accepts start_at and max_results options' do
+        start_at = rand(1000)
+        max_results = rand(1000)
+
+        expect(client).to receive(:get)
+          .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)
       end
     end
   end

data/spec/jira/resource/sprint_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Sprint do
+  let(:client) do
+    client = double(options: { site: 'https://foo.bar.com', 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}" }
+
+  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)
+    end
+  end
+
+  describe 'peristence' do
+    describe '#save' do
+      let(:instance_attrs) { { start_date: '2016-06-01' } }
+
+      before do
+        sprint.attrs = instance_attrs
+      end
+
+      context 'when attributes are specified' 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)
+
+          sprint.save(given_attrs)
+        end
+      end
+
+      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)
+
+          sprint.save
+        end
+      end
+
+      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)
+
+          sprint.save({}, 'mavenlink.com')
+        end
+      end
+    end
+
+    describe '#save!' do
+      let(:instance_attrs) { { start_date: '2016-06-01' } }
+
+      before do
+        sprint.attrs = instance_attrs
+      end
+
+      context 'when attributes are specified' 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)
+
+          sprint.save!(given_attrs)
+        end
+      end
+
+      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)
+
+          sprint.save!
+        end
+      end
+
+      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)
+
+          sprint.save!({}, 'mavenlink.com')
+        end
+      end
+    end
+  end
+end

data/spec/jira/resource/user_factory_spec.rb

@@ -1,19 +1,18 @@
 require 'spec_helper'
 
 describe JIRA::Resource::UserFactory do
-
-  let(:client) {
+  let(:client) do
     instance_double('Client', options: { rest_base_path: '/jira/rest/api/2' })
-  }
+  end
 
   subject { JIRA::Resource::UserFactory.new(client) }
 
-  describe "#myself" do
-    let(:response) {
+  describe '#myself' do
+    let(:response) do
       instance_double(
         'Response', body: get_mock_response('user_username=admin.json')
       )
-    }
+    end
 
     let(:user) { subject.myself }
 
@@ -23,11 +22,10 @@ describe JIRA::Resource::UserFactory do
       ).and_return(response)
     end
 
-    it "returns a JIRA::Resource::User with correct attrs" do
+    it 'returns a JIRA::Resource::User with correct attrs' do
       expect(user).to be_a(JIRA::Resource::User)
       expect(user.name).to eq('admin')
       expect(user.emailAddress).to eq('admin@example.com')
     end
   end
-
 end

data/spec/jira/resource/worklog_spec.rb

@@ -1,18 +1,17 @@
 require 'spec_helper'
 
 describe JIRA::Resource::Worklog do
+  let(:client) { double }
 
-  let(:client) { double() }
-
-  describe "relationships" do
-    subject {
-      JIRA::Resource::Worklog.new(client, :issue_id => '99999', :attrs => {
-        'author' => {'foo' => 'bar'},
-        'updateAuthor' => {'foo' => 'bar'}
-      })
-    }
+  describe 'relationships' do
+    subject do
+      JIRA::Resource::Worklog.new(client, issue_id: '99999', attrs: {
+                                    'author' => { 'foo' => 'bar' },
+                                    'updateAuthor' => { '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')
 
@@ -20,5 +19,4 @@ describe JIRA::Resource::Worklog do
       expect(subject.update_author.foo).to eq('bar')
     end
   end
-
 end