jira-ruby 2.1.3

data/spec/jira/resource/field_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Field do
+  let(:cache) { OpenStruct.new }
+
+  let(:client) do
+    client = double(options: { rest_base_path: '/jira/rest/api/2' })
+    field = JIRA::Resource::FieldFactory.new(client)
+    allow(client).to receive(:Field).and_return(field)
+    allow(client).to receive(:cache).and_return(cache)
+    # info about all fields on the client
+    allow(client.Field).to receive(:all).and_return([
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'customfield_10666', 'name' => 'Priority', 'custom' => true, 'orderable' => true, 'navigable' => true, 'searchable' => true, 'clauseNames' => ['cf[10666]', 'Priority'], 'schema' => { 'type' => 'string', 'custom' => 'com.atlassian.jira.plugin.system.customfieldtypes:select', 'customId' => 10_666 } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'issuekey',          'name' => 'Key',        'custom' => false, 'orderable' => false, 'navigable' => true, 'searchable' => false, 'clauseNames' => %w[id issue issuekey key] }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'priority',          'name' => 'Priority',   'custom' => false, 'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => ['priority'],                     'schema' => { 'type' => 'priority',  'system' => 'priority' } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'summary',           'name' => 'Summary',    'custom' => false, 'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => ['summary'],                      'schema' => { 'type' => 'string',    'system' => 'summary' } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'issuetype',         'name' => 'Issue Type', 'custom' => false, 'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => %w[issuetype type], 'schema' => { 'type' => 'issuetype', 'system' => 'issuetype' } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'customfield_10111', 'name' => 'SingleWord', 'custom' => true,  'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => ['cf[10111]', 'SingleWord'],       'schema' => { 'type' => 'string',    'custom' => 'com.atlassian.jira.plugin.system.customfieldtypes:select', 'customId' => 10_111 } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'customfield_10222', 'name' => 'Multi Word', 'custom' => true,  'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => ['cf[10222]', 'Multi Word'],       'schema' => { 'type' => 'string',    'custom' => 'com.atlassian.jira.plugin.system.customfieldtypes:select', 'customId' => 10_222 } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'customfield_10333', 'name' => 'Why/N@t',    'custom' => true,  'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => ['cf[10333]', 'Why/N@t'],          'schema' => { 'type' => 'string',    'custom' => 'com.atlassian.jira.plugin.system.customfieldtypes:select', 'customId' => 10_333 } }),
+                                                      JIRA::Resource::Field.new(client, attrs: { 'id' => 'customfield_10444', 'name' => 'SingleWord', 'custom' => true,  'orderable' => true,  'navigable' => true, 'searchable' => true,  'clauseNames' => ['cf[10444]', 'SingleWord'],       'schema' => { 'type' => 'string',    'custom' => 'com.atlassian.jira.plugin.system.customfieldtypes:select', 'customId' => 10_444 } })
+                                                    ])
+    client
+  end
+
+  describe 'field_mappings' do
+    shared_context 'mapped or not' do
+      subject do
+        JIRA::Resource::Field.new(client, attrs: {
+                                    'priority' => 1,
+                                    'customfield_10111' => 'data_in_custom_field',
+                                    'customfield_10222' => 'multi word custom name',
+                                    'customfield_10333' => 'complex custom name',
+                                    'customfield_10444' => 'duplicated custom name',
+                                    'customfield_10666' => 'duplicate of a system name'
+                                  })
+      end
+
+      it 'can find a standard field by id' do
+        expect(subject.priority).to eq(1)
+      end
+
+      it 'can find a custom field by customfield_##### name' do
+        expect(subject.customfield_10111).to eq('data_in_custom_field')
+      end
+
+      it 'is not confused by common attribute keys' do
+        expect { subject.name }.to raise_error(NoMethodError)
+        expect { subject.custom }.to raise_error(NoMethodError)
+        expect(subject.id).to eq(nil)   # picks up ID from the parent -
+      end
+    end
+
+    context 'before fields are mapped' do
+      include_context 'mapped or not'
+
+      it 'can find a standard field by id' do
+        expect(subject.priority).to eq(1)
+      end
+
+      it 'cannot find a standard field by name before mapping' do
+        expect { subject.Priority }.to raise_error(NoMethodError)
+      end
+
+      it 'can find a custom field by customfield_##### name' do
+        expect(subject.customfield_10111).to eq('data_in_custom_field')
+      end
+
+      it 'is not confused by common attribute keys and raises error' do
+        expect { subject.name }.to raise_error(NoMethodError)
+        expect { subject.custom }.to raise_error(NoMethodError)
+        expect(subject.id).to eq(nil)   # picks up ID from the parent -
+      end
+    end
+
+    context 'after fields are mapped' do
+      include_context 'mapped or not'
+
+      it 'warns of duplicate fields' do
+        expect { client.Field.map_fields }.to output(/renaming as Priority_10666/).to_stderr
+        expect { client.Field.map_fields }.to output(/renaming as SingleWord_10444/).to_stderr
+      end
+    end
+  end
+end

