sclemmer-jira-ruby 0.1.12

data/spec/jira/client_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe JIRA::Client do
+
+  let(:oauth_client) do
+    JIRA::Client.new({ :consumer_key => 'foo', :consumer_secret => 'bar' })
+  end
+
+  let(:basic_client) do
+    JIRA::Client.new({ :username => 'foo', :password => 'bar', :auth_type => :basic })
+  end
+
+  let(:clients) { [oauth_client, basic_client] }
+
+  let(: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(:merged_headers) { headers.merge(content_type_header) }
+
+  it "creates an instance" do
+    clients.each {|client| expect(client.class).to eq(JIRA::Client) }
+  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
+
+  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]) }
+    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
+
+  it "merges headers" do
+    clients.each { |client| expect(client.send(:merge_default_headers, {})).to eq({'Accept' => 'application/json'}) }
+  end
+
+  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)
+    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)
+    end
+
+    describe "like oauth" do
+
+      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')
+
+        expect(access_token).to eq(token)
+        expect(oauth_client.access_token).to eq(token)
+      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
+
+      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
+    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')
+      end
+    end
+  end
+
+  describe "has http methods" do
+    before do
+      oauth_client.set_access_token("foo", "bar")
+    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)
+
+      # 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({})
+
+      # 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)
+
+      [:delete, :get, :head].each do |method|
+        oauth_client.send(method, '/path', {})
+        basic_client.send(method, '/path', {})
+      end
+
+      [:post, :put].each do |method|
+        oauth_client.send(method, '/path', '', content_type_header)
+        basic_client.send(method, '/path', '', content_type_header)
+      end
+    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)
+        oauth_client.send(method, '/path', {})
+        basic_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)
+        oauth_client.send(method, '/path', '', {})
+        basic_client.send(method, '/path', '', {})
+      end
+    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
+      end
+    end
+
+    describe "that call a http client" do
+      it "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)
+        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)
+        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(oauth_client.Project.all).to eq([])
+      expect(basic_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(oauth_client.Project.find('123')).to eq(find_result)
+      expect(basic_client.Project.find('123')).to eq(find_result)
+    end
+  end
+end

data/spec/jira/has_many_proxy_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe JIRA::HasManyProxy do
+
+  class Foo ; end
+
+  subject { JIRA::HasManyProxy.new(parent, Foo, collection) }
+
+  let(:parent)      { double("parent") }
+  let(:collection)  { double("collection") }
+
+  it "has a target class" do
+    expect(subject.target_class).to eq(Foo)
+  end
+
+  it "has a parent" do
+    expect(subject.parent).to eq(parent)
+  end
+
+  it "has a collection" do
+    expect(subject.collection).to eq(collection)
+  end
+
+  it "can build a new instance" do
+    client = double('client')
+    foo = double('foo')
+    allow(parent).to receive(:client).and_return(client)
+    allow(parent).to receive(:to_sym).and_return(:parent)
+    expect(Foo).to receive(:new).with(client, :attrs => {'foo' => 'bar'}, :parent => parent).and_return(foo)
+    expect(collection).to receive(:<<).with(foo)
+    expect(subject.build('foo' => 'bar')).to eq(foo)
+  end
+
+  it "can get all the instances" do
+    foo = double('foo')
+    client = double('client')
+    allow(parent).to receive(:client).and_return(client)
+    allow(parent).to receive(:to_sym).and_return(:parent)
+    expect(Foo).to receive(:all).with(client, :parent => parent).and_return(foo)
+    expect(subject.all).to eq(foo)
+  end
+
+  it "delegates missing methods to the collection" do
+    expect(collection).to receive(:missing_method)
+    subject.missing_method
+  end
+end

data/spec/jira/http_client_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe JIRA::HttpClient do
+
+  let(:basic_client) do
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS)
+    JIRA::HttpClient.new(options)
+  end
+
+  let(:basic_cookie_client) do
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::HttpClient::DEFAULT_OPTIONS).merge(:use_cookies => true)
+    JIRA::HttpClient.new(options)
+  end
+
+  let(:response) do
+    response = double("response")
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+
+  let(:cookie_response) do
+    response = double("response")
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+
+  it "creates an instance of Net:HTTP for a basic auth client" do
+    expect(basic_client.basic_auth_http_conn.class).to eq(Net::HTTP)
+  end
+
+  it "responds to the http methods" do
+    body = ''
+    headers = double()
+    basic_auth_http_conn = double()
+    request = double()
+    allow(basic_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+    expect(request).to receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).exactly(5).times.and_return(request)
+    expect(basic_auth_http_conn).to receive(:request).exactly(5).times.with(request).and_return(response)
+    [:delete, :get, :head].each do |method|
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(basic_client.make_request(method, '/path', nil, headers)).to eq(response)
+    end
+    [:post, :put].each do |method|
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(request).to receive(:body=).with(body).and_return(request)
+      expect(basic_client.make_request(method, '/path', body, headers)).to eq(response)
+    end
+  end
+
+  it "gets and sets cookies" do
+    body = ''
+    headers = double()
+    basic_auth_http_conn = double()
+    request = double()
+    allow(basic_cookie_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+    expect(request).to receive(:basic_auth).with(basic_cookie_client.options[:username], basic_cookie_client.options[:password]).exactly(5).times.and_return(request)
+    expect(cookie_response).to receive(:get_fields).with('set-cookie').exactly(5).times
+    expect(basic_auth_http_conn).to receive(:request).exactly(5).times.with(request).and_return(cookie_response)
+    [:delete, :get, :head].each do |method|
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(basic_cookie_client.make_request(method, '/path', nil, headers)).to eq(cookie_response)
+    end
+    [:post, :put].each do |method|
+      expect(Net::HTTP.const_get(method.to_s.capitalize)).to receive(:new).with('/path', headers).and_return(request)
+      expect(request).to receive(:body=).with(body).and_return(request)
+      expect(basic_cookie_client.make_request(method, '/path', body, headers)).to eq(cookie_response)
+    end
+  end
+
+
+  it "performs a basic http client request" do
+    body = nil
+    headers = double()
+    basic_auth_http_conn = double()
+    http_request = double()
+    expect(Net::HTTP::Get).to receive(:new).with('/foo', headers).and_return(http_request)
+
+    expect(basic_auth_http_conn).to receive(:request).with(http_request).and_return(response)
+    expect(http_request).to receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).and_return(http_request)
+    allow(basic_client).to receive(:basic_auth_http_conn).and_return(basic_auth_http_conn)
+    basic_client.make_request(:get, '/foo', body, headers)
+  end
+
+  it "returns a URI" do
+    uri = URI.parse(basic_client.options[:site])
+    expect(basic_client.uri).to eq(uri)
+  end
+
+  it "sets up a http connection with options" do
+    http_conn = double()
+    uri = double()
+    host = double()
+    port = double()
+    expect(uri).to receive(:host).and_return(host)
+    expect(uri).to receive(:port).and_return(port)
+    expect(Net::HTTP).to receive(:new).with(host, port).and_return(http_conn)
+    expect(http_conn).to receive(:use_ssl=).with(basic_client.options[:use_ssl]).and_return(http_conn)
+    expect(http_conn).to receive(:verify_mode=).with(basic_client.options[:ssl_verify_mode]).and_return(http_conn)
+    expect(basic_client.http_conn(uri)).to eq(http_conn)
+  end
+
+  it "returns a http connection" do
+    http_conn = double()
+    uri = double()
+    expect(basic_client).to receive(:uri).and_return(uri)
+    expect(basic_client).to receive(:http_conn).and_return(http_conn)
+    expect(basic_client.basic_auth_http_conn).to eq(http_conn)
+  end
+end

