jira-ruby 0.0.4 → 0.1.0

data/spec/integration/project_spec.rb

@@ -2,55 +2,55 @@ require 'spec_helper'
 
 describe JIRA::Resource::Project do
 
-  let(:client) do
-    client = JIRA::Client.new('foo', 'bar')
-    client.set_access_token('abc', '123')
-    client
-  end
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
 
-  let(:key) { "SAMPLEPROJECT" }
 
-  let(:expected_attributes) do
-    {
-      'self'   => "http://localhost:2990/jira/rest/api/2/project/SAMPLEPROJECT",
-      'key'    => key,
-      'name'   => "Sample Project for Developing RoR RESTful API"
-    }
-  end
+    let(:key) { "SAMPLEPROJECT" }
+
+    let(:expected_attributes) do
+      {
+        'self'   => "http://localhost:2990/jira/rest/api/2/project/SAMPLEPROJECT",
+        'key'    => key,
+        'name'   => "Sample Project for Developing RoR RESTful API"
+      }
+    end
 
-  let(:expected_collection_length) { 1 }
+    let(:expected_collection_length) { 1 }
 
-  it_should_behave_like "a resource"
-  it_should_behave_like "a resource with a collection GET endpoint"
-  it_should_behave_like "a resource with a singular GET endpoint"
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a collection GET endpoint"
+    it_should_behave_like "a resource with a singular GET endpoint"
 
-  describe "issues" do
+    describe "issues" do
+
+      it "returns all the issues" do
+        stub_request(:get, site_url + "/jira/rest/api/2/search?jql=project='SAMPLEPROJECT'").
+          to_return(:status => 200, :body => get_mock_response('project/SAMPLEPROJECT.issues.json'))
+        subject = client.Project.build('key' => key)
+        issues = subject.issues
+        issues.length.should == 11
+        issues.each do |issue|
+          issue.class.should == JIRA::Resource::Issue
+          issue.expanded?.should be_false
+        end
 
-    it "returns all the issues" do
-      stub_request(:get, "http://localhost:2990/jira/rest/api/2/search?jql=project='SAMPLEPROJECT'").
-        to_return(:status => 200, :body => get_mock_response('project/SAMPLEPROJECT.issues.json'))
-      subject = client.Project.build('key' => key)
-      issues = subject.issues
-      issues.length.should == 11
-      issues.each do |issue|
-        issue.class.should == JIRA::Resource::Issue
-        issue.expanded?.should be_false
       end
 
     end
 
-  end
+    it "returns a collection of components" do
 
-  it "returns a collection of components" do
+      stub_request(:get, site_url + described_class.singular_path(client, key)).
+        to_return(:status => 200, :body => get_mock_response('project/SAMPLEPROJECT.json'))
 
-    stub_request(:get, 'http://localhost:2990' + described_class.singular_path(client, key)).
-      to_return(:status => 200, :body => get_mock_response('project/SAMPLEPROJECT.json'))
+      subject = client.Project.find(key)
+      subject.components.length.should == 2
+      subject.components.each do |component|
+        component.class.should == JIRA::Resource::Component
+      end
 
-    subject = client.Project.find(key)
-    subject.components.length.should == 2
-    subject.components.each do |component|
-      component.class.should == JIRA::Resource::Component
     end
-
   end
 end

data/spec/integration/status_spec.rb

@@ -2,26 +2,26 @@ require 'spec_helper'
 
 describe JIRA::Resource::Status do
 
-  let(:client) do
-    client = JIRA::Client.new('foo', 'bar')
-    client.set_access_token('abc', '123')
-    client
-  end
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
 
-  let(:key) { "1" }
 
-  let(:expected_attributes) do
-    {
-      'self' => "http://localhost:2990/jira/rest/api/2/status/1",
-      'id' => key,
-      'name' => 'Open'
-    }
-  end
+    let(:key) { "1" }
 
-  let(:expected_collection_length) { 5 }
+    let(:expected_attributes) do
+      {
+        'self' => "http://localhost:2990/jira/rest/api/2/status/1",
+        'id' => key,
+        'name' => 'Open'
+      }
+    end
 
