jira-ruby-added-transitions 0.1.3

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 = mock("response")
+    response.stub(: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| client.class.should == 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/'})
+    client.options[:site].should == 'http://foo.com/'
+    JIRA::Client::DEFAULT_OPTIONS[:site].should_not == '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| client.options[key].should == 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| client.options.should be_frozen }
+  end
+
+  it "merges headers" do
+    clients.each { |client| client.send(:merge_default_headers, {}).should == {'Accept' => 'application/json'} }
+  end
+
+  describe "creates instances of request clients" do
+    specify "that are of the correct class" do
+      oauth_client.request_client.class.should == JIRA::OauthClient
+      basic_client.request_client.class.should == JIRA::HttpClient
+    end
+
+    specify "which have a corresponding auth type option" do
+      oauth_client.options[:auth_type].should == :oauth
+      basic_client.options[:auth_type].should == :basic
+    end
+
+    describe "like oauth" do
+
+      it "allows setting an access token" do
+        token = mock()
+        OAuth::AccessToken.should_receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+        access_token = oauth_client.set_access_token('foo', 'bar')
+
+        access_token.should         == token
+        oauth_client.access_token.should == token
+      end
+
+      it "allows initializing the access token" do
+        request_token = OAuth::RequestToken.new(oauth_client.consumer)
+        oauth_client.consumer.stub(:get_request_token => request_token)
+        mock_access_token = mock()
+        request_token.should_receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
+        oauth_client.init_access_token(:oauth_verifier => 'abc123')
+        oauth_client.access_token.should == mock_access_token
+      end
+
+      specify "that has specific default options" do
+        options = [:signature_method, :private_key_file]
+        options.each do |key|
+          oauth_client.options[key].should == JIRA::Client::DEFAULT_OPTIONS[key]
+        end
+      end
+    end
+
+    describe "like basic http" do
+      it "sets the username and password" do
+        basic_client.options[:username].should == 'foo'
+        basic_client.options[:password].should == '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
+      oauth_client.should_receive(:request).exactly(5).times.and_return(response)
+      basic_client.should_receive(:request).exactly(5).times.and_return(response)
+
+      # response for merging headers for http methods with no body
+      oauth_client.should_receive(:merge_default_headers).exactly(3).times.with({})
+      basic_client.should_receive(:merge_default_headers).exactly(3).times.with({})
+
+      # response for merging headers for http methods with body
+      oauth_client.should_receive(:merge_default_headers).exactly(2).times.with(content_type_header)
+      basic_client.should_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|
+        oauth_client.should_receive(:request).with(method, '/path', nil, headers).and_return(response)
+        basic_client.should_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|
+        oauth_client.should_receive(:request).with(method, '/path', '', merged_headers)
+        basic_client.should_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|
+          oauth_client.request_client.should_receive(:make_request).with(method, '/path', nil, headers).and_return(response)
+          oauth_client.send(method, '/path', {})
+        end
+        [:post, :put].each do |method|
+          oauth_client.request_client.should_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|
+          basic_client.request_client.should_receive(:make_request).with(method, '/path', nil, headers).and_return(response)
+          basic_client.send(method, '/path', headers)
+        end
+        [:post, :put].each do |method|
+          basic_client.request_client.should_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
+      JIRA::Resource::Project.should_receive(:all).with(oauth_client).and_return([])
+      JIRA::Resource::Project.should_receive(:all).with(basic_client).and_return([])
+      oauth_client.Project.all.should == []
+      basic_client.Project.all.should == []
+    end
+
+    it "finds a single project" do
+      find_result = mock()
+      JIRA::Resource::Project.should_receive(:find).with(oauth_client, '123').and_return(find_result)
+      JIRA::Resource::Project.should_receive(:find).with(basic_client, '123').and_return(find_result)
+      oauth_client.Project.find('123').should == find_result
+      basic_client.Project.find('123').should == find_result
+    end
+  end
+end

data/spec/jira/has_many_proxy_spec.rb

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

data/spec/jira/http_client_spec.rb

@@ -0,0 +1,77 @@
+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(:response) do
+    response = mock("response")
+    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+
+  it "creates an instance of Net:HTTP for a basic auth client" do
+    basic_client.basic_auth_http_conn.class.should == Net::HTTP
+  end
+
+  it "responds to the http methods" do
+    body = ''
+    headers = mock()
+    basic_auth_http_conn = mock()
+    request = mock()
+    basic_client.stub(:basic_auth_http_conn => basic_auth_http_conn)
+    request.should_receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).exactly(5).times.and_return(request)
+    basic_auth_http_conn.should_receive(:request).exactly(5).times.with(request).and_return(response)
+    [:delete, :get, :head].each do |method|
+      Net::HTTP.const_get(method.to_s.capitalize).should_receive(:new).with('/path', headers).and_return(request)
+      basic_client.make_request(method, '/path', nil, headers).should == response
+    end
+    [:post, :put].each do |method|
+      Net::HTTP.const_get(method.to_s.capitalize).should_receive(:new).with('/path', headers).and_return(request)
+      request.should_receive(:body=).with(body).and_return(request)
+      basic_client.make_request(method, '/path', body, headers).should == response
+    end
+  end
+
+  it "performs a basic http client request" do
+    body = nil
+    headers = mock()
+    basic_auth_http_conn = mock()
+    http_request = mock()
+    Net::HTTP::Get.should_receive(:new).with('/foo', headers).and_return(http_request)
+
+    basic_auth_http_conn.should_receive(:request).with(http_request).and_return(response)
+    http_request.should_receive(:basic_auth).with(basic_client.options[:username], basic_client.options[:password]).and_return(http_request)
+    basic_client.stub(:basic_auth_http_conn => 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])
+    basic_client.uri.should == uri
+  end
+
+  it "sets up a http connection with options" do
+    http_conn = mock()
+    uri = mock()
+    host = mock()
+    port = mock()
+    uri.should_receive(:host).and_return(host)
+    uri.should_receive(:port).and_return(port)
+    Net::HTTP.should_receive(:new).with(host, port).and_return(http_conn)
+    http_conn.should_receive(:use_ssl=).with(basic_client.options[:use_ssl]).and_return(http_conn)
+    http_conn.should_receive(:verify_mode=).with(basic_client.options[:ssl_verify_mode]).and_return(http_conn)
+    basic_client.http_conn(uri).should == http_conn
+  end
+
+  it "returns a http connection" do
+    http_conn = mock()
+    uri = mock()
+    basic_client.should_receive(:uri).and_return(uri)
+    basic_client.should_receive(:http_conn).and_return(http_conn)
+    basic_client.basic_auth_http_conn.should == http_conn
+  end
+end