data/spec/jira/resource/filter_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Filter do
+  let(:client) do
+    client = double
+    allow(client).to receive(:Issue).and_return(JIRA::Resource::IssueFactory.new(self))
+    client
+  end
+  let(:collection_path) { '/rest/api/2/filter' }
+  let(:jira_user) do
+    {
+      self: 'https://localhost/rest/api/2/user?username=ljharb',
+      name: 'ljharb',
+      avatarUrls: {
+        '16x16' => 'https://localhost/secure/useravatar?size=small&ownerId=ljharb&avatarId=1',
+        '48x48' => 'https://localhost/secure/useravatar?ownerId=ljharb&avatarId=1'
+      },
+      displayName: 'Jordan Harband',
+      active: true
+    }
+  end
+  let(:filter_attrs) do
+    {
+      self: "https://localhost#{collection_path}/42",
+      id: 42,
+      name: 'Resolved Tickets',
+      description: '',
+      owner: jira_user,
+      jql: '"Git Repository" ~ jira-ruby AND status = Resolved',
+      viewUrl: 'https://localhost/secure/IssueNavigator.jspa?mode=hide&requestId=42',
+      searchUrl: 'https://localhost/rest/api/2/search?jql=%22Git+Repository%22+~+jira-ruby+AND+status+%3D+Resolved',
+      favourite: false,
+      sharePermissions: [
+        {
+          id: 123,
+          type: 'global'
+        }
+      ],
+      subscriptions: {
+        size: 0,
+        items: []
+      }
+    }
+  end
+  let(:filter_response) do
+    response = double
+    allow(response).to receive(:body).and_return(filter_attrs.to_json)
+    response
+  end
+  let(:filter) do
+    expect(client).to receive(:get).with("#{collection_path}/42").and_return(filter_response)
+    allow(JIRA::Resource::Filter).to receive(:collection_path).and_return(collection_path)
+    JIRA::Resource::Filter.find(client, 42)
+  end
+  let(:jql_issue) do
+    {
+      id: '663147',
+      self: 'https://localhost/rest/api/2/issue/663147',
+      key: 'JIRARUBY-2386',
+      fields: {
+        reporter: jira_user,
+        created: '2013-12-11T23:28:02.000+0000',
+        assignee: jira_user
+      }
+    }
+  end
+  let(:jql_attrs) do
+    {
+      startAt: 0,
+      maxResults: 50,
+      total: 2,
+      issues: [jql_issue]
+    }
+  end
+  let(:issue_jql_response) do
+    response = double
+    allow(response).to receive(:body).and_return(jql_attrs.to_json)
+    response
+  end
+
+  it 'can be found by ID' do
+    expect(JSON.parse(filter.attrs.to_json)).to eql(JSON.parse(filter_attrs.to_json))
+  end
+
+  it 'returns issues' do
+    expect(filter).to be_present
+    allow(client).to receive(:options).and_return(rest_base_path: 'localhost')
+    expect(client).to receive(:get)
+      .with("localhost/search?jql=#{CGI.escape(filter.jql)}")
+      .and_return(issue_jql_response)
+    issues = filter.issues
+    expect(issues).to be_an(Array)
+    expect(issues.size).to eql(1)
+    expected_issue = client.Issue.build(JSON.parse(jql_issue.to_json))
+    expect(issues.first.attrs).to eql(expected_issue.attrs)
+  end
+end