-  it_should_behave_like "a resource"
-  it_should_behave_like "a resource with a collection GET endpoint"
-  it_should_behave_like "a resource with a singular GET endpoint"
+    let(:expected_collection_length) { 5 }
 
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a collection GET endpoint"
+    it_should_behave_like "a resource with a singular GET endpoint"
+
+  end
 end

data/spec/integration/user_spec.rb

@@ -3,23 +3,23 @@ require 'spec_helper'
 describe JIRA::Resource::User do
 
 
-  let(:client) do
-    client = JIRA::Client.new('foo', 'bar')
-    client.set_access_token('abc', '123')
-    client
-  end
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
 
-  let(:key) { "admin" }
 
-  let(:expected_attributes) do
-    {
-      'self' => "http://localhost:2990/jira/rest/api/2/user?username=admin",
-      'name' => key,
-      'emailAddress' => 'admin@example.com'
-    }
-  end
+    let(:key) { "admin" }
 
-  it_should_behave_like "a resource"
-  it_should_behave_like "a resource with a singular GET endpoint"
+    let(:expected_attributes) do
+      {
+        'self' => "http://localhost:2990/jira/rest/api/2/user?username=admin",
+        'name' => key,
+        'emailAddress' => 'admin@example.com'
+      }
+    end
 
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a singular GET endpoint"
+
+  end
 end

data/spec/integration/version_spec.rb

@@ -3,41 +3,41 @@ require 'spec_helper'
 describe JIRA::Resource::Version do
 
 
-  let(:client) do
-    client = JIRA::Client.new('foo', 'bar')
-    client.set_access_token('abc', '123')
-    client
-  end
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+
+    let(:key) { "10000" }
 
-  let(:key) { "10000" }
+    let(:expected_attributes) do
+      {
+        'self' => "http://localhost:2990/jira/rest/api/2/version/10000",
+        'id'   => key,
+        'description' => "Initial version"
+      }
+    end
 