data/spec/jira/http_error_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe JIRA::HTTPError do
+
+  let(:response)  { 
+    response = mock("response") 
+    response.stub(:code => 401)
+    response.stub(:message => "A MESSAGE WOO")
+    response
+  }
+  subject { described_class.new(response) }
+
+  it "takes the response object as an argument" do
+    subject.response.should == response
+  end
+
+  it "has a code method" do
+    subject.code.should == response.code
+  end
+
+  it "returns code and class from message" do
+    subject.message.should == 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 = mock("response")
+    response.stub(: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|
+        oauth_client.options[key].should == defaults[:context_path] + defaults[key]
+      end
+    end
+
+    it "creates a Oauth::Consumer on initialize" do
+      oauth_client.consumer.class.should == OAuth::Consumer
+      oauth_client.consumer.key.should == oauth_client.key
+      oauth_client.consumer.secret.should == 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)
+      oauth_client.consumer.stub(:get_request_token => request_token)
+      oauth_client.get_request_token.should == request_token
+    end
+
+    it "allows setting the request token" do
+      token = mock()
+      OAuth::RequestToken.should_receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+
+      request_token = oauth_client.set_request_token('foo', 'bar')
+
+      request_token.should == token
+      oauth_client.request_token.should == token
+    end
+
+    it "allows setting the consumer key" do
+      oauth_client.key.should == 'foo'
+    end
+
+    it "allows setting the consumer secret" do
+      oauth_client.secret.should == 'bar'
+    end
+
+    describe "the access token" do
+
+      it "initializes" do
+        request_token = OAuth::RequestToken.new(oauth_client.consumer)
+        oauth_client.consumer.stub(:get_request_token => request_token)
+        mock_access_token = mock()
+        request_token.should_receive(:get_access_token).with(:oauth_verifier => 'abc123').and_return(mock_access_token)
+        oauth_client.init_access_token(:oauth_verifier => 'abc123')
+        oauth_client.access_token.should == 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 = mock()
+        OAuth::AccessToken.should_receive(:new).with(oauth_client.consumer, 'foo', 'bar').and_return(token)
+
+        access_token = oauth_client.set_access_token('foo', 'bar')
+
+        access_token.should         == token
+        oauth_client.access_token.should == token
+      end
+    end
+
+    describe "http" do
+      it "responds to the http methods" do
+        headers = mock()
+        mock_access_token = mock()
+        oauth_client.stub(:access_token => mock_access_token)
+        [:delete, :get, :head].each do |method|
+          mock_access_token.should_receive(method).with('/path', headers).and_return(response)
+          oauth_client.make_request(method, '/path', '', headers)
+        end
+        [:post, :put].each do |method|
+          mock_access_token.should_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 = mock()
+        access_token = mock()
+        access_token.should_receive(:send).with(:get, '/foo', headers).and_return(response)
+        oauth_client.stub(:access_token => access_token)
+        oauth_client.request(:get, '/foo', body, headers)
+      end
+    end
+  end
+end