jira-ruby 2.3.0 → 3.0.0.beta2

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]
       )

data/spec/jira/resource/field_spec.rb

@@ -1,39 +1,56 @@
 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)
+    allow(client).to receive(:field_map_cache).and_return(nil)
+    allow(client).to receive(:field_map_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 } })
+                                                      described_class.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 } }),
+                                                      described_class.new(client,
+                                                                          attrs: { 'id' => 'issuekey', 'name' => 'Key', 'custom' => false, 'orderable' => false,
+                                                                                   'navigable' => true, 'searchable' => false, 'clauseNames' => %w[id issue issuekey key] }),
+                                                      described_class.new(client,
+                                                                          attrs: { 'id' => 'priority', 'name' => 'Priority', 'custom' => false, 'orderable' => true,
+                                                                                   'navigable' => true, 'searchable' => true, 'clauseNames' => ['priority'], 'schema' => { 'type' => 'priority', 'system' => 'priority' } }),
+                                                      described_class.new(client,
+                                                                          attrs: { 'id' => 'summary', 'name' => 'Summary', 'custom' => false, 'orderable' => true,
+                                                                                   'navigable' => true, 'searchable' => true, 'clauseNames' => ['summary'], 'schema' => { 'type' => 'string', 'system' => 'summary' } }),
+                                                      described_class.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' } }),
+                                                      described_class.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 } }),
+                                                      described_class.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 } }),
+                                                      described_class.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 } }),
+                                                      described_class.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
+    shared_context 'with or without mapping' 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'
-                                  })
+        described_class.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
@@ -47,12 +64,12 @@ describe JIRA::Resource::Field do
       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 -
+        expect(subject.id).to be_nil   # picks up ID from the parent -
       end
     end
 
-    context 'before fields are mapped' do
-      include_context 'mapped or not'
+    context 'when fields are not yet mapped' do
+      include_context 'with or without mapping'
 
       it 'can find a standard field by id' do
         expect(subject.priority).to eq(1)
@@ -69,12 +86,12 @@ describe JIRA::Resource::Field do
       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 -
+        expect(subject.id).to be_nil   # picks up ID from the parent -
       end
     end
 
-    context 'after fields are mapped' do
-      include_context 'mapped or not'
+    context 'when fields have been mapped' do
+      include_context 'with or without mapping'
 
       it 'warns of duplicate fields' do
         expect { client.Field.map_fields }.to output(/renaming as Priority_10666/).to_stderr

data/spec/jira/resource/filter_spec.rb

@@ -48,9 +48,9 @@ describe JIRA::Resource::Filter do
     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)
+    allow(client).to receive(:get).with("#{collection_path}/42").and_return(filter_response)
+    allow(described_class).to receive(:collection_path).and_return(collection_path)
+    described_class.find(client, 42)
   end
   let(:jql_issue) do
     {
@@ -90,7 +90,7 @@ describe JIRA::Resource::Filter do
       .and_return(issue_jql_response)
     issues = filter.issues
     expect(issues).to be_an(Array)
-    expect(issues.size).to eql(1)
+    expect(issues.size).to be(1)
     expected_issue = client.Issue.build(JSON.parse(jql_issue.to_json))
     expect(issues.first.attrs).to eql(expected_issue.attrs)
   end

data/spec/jira/resource/issue_picker_suggestions_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe JIRA::Resource::IssuePickerSuggestions do
   let(:client) do
     double('client', options: {
-      rest_base_path: '/jira/rest/api/2'
-    })
+             rest_base_path: '/jira/rest/api/2'
+           })
   end
 
   describe 'relationships' do
     subject do
-      JIRA::Resource::IssuePickerSuggestions.new(client, attrs: {
-        'sections' => [{ 'id' => 'hs'}, { 'id' => 'cs' }]
-      })
+      described_class.new(client, attrs: {
+                            'sections' => [{ 'id' => 'hs' }, { 'id' => 'cs' }]
+                          })
     end
 
     it 'has the correct relationships' do
@@ -30,7 +30,7 @@ describe JIRA::Resource::IssuePickerSuggestions do
       allow(issue_picker_suggestions).to receive(:build)
     end
 
-    it 'should autocomplete issues' do
+    it 'autocompletes issues' do
       allow(response).to receive(:body).and_return('{"sections":[{"id": "cs"}]}')
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/picker?query=query')
                                      .and_return(response)
@@ -38,42 +38,42 @@ describe JIRA::Resource::IssuePickerSuggestions do
       expect(client).to receive(:IssuePickerSuggestions).and_return(issue_picker_suggestions)
       expect(issue_picker_suggestions).to receive(:build).with({ 'sections' => [{ 'id' => 'cs' }] })
 
-      JIRA::Resource::IssuePickerSuggestions.all(client, 'query')
+      described_class.all(client, 'query')
     end
 
-    it 'should autocomplete issues with current jql' do
+    it 'autocompletes issues with current jql' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/picker?query=query&currentJQL=project+%3D+PR')
                                      .and_return(response)
 
-      JIRA::Resource::IssuePickerSuggestions.all(client, 'query', current_jql: 'project = PR')
+      described_class.all(client, 'query', current_jql: 'project = PR')
     end
 
-    it 'should autocomplete issues with current issue jey' do
+    it 'autocompletes issues with current issue jey' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/picker?query=query&currentIssueKey=PR-42')
                                      .and_return(response)
 
-      JIRA::Resource::IssuePickerSuggestions.all(client, 'query', current_issue_key: 'PR-42')
+      described_class.all(client, 'query', current_issue_key: 'PR-42')
     end
 
-    it 'should autocomplete issues with current project id' do
+    it 'autocompletes issues with current project id' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/picker?query=query&currentProjectId=PR')
                                      .and_return(response)
 
-      JIRA::Resource::IssuePickerSuggestions.all(client, 'query', current_project_id: 'PR')
+      described_class.all(client, 'query', current_project_id: 'PR')
     end
 
-    it 'should autocomplete issues with show sub tasks' do
+    it 'autocompletes issues with show sub tasks' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/picker?query=query&showSubTasks=true')
                                      .and_return(response)
 
-      JIRA::Resource::IssuePickerSuggestions.all(client, 'query', show_sub_tasks: true)
+      described_class.all(client, 'query', show_sub_tasks: true)
     end
 
-    it 'should autocomplete issues with show sub tasks parent' do
+    it 'autocompletes issues with show sub tasks parent' do
       expect(client).to receive(:get).with('/jira/rest/api/2/issue/picker?query=query&showSubTaskParent=true')
                                      .and_return(response)
 
-      JIRA::Resource::IssuePickerSuggestions.all(client, 'query', show_sub_task_parent: true)
+      described_class.all(client, 'query', show_sub_task_parent: true)
     end
   end
 end