jira-ruby-dmg 0.1.10

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")
+    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 = double()
+        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 = double()
+        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 = double()
+      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)      { double("parent") }
+  let(:collection)  { double("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 = double('client')
+    foo = double('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 = double('foo')
+    client = double('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,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")
+    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+
+  let(:cookie_response) do
+    response = double("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 = double()
+    basic_auth_http_conn = double()
+    request = double()
+    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 "gets and sets cookies" do
+    body = ''
+    headers = double()
+    basic_auth_http_conn = double()
+    request = double()
+    basic_cookie_client.stub(:basic_auth_http_conn => basic_auth_http_conn)
+    request.should_receive(:basic_auth).with(basic_cookie_client.options[:username], basic_cookie_client.options[:password]).exactly(5).times.and_return(request)
+    cookie_response.should_receive(:get_fields).with('set-cookie').exactly(5).times
+    basic_auth_http_conn.should_receive(:request).exactly(5).times.with(request).and_return(cookie_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_cookie_client.make_request(method, '/path', nil, headers).should == cookie_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_cookie_client.make_request(method, '/path', body, headers).should == cookie_response
+    end
+  end
+
+
+  it "performs a basic http client request" do
+    body = nil
+    headers = double()
+    basic_auth_http_conn = double()
+    http_request = double()
+    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 = double()
+    uri = double()
+    host = double()
+    port = double()
+    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 = double()
+    uri = double()
+    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 = double("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 = double("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 = double()
+      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 = double()
+        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 = double()
+        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 = double()
+        mock_access_token = double()
+        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 = double()
+        access_token = double()
+        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

data/spec/jira/request_client_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe JIRA::RequestClient do
+
+  it "raises an exception for non success responses" do
+    response = double()
+    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(false)
+    rc = JIRA::RequestClient.new
+    rc.should_receive(:make_request).with(:get, '/foo', '', {}).and_return(response)
+    expect {
+      rc.request(:get, '/foo', '', {})
+    }.to raise_exception(JIRA::HTTPError)
+  end
+end

data/spec/jira/resource/attachment_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Attachment do
+
+  let(:client) { double() }
+
+  describe "relationships" do
+    subject {
+      JIRA::Resource::Attachment.new(client, :attrs => {
+        'author' => {'foo' => 'bar'}
+      })
+    }
+
+    it "has the correct relationships" do
+      subject.should have_one(:author, JIRA::Resource::User)
+      subject.author.foo.should == 'bar'
+    end
+  end
+
+end

data/spec/jira/resource/filter_spec.rb

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