jira-ruby 1.2.0 → 1.3.0

data/lib/jira/client.rb

@@ -23,9 +23,10 @@ module JIRA
   #   :use_ssl            => true,
   #   :username           => nil,
   #   :password           => nil,
-  #   :auth_type          => :oauth
-  #   :proxy_address      => nil
-  #   :proxy_port         => nil
+  #   :auth_type          => :oauth,
+  #   :proxy_address      => nil,
+  #   :proxy_port         => nil,
+  #   :additional_cookies => nil
   #
   # See the JIRA::Base class methods for all of the available methods on these accessor
   # objects.
@@ -43,7 +44,7 @@ module JIRA
     # The configuration options for this client instance
     attr_reader :options
 
-    def_delegators :@request_client, :init_access_token, :set_access_token, :set_request_token, :request_token, :access_token
+    def_delegators :@request_client, :init_access_token, :set_access_token, :set_request_token, :request_token, :access_token, :authenticated?
 
     DEFAULT_OPTIONS = {
       :site               => 'http://localhost:2990',
@@ -71,6 +72,8 @@ module JIRA
         @options[:use_cookies] = true
         @request_client = HttpClient.new(@options)
         @request_client.make_cookie_auth_request
+        @options.delete(:username)
+        @options.delete(:password)
       else
         raise ArgumentError, 'Options: ":auth_type" must be ":oauth", ":cookie" or ":basic"'
       end

data/lib/jira/http_client.rb

@@ -19,15 +19,18 @@ module JIRA
 
     def make_cookie_auth_request
       body = { :username => @options[:username], :password => @options[:password] }.to_json
-      make_request(:post, '/rest/auth/1/session', body, {'Content-Type' => 'application/json'})
+      @options.delete(:username)
+      @options.delete(:password)
+      make_request(:post, @options[:context_path] + '/rest/auth/1/session', body, {'Content-Type' => 'application/json'})
     end
 
     def make_request(http_method, path, body='', headers={})
       request = Net::HTTP.const_get(http_method.to_s.capitalize).new(path, headers)
       request.body = body unless body.nil?
       add_cookies(request) if options[:use_cookies]
-      request.basic_auth(@options[:username], @options[:password])
+      request.basic_auth(@options[:username], @options[:password]) if @options[:username] && @options[:password]
       response = basic_auth_http_conn.request(request)
+      @authenticated = response.is_a? Net::HTTPOK
       store_cookies(response) if options[:use_cookies]
       response
     end
@@ -53,6 +56,10 @@ module JIRA
       uri = URI.parse(@options[:site])
     end
 
+    def authenticated?
+      @authenticated
+    end
+
     private
 
     def store_cookies(response)
@@ -67,7 +74,8 @@ module JIRA
     end
 
     def add_cookies(request)
-      cookie_array = @cookies.values.map { |cookie| cookie.to_s }
+      cookie_array = @cookies.values.map { |cookie| "#{cookie.name}=#{cookie.value[0]}" }
+      cookie_array +=  Array(@options[:additional_cookies]) if @options.key?(:additional_cookies)
       request.add_field('Cookie', cookie_array.join('; ')) if cookie_array.any?
       request
     end

data/lib/jira/oauth_client.rb

@@ -62,6 +62,8 @@ module JIRA
     # Sets the access token from a preexisting token and secret.
     def set_access_token(token, secret)
       @access_token = OAuth::AccessToken.new(@consumer, token, secret)
+      @authenticated = true
+      @access_token
     end
 
     # Returns the current access token. Raises an
@@ -78,7 +80,12 @@ module JIRA
       when :post, :put
         response = access_token.send http_method, path, body, headers
       end
+      @authenticated = true
       response
     end
+
+    def authenticated?
+      @authenticated
+    end
   end
 end

data/lib/jira/resource/agile.rb

@@ -15,19 +15,33 @@ module JIRA
 
       def self.get_backlog_issues(client, board_id, options = {})
         options[:maxResults] ||= 100
-        response = client.get("/rest/agile/1.0/board/#{board_id}/backlog?maxResults=#{options[:maxResults]}")
+        response = client.get(path_base(client) + "/board/#{board_id}/backlog?#{hash_to_query_string(options)}")
         parse_json(response.body)
       end
 
       def self.get_sprints(client, board_id, options = {})
         options[:maxResults] ||= 100
-        response = client.get("/rest/agile/1.0/board/#{board_id}/sprint?maxResults=#{options[:maxResults]}")
+        response = client.get(path_base(client) + "/board/#{board_id}/sprint?#{hash_to_query_string(options)}")
         parse_json(response.body)
       end
 
       def self.get_sprint_issues(client, sprint_id, options = {})
         options[:maxResults] ||= 100
-        response = client.get("/rest/agile/1.0/sprint/#{sprint_id}/issue?maxResults=#{options[:maxResults]}")
+        response = client.get(path_base(client) + "/sprint/#{sprint_id}/issue?#{hash_to_query_string(options)}")
+        parse_json(response.body)
+      end
+
+      def self.get_projects_full(client, board_id, options = {})
+        response = client.get(path_base(client) + "/board/#{board_id}/project/full")
+        parse_json(response.body)
+      end
+
+      def self.get_projects(client, board_id, options = {})
+        options[:maxResults] ||= 100
+        create_meta_url = path_base(client) + "/board/#{board_id}/project"
+        params = hash_to_query_string(options)
+
+        response = client.get("#{create_meta_url}?#{params}")
         parse_json(response.body)
       end
 
@@ -47,7 +61,6 @@ module JIRA
       def path_base(client)
         self.class.path_base(client)
       end
-
     end
 
   end

data/lib/jira/resource/attachment.rb

@@ -1,3 +1,5 @@
+require 'net/http/post/multipart'
+
 module JIRA
   module Resource
 
@@ -5,8 +7,35 @@ module JIRA
     end
 
     class Attachment < JIRA::Base
+      belongs_to :issue
       has_one :author, :class => JIRA::Resource::User
-    end
 
+      def self.meta(client)
+        response = client.get(client.options[:rest_base_path] + '/attachment/meta')
+        parse_json(response.body)
+      end
+
+      def save!(attrs)
+        headers = { 'X-Atlassian-Token' => 'nocheck' }
+        data = { 'file' => UploadIO.new(attrs['file'], 'application/binary', attrs['file']) }
+
+        request = Net::HTTP::Post::Multipart.new url, data, headers
+        request.basic_auth(client.request_client.options[:username],
+                           client.request_client.options[:password])
+
+        response = client.request_client.basic_auth_http_conn.request(request)
+
+        set_attrs(attrs, false)
+        unless response.body.nil? || response.body.length < 2
+          json = self.class.parse_json(response.body)
+          attachment = json[0]
+
+          set_attrs(attachment)
+        end
+
+        @expanded = false
+        true
+      end
+    end
   end
 end

data/lib/jira/resource/issue.rb

@@ -71,6 +71,23 @@ module JIRA
         end
       end
 
+      # Fetches the attributes for the specified resource from JIRA unless
+      # the resource is already expanded and the optional force reload flag
+      # is not set
+      def fetch(reload = false, query_params = {})
+        return if expanded? && !reload
+        response = client.get(url_with_query_params(url, query_params))
+        set_attrs_from_response(response)
+        if @attrs and @attrs['fields'] and @attrs['fields']['worklog'] and @attrs['fields']['worklog']['total'] > @attrs['fields']['worklog']['maxResults']
+          worklog_url = client.options[:rest_base_path] + "/#{self.class.endpoint_name}/#{id}/worklog"
+          response = client.get(worklog_url)
+          unless response.body.nil? or response.body.length < 2
+            set_attrs({'fields' => { 'worklog' => self.class.parse_json(response.body) }}, false)
+          end
+        end
+        @expanded = true
+      end
+
       def editmeta
         editmeta_url = client.options[:rest_base_path] + "/#{self.class.endpoint_name}/#{key}/editmeta"
 

data/lib/jira/version.rb

@@ -1,3 +1,3 @@
 module JIRA
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/spec/integration/attachment_spec.rb

@@ -8,6 +8,8 @@ describe JIRA::Resource::Attachment do
 
     let(:key) { "10000" }
 
+    let(:target) { JIRA::Resource::Attachment.new(client, :attrs => {'id' => '99999'}, :issue_id => '10002') }
+
     let(:expected_attributes) do
       {
         'self' => "http://localhost:2990/jira/rest/api/2/attachment/10000",
@@ -16,7 +18,15 @@ describe JIRA::Resource::Attachment do
       }
     end
 
-    it_should_behave_like "a resource"
+    let(:belongs_to) {
+      JIRA::Resource::Issue.new(client, :attrs => {
+        'id' => '10002',
+        'fields' => {
+          'attachment' => {'attachments' => []}
+        }
+      })
+    }
+
     it_should_behave_like "a resource with a singular GET endpoint"
     it_should_behave_like "a resource with a DELETE endpoint"
   end

data/spec/jira/client_spec.rb

@@ -1,223 +1,228 @@
 require 'spec_helper'
 
-describe JIRA::Client do
-  before(:each) do
-    stub_request(:post, "https://foo:bar@localhost:2990/rest/auth/1/session").
-      to_return(:status => 200, :body => "", :headers => {})
+# We have three forms of authentication with two clases to represent the client for those different authentications.
+# Some behaviours are shared across all three types of authentication.  these are captured here.
+RSpec.shared_examples 'Client Common Tests' do
+  it { is_expected.to be_a JIRA::Client }
+
+  it 'freezes the options once initialised' do
+    expect(subject.options).to be_frozen
+  end
+
+  it 'prepends context path to rest base_path' do
+    options = [:rest_base_path]
+    defaults = JIRA::Client::DEFAULT_OPTIONS
+    options.each { |key| expect(subject.options[key]).to eq(defaults[:context_path] + defaults[key]) }
   end
 
-  let(:oauth_client) do
-    JIRA::Client.new({ :consumer_key => 'foo', :consumer_secret => 'bar' })
+  it 'merges headers' do
+    expect(subject.send(:merge_default_headers, {})).to eq({'Accept' => 'application/json'})
   end
 
-  let(:basic_client) do
-    JIRA::Client.new({ :username => 'foo', :password => 'bar', :auth_type => :basic })
+  describe 'http methods' do
+    it 'merges default headers' do
+      # stubbed response for generic client request method
+      expect(subject).to receive(:request).exactly(5).times.and_return(successful_response)
+
+      # response for merging headers for http methods with no body
+      expect(subject).to receive(:merge_default_headers).exactly(3).times.with({})
+
+      # response for merging headers for http methods with body
+      expect(subject).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
+
+      [:delete, :get, :head].each { |method| subject.send(method, '/path', {}) }
+      [:post, :put].each {|method| subject.send(method, '/path', '', content_type_header)}
+    end
+
+    it 'calls the generic request method' do
+      [:delete, :get, :head].each do |method|
+        expect(subject).to receive(:request).with(method, '/path', nil, headers).and_return(successful_response)
+        subject.send(method, '/path', {})
+      end
+
+      [:post, :put].each do |method|
+        expect(subject).to receive(:request).with(method, '/path', '', merged_headers)
+        subject.send(method, '/path', '', {})
+      end
+    end
   end
 
-  let(:cookie_client) do
-    JIRA::Client.new({ :username => 'foo', :password => 'bar', :auth_type => :cookie })
+  describe 'Resource Factories' do
+    it 'gets all projects' do
+      expect(JIRA::Resource::Project).to receive(:all).with(subject).and_return([])
+      expect(subject.Project.all).to eq([])
+    end
+
+    it 'finds a single project' do
+      find_result = double
+      expect(JIRA::Resource::Project).to receive(:find).with(subject, '123').and_return(find_result)
+      expect(subject.Project.find('123')).to eq(find_result)
+    end
   end
+end
 
-  let(:clients) { [oauth_client, basic_client, cookie_client] }
+RSpec.shared_examples 'HttpClient tests' do
+  it 'makes a valid request' do
+    [:delete, :get, :head].each do |method|
+      expect(subject.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(successful_response)
+      subject.send(method, '/path', headers)
+    end
+    [:post, :put].each do |method|
+      expect(subject.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(successful_response)
+      subject.send(method, '/path', '', headers)
+    end
+  end
+end
 
-  let(:response) do
-    response = double("response")
+describe JIRA::Client do
+  let(:request) { subject.request_client.class }
+  let(:successful_response) do
+    response = double('response')
     allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
     response
   end
-
-  let(:headers) { {'Accept' => 'application/json'} }
   let(:content_type_header) { {'Content-Type' => 'application/json'} }
+  let(:headers) { {'Accept' => 'application/json'} }
   let(:merged_headers) { headers.merge(content_type_header) }
 
-  it "creates an instance" do
-    clients.each {|client| expect(client.class).to eq(JIRA::Client) }
+  context 'behaviour that applies to all client classes irrespective of authentication method' do
+    it 'allows the overriding of some options' do
+      client = JIRA::Client.new({:consumer_key => 'foo', :consumer_secret => 'bar', :site => 'http://foo.com/'})
+      expect(client.options[:site]).to eq('http://foo.com/')
+      expect(JIRA::Client::DEFAULT_OPTIONS[:site]).not_to eq('http://foo.com/')
+    end
   end
 
-  it "allows the overriding of some options" do
-    client = JIRA::Client.new({:consumer_key => 'foo', :consumer_secret => 'bar', :site => 'http://foo.com/'})
-    expect(client.options[:site]).to eq('http://foo.com/')
-    expect(JIRA::Client::DEFAULT_OPTIONS[:site]).not_to eq('http://foo.com/')
-  end
+  context 'with basic http authentication' do
+    subject { JIRA::Client.new(username: 'foo', password: 'bar', auth_type: :basic) }
 
-  it "prepends the context path to the rest base path" do
-    options = [:rest_base_path]
-    defaults = JIRA::Client::DEFAULT_OPTIONS
-    options.each do |key|
-      clients.each { |client| expect(client.options[key]).to eq(defaults[:context_path] + defaults[key]) }
+    before(:each) do
+      stub_request(:get, 'https://foo:bar@localhost:2990/jira/rest/api/2/project')
+        .to_return(status: 200, body: '[]', headers: {} )
+
+      stub_request(:get, 'https://foo:badpassword@localhost:2990/jira/rest/api/2/project').
+        to_return(status: 401, headers: {} )
     end
-  end
 
-  # To avoid having to validate options after initialisation, e.g. setting
-  # client.options[:invalid] = 'foo'
-  it "freezes the options" do
-    clients.each { |client| expect(client.options).to be_frozen }
-  end
+    include_examples 'Client Common Tests'
+    include_examples 'HttpClient tests'
 
-  it "merges headers" do
-    clients.each { |client| expect(client.send(:merge_default_headers, {})).to eq({'Accept' => 'application/json'}) }
-  end
+    specify { expect(subject.request_client).to be_a JIRA::HttpClient }
 
-  describe "creates instances of request clients" do
-    specify "that are of the correct class" do
-      expect(oauth_client.request_client.class).to eq(JIRA::OauthClient)
-      expect(basic_client.request_client.class).to eq(JIRA::HttpClient)
-      expect(cookie_client.request_client.class).to eq(JIRA::HttpClient)
+    it 'sets the username and password' do
+      expect(subject.options[:username]).to eq('foo')
+      expect(subject.options[:password]).to eq('bar')
     end
 
-    specify "which have a corresponding auth type option" do
-      expect(oauth_client.options[:auth_type]).to eq(:oauth)
-      expect(basic_client.options[:auth_type]).to eq(:basic)
-      expect(cookie_client.options[:auth_type]).to eq(:cookie)
+    it 'fails with wrong user name and password' do
+      bad_login = JIRA::Client.new(username: 'foo', password: 'badpassword', auth_type: :basic)
+      expect(bad_login.authenticated?).to be_falsey
+      expect{bad_login.Project.all}.to raise_error JIRA::HTTPError
     end
 
-    describe "like oauth" do
+    it 'only returns a true for #authenticated? once we have requested some data' do
+      expect(subject.authenticated?).to be_falsey
+      expect(subject.Project.all).to be_empty
+      expect(subject.authenticated?).to be_truthy
+    end
 
-      it "allows setting an access token" do
-        token = double()
-        expect(OAuth::AccessToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
-        access_token = oauth_client.set_access_token('foo', 'bar')
+  end
 
-        expect(access_token).to eq(token)
-        expect(oauth_client.access_token).to eq(token)
-      end
+  context 'with cookie authentication' do
+    subject { JIRA::Client.new(username: 'foo', password: 'bar', auth_type: :cookie) }
+
+    let(:session_cookie) { '6E3487971234567896704A9EB4AE501F' }
+    let(:session_body) do
+      {
+        'session': {'name' => "JSESSIONID", 'value' => session_cookie },
+        'loginInfo': {'failedLoginCount' => 1, 'loginCount' => 2,
+                      'lastFailedLoginTime' => (DateTime.now - 2).iso8601,
+                      'previousLoginTime' => (DateTime.now - 5).iso8601 }
+      }
+    end
 
-      it "allows initializing the access token" do
-        request_token = OAuth::RequestToken.new(oauth_client.consumer)
-        allow(oauth_client.consumer).to receive(:get_request_token).and_return(request_token)
-        mock_access_token = double()
-        expect(request_token).to receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
-        oauth_client.init_access_token(:oauth_verifier => 'abc123')
-        expect(oauth_client.access_token).to eq(mock_access_token)
-      end
+    before(:each) do
+      # General case of API call with no authentication, or wrong authentication
+      stub_request(:post, 'https://localhost:2990/jira/rest/auth/1/session').
+        to_return(status: 401, headers: {} )
 
-      specify "that has specific default options" do
-        options = [:signature_method, :private_key_file]
-        options.each do |key|
-          expect(oauth_client.options[key]).to eq(JIRA::Client::DEFAULT_OPTIONS[key])
-        end
-      end
+      # Now special case of API with correct authentication.  This gets checked first by RSpec.
+      stub_request(:post, 'https://localhost:2990/jira/rest/auth/1/session')
+        .with(body: '{"username":"foo","password":"bar"}')
+        .to_return(status: 200, body: session_body.to_json,
+                   headers: { 'Set-Cookie': "JSESSIONID=#{session_cookie}; Path=/; HttpOnly"})
+
+      stub_request(:get, 'https://localhost:2990/jira/rest/api/2/project')
+        .with(headers: { cookie: "JSESSIONID=#{session_cookie}" } )
+        .to_return(status: 200, body: '[]', headers: {} )
     end
 
-    describe "like basic http" do
-      it "sets the username and password" do
-        expect(basic_client.options[:username]).to eq('foo')
-        expect(basic_client.options[:password]).to eq('bar')
+    include_examples 'Client Common Tests'
+    include_examples 'HttpClient tests'
 
-        expect(cookie_client.options[:username]).to eq('foo')
-        expect(cookie_client.options[:password]).to eq('bar')
-      end
+    specify { expect(subject.request_client).to be_a JIRA::HttpClient }
+
+    it 'authenticates with a correct username and password' do
+      expect(subject).to be_authenticated
+      expect(subject.Project.all).to be_empty
     end
 
-  end
+    it 'does not authenticate with an incorrect username and password' do
+      bad_client = JIRA::Client.new(username: 'foo', password: 'bad_password', auth_type: :cookie)
+      expect(bad_client).not_to be_authenticated
+    end
 
-  describe "has http methods" do
-    before do
-      oauth_client.set_access_token("foo", "bar")
+    it 'destroys the username and password once authenticated' do
+      expect(subject.options[:username]).to be_nil
+      expect(subject.options[:password]).to be_nil
     end
+  end
 
-    specify "that merge default headers" do
-      # stubbed response for generic client request method
-      expect(oauth_client).to receive(:request).exactly(5).times.and_return(response)
-      expect(basic_client).to receive(:request).exactly(5).times.and_return(response)
-      expect(cookie_client).to receive(:request).exactly(5).times.and_return(response)
+  context 'oath2 authentication' do
+    subject { JIRA::Client.new(consumer_key: 'foo', consumer_secret: 'bar') }
 
-      # response for merging headers for http methods with no body
-      expect(oauth_client).to receive(:merge_default_headers).exactly(3).times.with({})
-      expect(basic_client).to receive(:merge_default_headers).exactly(3).times.with({})
-      expect(cookie_client).to receive(:merge_default_headers).exactly(3).times.with({})
+    include_examples 'Client Common Tests'
 
-      # response for merging headers for http methods with body
-      expect(oauth_client).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
-      expect(basic_client).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
-      expect(cookie_client).to receive(:merge_default_headers).exactly(2).times.with(content_type_header)
+    specify { expect(subject.request_client).to be_a JIRA::OauthClient }
 
-      [:delete, :get, :head].each do |method|
-        oauth_client.send(method, '/path', {})
-        basic_client.send(method, '/path', {})
-        cookie_client.send(method, '/path', {})
-      end
+    it 'allows setting an access token' do
+      token = double
+      expect(OAuth::AccessToken).to receive(:new).with(subject.consumer, 'foo', 'bar').and_return(token)
 
-      [:post, :put].each do |method|
-        oauth_client.send(method, '/path', '', content_type_header)
-        basic_client.send(method, '/path', '', content_type_header)
-        cookie_client.send(method, '/path', '', content_type_header)
-      end
+      expect(subject.authenticated?).to be_falsey
+      access_token = subject.set_access_token('foo', 'bar')
+      expect(access_token).to eq(token)
+      expect(subject.access_token).to eq(token)
+      expect(subject.authenticated?).to be_truthy
     end
 
-    specify "that call the generic request method" do
-      [:delete, :get, :head].each do |method|
-        expect(oauth_client).to receive(:request).with(method, '/path', nil, headers).and_return(response)
-        expect(basic_client).to receive(:request).with(method, '/path', nil, headers).and_return(response)
-        expect(cookie_client).to receive(:request).with(method, '/path', nil, headers).and_return(response)
-        oauth_client.send(method, '/path', {})
-        basic_client.send(method, '/path', {})
-        cookie_client.send(method, '/path', {})
-      end
-
-      [:post, :put].each do |method|
-        expect(oauth_client).to receive(:request).with(method, '/path', '', merged_headers)
-        expect(basic_client).to receive(:request).with(method, '/path', '', merged_headers)
-        expect(cookie_client).to receive(:request).with(method, '/path', '', merged_headers)
-        oauth_client.send(method, '/path', '', {})
-        basic_client.send(method, '/path', '', {})
-        cookie_client.send(method, '/path', '', {})
-      end
+    it 'allows initializing the access token' do
+      request_token = OAuth::RequestToken.new(subject.consumer)
+      allow(subject.consumer).to receive(:get_request_token).and_return(request_token)
+      mock_access_token = double
+      expect(request_token).to receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
+      subject.init_access_token(:oauth_verifier => 'abc123')
+      expect(subject.access_token).to eq(mock_access_token)
     end
 
-    describe "that call a oauth client" do
-      specify "which makes a request" do
-        [:delete, :get, :head].each do |method|
-          expect(oauth_client.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(response)
-          oauth_client.send(method, '/path', {})
-        end
-        [:post, :put].each do |method|
-          expect(oauth_client.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
-          oauth_client.send(method, '/path', '', {})
-        end
+    specify 'that has specific default options' do
+      [:signature_method, :private_key_file].each do |key|
+        expect(subject.options[key]).to eq(JIRA::Client::DEFAULT_OPTIONS[key])
       end
     end
 
-    describe "that call a http client" do
-      it "which makes a request" do
+    describe 'that call a oauth client' do
+      specify 'which makes a request' do
         [:delete, :get, :head].each do |method|
-          expect(basic_client.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(response)
-          basic_client.send(method, '/path', headers)
-
-          expect(cookie_client.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(response)
-          cookie_client.send(method, '/path', headers)
+          expect(subject.request_client).to receive(:make_request).with(method, '/path', nil, headers).and_return(successful_response)
+          subject.send(method, '/path', {})
         end
         [:post, :put].each do |method|
-          expect(basic_client.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
-          basic_client.send(method, '/path', '', headers)
-
-          expect(cookie_client.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(response)
-          cookie_client.send(method, '/path', '', headers)
+          expect(subject.request_client).to receive(:make_request).with(method, '/path', '', merged_headers).and_return(successful_response)
+          subject.send(method, '/path', '', {})
         end
       end
     end
   end
-
-  describe "Resource Factories" do
-    it "gets all projects" do
-      expect(JIRA::Resource::Project).to receive(:all).with(oauth_client).and_return([])
-      expect(JIRA::Resource::Project).to receive(:all).with(basic_client).and_return([])
-      expect(JIRA::Resource::Project).to receive(:all).with(cookie_client).and_return([])
-
-      expect(oauth_client.Project.all).to eq([])
-      expect(basic_client.Project.all).to eq([])
-      expect(cookie_client.Project.all).to eq([])
-    end
-
-    it "finds a single project" do
-      find_result = double()
-      expect(JIRA::Resource::Project).to receive(:find).with(oauth_client, '123').and_return(find_result)
-      expect(JIRA::Resource::Project).to receive(:find).with(basic_client, '123').and_return(find_result)
-      expect(JIRA::Resource::Project).to receive(:find).with(cookie_client, '123').and_return(find_result)
-
-      expect(oauth_client.Project.find('123')).to eq(find_result)
-      expect(basic_client.Project.find('123')).to eq(find_result)
-      expect(cookie_client.Project.find('123')).to eq(find_result)
-    end
-  end
 end
+