data/spec/jira/http_error_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe JIRA::HTTPError do
+
+  let(:response)  {
+    response = double("response")
+    allow(response).to receive(:code).and_return(401)
+    allow(response).to receive(:message).and_return("A MESSAGE WOO")
+    response
+  }
+
+  subject { described_class.new(response) }
+
+  it "takes the response object as an argument" do
+    expect(subject.response).to eq(response)
+  end
+
+  it "has a code method" do
+    expect(subject.code).to eq(response.code)
+  end
+
+  it "returns code and class from message" do
+    expect(subject.message).to eq(response.message)
+  end
+
+end

data/spec/jira/oauth_client_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe JIRA::OauthClient do
+
+  let(:oauth_client) do
+    options = { :consumer_key => 'foo', :consumer_secret => 'bar' }
+    options = JIRA::Client::DEFAULT_OPTIONS.merge(options)
+    JIRA::OauthClient.new(options)
+  end
+
+  let(:response) do
+    response = double("response")
+    allow(response).to receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+
+  describe "authenticating with oauth" do
+    it "prepends the context path to all authorization and rest paths" do
+      options = [:request_token_path, :authorize_path, :access_token_path]
+      defaults = JIRA::Client::DEFAULT_OPTIONS.merge(JIRA::OauthClient::DEFAULT_OPTIONS)
+      options.each do |key|
+        expect(oauth_client.options[key]).to eq(defaults[:context_path] + defaults[key])
+      end
+    end
+
+    it "creates a Oauth::Consumer on initialize" do
+      expect(oauth_client.consumer.class).to eq(OAuth::Consumer)
+      expect(oauth_client.consumer.key).to eq(oauth_client.key)
+      expect(oauth_client.consumer.secret).to eq(oauth_client.secret)
+    end
+
+    it "returns an OAuth request_token" do
+      # Cannot just check for method delegation as http connection will be attempted
+      request_token = OAuth::RequestToken.new(oauth_client.consumer)
+      allow(oauth_client).to receive(:get_request_token).and_return(request_token)
+      expect(oauth_client.get_request_token).to eq(request_token)
+    end
+
+    it "allows setting the request token" do
+      token = double()
+      expect(OAuth::RequestToken).to receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+
+      request_token = oauth_client.set_request_token('foo', 'bar')
+
+      expect(request_token).to eq(token)
+      expect(oauth_client.request_token).to eq(token)
+    end
+
+    it "allows setting the consumer key" do
+      expect(oauth_client.key).to eq('foo')
+    end
+
+    it "allows setting the consumer secret" do
+      expect(oauth_client.secret).to eq('bar')
+    end
+
+    describe "the access token" do
+
+      it "initializes" do
+        request_token = OAuth::RequestToken.new(oauth_client.consumer)
+        allow(oauth_client).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
+
+      it "raises an exception when accessing without initialisation" do
+        expect {
+          oauth_client.access_token
+        }.to raise_exception(JIRA::OauthClient::UninitializedAccessTokenError,
+                             "init_access_token must be called before using the client")
+      end
+
+      it "allows setting the 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')
+
+        expect(access_token).to eq(token)
+        expect(oauth_client.access_token).to eq(token)
+      end
+    end
+
+    describe "http" do
+      it "responds to the http methods" do
+        headers = double()
+        mock_access_token = double()
+        allow(oauth_client).to receive(:access_token).and_return(mock_access_token)
+        [:delete, :get, :head].each do |method|
+          expect(mock_access_token).to receive(method).with('/path', headers).and_return(response)
+          oauth_client.make_request(method, '/path', '', headers)
+        end
+        [:post, :put].each do |method|
+          expect(mock_access_token).to receive(method).with('/path', '', headers).and_return(response)
+          oauth_client.make_request(method, '/path', '', headers)
+        end
+      end
+
+      it "performs a request" do
+        body = nil
+        headers = double()
+        access_token = double()
+        expect(access_token).to receive(:send).with(:get, '/foo', headers).and_return(response)
+        allow(oauth_client).to receive(:access_token).and_return(access_token)
+        oauth_client.request(:get, '/foo', body, headers)
+      end
+    end
+  end
+end