-  let(:expected_attributes) do
-    {
-      'self' => "http://localhost:2990/jira/rest/api/2/version/10000",
-      'id'   => key,
-      'description' => "Initial version"
+    let(:attributes_for_post) {
+      {"name" => "2.0", "project" => "SAMPLEPROJECT" }
+    }
+    let(:expected_attributes_from_post) {
+      { "id" => "10001", "name" => "2.0" }
     }
-  end
 
-  let(:attributes_for_post) {
-    {"name" => "2.0", "project" => "SAMPLEPROJECT" }
-  }
-  let(:expected_attributes_from_post) {
-    { "id" => "10001", "name" => "2.0" }
-  }
-
-  let(:attributes_for_put) {
-    {"name" => "2.0.0" }
-  }
-  let(:expected_attributes_from_put) {
-    { "id" => "10000", "name" => "2.0.0" }
-  }
-
-  it_should_behave_like "a resource"
-  it_should_behave_like "a resource with a singular GET endpoint"
-  it_should_behave_like "a resource with a DELETE endpoint"
-  it_should_behave_like "a resource with a POST endpoint"
-  it_should_behave_like "a resource with a PUT endpoint"
-  it_should_behave_like "a resource with a PUT endpoint that rejects invalid fields"
+    let(:attributes_for_put) {
+      {"name" => "2.0.0" }
+    }
+    let(:expected_attributes_from_put) {
+      { "id" => "10000", "name" => "2.0.0" }
+    }
 
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a singular GET endpoint"
+    it_should_behave_like "a resource with a DELETE endpoint"
+    it_should_behave_like "a resource with a POST endpoint"
+    it_should_behave_like "a resource with a PUT endpoint"
+    it_should_behave_like "a resource with a PUT endpoint that rejects invalid fields"
+
+  end
 end

data/spec/integration/worklog_spec.rb

@@ -3,53 +3,53 @@ require 'spec_helper'
 describe JIRA::Resource::Worklog do
 
 
-  let(:client) do
-    client = JIRA::Client.new('foo', 'bar')
-    client.set_access_token('abc', '123')
-    client
-  end
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+
+    let(:key) { "10000" }
 
-  let(:key) { "10000" }
+    let(:target) { JIRA::Resource::Worklog.new(client, :attrs => {'id' => '99999'}, :issue_id => '54321') }
 
-  let(:target) { JIRA::Resource::Worklog.new(client, :attrs => {'id' => '99999'}, :issue_id => '54321') }
+    let(:expected_collection_length) { 3 }
 
-  let(:expected_collection_length) { 3 }
+    let(:belongs_to) {
+      JIRA::Resource::Issue.new(client, :attrs => {
+        'id' => '10002', 'fields' => {
+          'comment' => {'comments' => []}
+        }
+      })
+    }
 
-  let(:belongs_to) {
-    JIRA::Resource::Issue.new(client, :attrs => {
-      'id' => '10002', 'fields' => {
-        'comment' => {'comments' => []}
+    let(:expected_attributes) do
+      {
+        'self' => "http://localhost:2990/jira/rest/api/2/issue/10002/worklog/10000",
+        'id'   => key,
+        'comment' => "Some epic work."
       }
-    })
-  }
-
-  let(:expected_attributes) do
-    {
-      'self' => "http://localhost:2990/jira/rest/api/2/issue/10002/worklog/10000",
-      'id'   => key,
-      'comment' => "Some epic work."
+    end
+
+    let(:attributes_for_post) {
+      {"timeSpent" => "2d"}
+    }
+    let(:expected_attributes_from_post) {
+      { "id" => "10001", "timeSpent" => "2d"}
     }
-  end
 
-  let(:attributes_for_post) {
-    {"timeSpent" => "2d"}
-  }
-  let(:expected_attributes_from_post) {
-    { "id" => "10001", "timeSpent" => "2d"}
-  }
-
-  let(:attributes_for_put) {
-    {"timeSpent" => "2d"}
-  }
-  let(:expected_attributes_from_put) {
-    { "id" => "10001", "timeSpent" => "4d"}
-  }
-
-  it_should_behave_like "a resource"
-  it_should_behave_like "a resource with a collection GET endpoint"
-  it_should_behave_like "a resource with a singular GET endpoint"
-  it_should_behave_like "a resource with a DELETE endpoint"
-  it_should_behave_like "a resource with a POST endpoint"
-  it_should_behave_like "a resource with a PUT endpoint"
+    let(:attributes_for_put) {
+      {"timeSpent" => "2d"}
+    }
+    let(:expected_attributes_from_put) {
+      { "id" => "10001", "timeSpent" => "4d"}
+    }
 
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a collection GET endpoint"
+    it_should_behave_like "a resource with a singular GET endpoint"
+    it_should_behave_like "a resource with a DELETE endpoint"
+    it_should_behave_like "a resource with a POST endpoint"
+    it_should_behave_like "a resource with a PUT endpoint"
+
+  end
 end

data/spec/jira/client_spec.rb

@@ -2,157 +2,187 @@ require 'spec_helper'
 
 describe JIRA::Client do
 
-  subject {JIRA::Client.new('foo','bar')}
+  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
-    subject.class.should == JIRA::Client
-  end
-
-  it "sets consumer key" do
-    subject.key.should == 'foo'
-  end
-
-  it "sets consumer secret" do
-    subject.secret.should == 'bar'
-  end
-
-  it "sets the non path default options" do
-    options = [:site, :signature_method, :private_key_file]
-    options.each do |key|
-      subject.options[key].should == JIRA::Client::DEFAULT_OPTIONS[key]
-    end
+    clients.each {|client| client.class.should == JIRA::Client }
   end
 
   it "allows the overriding of some options" do
-    # Check it overrides a given option ...
-    client = JIRA::Client.new('foo', 'bar', :site => 'http://foo.com/')
+    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 all authorization and rest paths" do
-    options = [:request_token_path, :authorize_path, :access_token_path, :rest_base_path]
+  it "prepends the context path to the rest base path" do
+    options = [:rest_base_path]
     defaults = JIRA::Client::DEFAULT_OPTIONS
     options.each do |key|
-      subject.options[key].should == defaults[:context_path] + defaults[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
-    subject.options.should be_frozen
+    clients.each { |client| client.options.should be_frozen }
   end
 
-  it "creates a Oauth::Consumer on initialize" do
-    subject.consumer.class.should == OAuth::Consumer
-    subject.consumer.key.should == subject.key
-    subject.consumer.secret.should == subject.secret
+  it "merges headers" do
+    clients.each { |client| client.send(:merge_default_headers, {}).should == {'Accept' => 'application/json'} }
   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(subject.consumer)
-    subject.consumer.stub(:get_request_token => request_token)
-    subject.get_request_token.should == request_token
-  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
 
-  it "is possible to set the request token" do
-    token = mock()
-    OAuth::RequestToken.should_receive(:new).with(subject.consumer, 'foo', 'bar').and_return(token)
+    specify "which have a corresponding auth type option" do
+      oauth_client.options[:auth_type].should == :oauth
+      basic_client.options[:auth_type].should == :basic
+    end
 
-    request_token = subject.set_request_token('foo', 'bar')
+    describe "like oauth" do
 
-    request_token.should         == token
-    subject.request_token.should == token
-  end
+      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')
 
-  describe "access token" do
+        access_token.should         == token
+        oauth_client.access_token.should == token
+      end
 
-    it "initializes the access token" do
-      request_token = OAuth::RequestToken.new(subject.consumer)
-      subject.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)
-      subject.init_access_token(:oauth_verifier => 'abc123')
-      subject.access_token.should == mock_access_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
 
-    it "raises an exception when accessing without initialisation" do
-      lambda do
-        subject.access_token
-      end.should raise_exception(JIRA::Client::UninitializedAccessTokenError, "init_access_token must be called before using the client")
+      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
 
-    it "is possible to set the access token" do
-      token = mock()
-      OAuth::AccessToken.should_receive(:new).with(subject.consumer, 'foo', 'bar').and_return(token)
-
-      access_token = subject.set_access_token('foo', 'bar')
+    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
 
-      access_token.should         == token
-      subject.access_token.should == token
+  describe "has http methods" do
+    before do
+      oauth_client.set_access_token("foo", "bar")
     end
 
-  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({})
 
-  describe "http" do
+      # 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)
 
-    it "responds to the http methods" do
-      mock_access_token = mock()
-      subject.stub(:access_token => mock_access_token)
       [:delete, :get, :head].each do |method|
-        mock_access_token.should_receive(:request).with(method, '/path', {'Accept' => 'application/json'}).and_return(response)
-        subject.send(method, '/path')
+        oauth_client.send(method, '/path', {})
+        basic_client.send(method, '/path', {})
       end
+
       [:post, :put].each do |method|
-        mock_access_token.should_receive(:request).with(method,
-                                                        '/path', '',
-                                                        {'Accept' => 'application/json', 'Content-Type' => 'application/json'}).and_return(response)
-        subject.send(method, '/path')
+        oauth_client.send(method, '/path', '', content_type_header)
+        basic_client.send(method, '/path', '', content_type_header)
       end
     end
 
-    it "performs a request" do
-      access_token = mock()
-      access_token.should_receive(:request).with(:get, '/foo').and_return(response)
-      subject.stub(:access_token => access_token)
-      subject.request(:get, '/foo')
-    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
 
-    it "raises an exception for non success responses" do
-      response = mock()
-      response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(false)
-      access_token = mock()
-      access_token.should_receive(:request).with(:get, '/foo').and_return(response)
-      subject.stub(:access_token => access_token)
-      
-      lambda do
-        subject.request(:get, '/foo')
-      end.should raise_exception(JIRA::HTTPError)
+      [: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(subject).and_return([])
-      subject.Project.all.should == []
+      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(subject, '123').and_return(find_result)
-      subject.Project.find('123').should == find_result
+      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