data/spec/jira/resource/issue_spec.rb

@@ -0,0 +1,227 @@
+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' })
+    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
+      before(:each) 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(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)
+      end
+      it 'responds to key' do
+        expect(@decorated.respond_to?(:key)).to eq(true)
+      end
+      it 'does not raise an error' do
+        expect do
+          @issue.respond_to?(:project)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  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&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')
+
+    issues = JIRA::Resource::Issue.all(client)
+  end
+
+  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)
+
+    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
+
+    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('')
+
+    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
+
+    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('')
+
+    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
+
+    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(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
+
+    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)
+  end
+
+  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(%w[key foo]).and_return('')
+
+    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
+
+    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('')
+
+    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
+
+    allow(response).to receive(:body).and_return(
+      '{"fields":{"summary":{"required":true,"name":"Summary","operations":["set"]}}}'
+    )
+    expect(client).to receive(:get)
+      .with('/jira/rest/api/2/issue/TST=123/editmeta')
+      .and_return(response)
+
+    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' } })
+    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' }] }
+                                  }
+                                })
+    end
+
+    it 'has the correct relationships' do
+      expect(subject).to have_one(:reporter, JIRA::Resource::User)
+      expect(subject.reporter.foo).to eq('bar')
+
+      expect(subject).to have_one(:assignee, JIRA::Resource::User)
+      expect(subject.assignee.foo).to eq('bar')
+
+      expect(subject).to have_one(:project, JIRA::Resource::Project)
+      expect(subject.project.foo).to eq('bar')
+
+      expect(subject).to have_one(:issuetype, JIRA::Resource::Issuetype)
+      expect(subject.issuetype.foo).to eq('bar')
+
+      expect(subject).to have_one(:priority, JIRA::Resource::Priority)
+      expect(subject.priority.foo).to eq('bar')
+
+      expect(subject).to have_one(:status, JIRA::Resource::Status)
+      expect(subject.status.foo).to eq('bar')
+
+      expect(subject).to have_many(:components, JIRA::Resource::Component)
+      expect(subject.components.length).to eq(2)
+
+      expect(subject).to have_many(:comments, JIRA::Resource::Comment)
+      expect(subject.comments.length).to eq(2)
+
+      expect(subject).to have_many(:attachments, JIRA::Resource::Attachment)
+      expect(subject.attachments.length).to eq(2)
+
+      expect(subject).to have_many(:versions, JIRA::Resource::Version)
+      expect(subject.attachments.length).to eq(2)
+
+      expect(subject).to have_many(:worklogs, JIRA::Resource::Worklog)
+      expect(subject.worklogs.length).to eq(2)
+    end
+  end
+end

data/spec/jira/resource/issuelink_spec.rb

@@ -0,0 +1,14 @@
+# require 'spec_helper'
+#
+# describe JIRA::Resource::Issuelink do
+#   let(:client) { double() }
+#
+#   describe "links" do
+#     subject {
+#       JIRA::Resource::Issuelink.new(client, :attrs => {
+#
+#       }
+#       )
+#     }
+#   end
+# end

data/spec/jira/resource/project_factory_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe JIRA::Resource::ProjectFactory do
+  let(:client)  { double }
+  subject       { JIRA::Resource::ProjectFactory.new(client) }
+
+  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

@@ -0,0 +1,123 @@
+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
+
+    it 'has the correct relationships' do
+      expect(subject).to have_one(:lead, JIRA::Resource::User)
+      expect(subject.lead.foo).to eq('bar')
+
+      expect(subject).to have_many(:issuetypes, JIRA::Resource::Issuetype)
+      expect(subject.issuetypes.length).to eq(2)
+
+      expect(subject).to have_many(:versions, JIRA::Resource::Version)
+      expect(subject.versions.length).to eq(2)
+    end
+  end
+
+  describe 'issues' do
+    subject do
+      JIRA::Resource::Project.new(client, attrs: {
+                                    'key'         => 'test'
+                                  })
+    end
+
+    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')
+
+      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])
+      subject.issues
+    end
+
+    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')
+
+        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)
+      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
+end