jira-ruby 0.0.2

data/lib/jira/resource/base_factory.rb

@@ -0,0 +1,44 @@
+module Jira
+  module Resource
+
+    # This is the base class for all the Jira resource factory instances.
+    class BaseFactory
+
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Return the name of the class which this factory generates, i.e. 
+      # Jira::Resource::FooFactory creates Jira::Resource::Foo instances.
+      def target_class
+        # Need to do a little bit of work here as Module.const_get doesn't work
+        # with nested class names, i.e. Jira::Resource::Foo.
+        #
+        # So create a method chain from the class componenets.  This code will
+        # unroll to:
+        #   Module.const_get('Jira').const_get('Resource').const_get('Foo')
+        #
+        target_class_name = self.class.name.sub(/Factory$/, '')
+        class_components = target_class_name.split('::')
+
+        class_components.inject(Module) do |mod, const_name|
+          mod.const_get(const_name)
+        end
+      end
+
+      def all
+        target_class.all(@client)
+      end
+
+      def find(key)
+        target_class.find(@client, key)
+      end
+
+      def build(attrs={})
+        target_class.build(@client, attrs)
+      end
+    end
+  end
+end

data/lib/jira/resource/component.rb

@@ -0,0 +1,15 @@
+module Jira
+  module Resource
+
+    class ComponentFactory < BaseFactory ; end
+
+    class Component < Base
+    
+      def self.key_attribute
+        :id
+      end
+
+    end
+
+  end
+end

data/lib/jira/resource/http_error.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+module Jira
+  module Resource
+
+    class HTTPError < StandardError
+      extend Forwardable
+
+      delegate [:message, :code] => :response
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+    end
+  end
+end

data/lib/jira/resource/issue.rb

@@ -0,0 +1,15 @@
+module Jira
+  module Resource
+
+    class IssueFactory < BaseFactory ; end
+
+    class Issue < Base
+
+      def self.key_attribute
+        :id
+      end
+
+    end
+
+  end
+end

data/lib/jira/resource/project.rb

@@ -0,0 +1,9 @@
+module Jira
+  module Resource
+
+    class ProjectFactory < BaseFactory ; end
+
+    class Project < Base ; end
+
+  end
+end

data/lib/jira/version.rb

@@ -0,0 +1,3 @@
+module Jira
+  VERSION = "0.0.2"
+end

data/lib/tasks/generate.rake

@@ -0,0 +1,16 @@
+namespace :jira do
+  desc "Generate a consumer key for your application"
+  task :generate_consumer_key do
+    #FIXME SERIOUSLY. THIS IS NOT A REAL SOLUTION. I FEEL SO UNCLEAN.
+    system("for i in {1..10}; do echo $RANDOM$RANDOM$RANDOM; done | md5 | awk '{ print \"You can use this as your consumer key: \" $0 }'")
+  end
+
+  desc "Run the system call to generate a RSA public certificate"
+  task :generate_public_cert do
+    puts "Executing 'openssl req -x509 -nodes -newkey rsa:1024 -sha1 -keyout rsakey.pem -out rsacert.pem'"
+    system("openssl req -x509 -nodes -newkey rsa:1024 -sha1 -keyout rsakey.pem -out rsacert.pem")
+    puts "Done. The RSA-SHA1 private keyfile is in the current directory: \'rsakey.pem\'."
+    puts "You will need to copy the following certificate into your application link configuration in Jira:"
+    system("cat rsacert.pem")
+  end
+end

data/spec/integration/component_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Jira::Resource::Component do
+
+
+  let(:client) do
+    client = Jira::Client.new('foo', 'bar')
+    client.set_access_token('abc', '123')
+    client
+  end
+
+  let(:expected_attributes) do
+    {
+      'self' => "http://localhost:2990/jira/rest/api/2/component/10000",
+      'id'   => "10000",
+      'name' => "Cheesecake"
+    }
+  end
+
+  before(:each) do
+    stub_request(:get,
+                 "http://localhost:2990/jira/rest/api/2/component/10000").
+                 to_return(:body => get_mock_response('component/10000.json'))
+    stub_request(:delete,
+                 "http://localhost:2990/jira/rest/api/2/component/10000").
+                 to_return(:body => nil)
+    stub_request(:post,
+                 "http://localhost:2990/jira/rest/api/2/component").
+                 with(:body => '{"name":"Test component","project":"SAMPLEPROJECT"}').
+                 to_return(:status => 201, :body => get_mock_response('component.post.json'))
+    stub_request(:put,
+                 "http://localhost:2990/jira/rest/api/2/component/10000").
+                 with(:body => '{"name":"Jammy"}').
+                 to_return(:status => 200, :body => get_mock_response('component/10000.put.json'))
+  end
+
+  it "should get a single component by id" do
+    component = client.Component.find(10000)
+
+    component.should have_attributes(expected_attributes)
+  end
+
+  it "builds and fetches single component" do
+    component = client.Component.build('id' => 10000)
+    component.fetch
+
+    component.should have_attributes(expected_attributes)
+  end
+
+  it "deletes a component" do
+    component = client.Component.build('id' => "10000")
+    component.delete.should be_true
+  end
+
+  it "saves a new component" do
+    component = client.Component.build
+    component.save({"name" => "Test component", "project" => "SAMPLEPROJECT"}).should be_true
+    component.id.should   == "10001"
+    component.name.should == "Test component"
+  end
+
+  it "saves an existing component" do
+    component = client.Component.build('id' => '10000')
+    component.fetch
+    component.save('name' => 'Jammy').should be_true
+    component.id.should == "10000"
+    component.name.should == "Jammy"
+  end
+
+end

data/spec/integration/issue_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Jira::Resource::Issue do
+
+  let(:client) do
+    client = Jira::Client.new('foo', 'bar')
+    client.set_access_token('abc', '123')
+    client
+  end
+
+  let(:expected_attributes) do
+    {
+      'self'   => "http://localhost:2990/jira/rest/api/2/issue/10002",
+      'key'    => "SAMPLEPROJECT-1",
+      'expand' => "renderedFields,names,schema,transitions,editmeta,changelog"
+    }
+  end
+
+  before(:each) do
+    stub_request(:get,
+                 "http://localhost:2990/jira/rest/api/2/issue/10002").
+                 to_return(:body => get_mock_response('issue/10002.json'))
+    stub_request(:delete,
+                 "http://localhost:2990/jira/rest/api/2/issue/10002").
+                 to_return(:body => nil)
+    stub_request(:post, "http://localhost:2990/jira/rest/api/2/issue").
+                 with(:body => '{"foo":"bar"}').
+                 to_return(:body => get_mock_response('issue.post.json'))
+    stub_request(:put, "http://localhost:2990/jira/rest/api/2/issue/10002").
+                 with(:body => '{"foo":"bar"}').
+                 to_return(:body => nil)
+    stub_request(:get,
+                 "http://localhost:2990/jira/rest/api/2/issue/99999").
+                 to_return(:status => 404, :body => '{"errorMessages":["Issue Does Not Exist"],"errors": {}}')
+  end
+
+  it "should get a single issue by key" do
+    issue = client.Issue.find('10002')
+
+    issue.should have_attributes(expected_attributes)
+  end
+
+  it "should handle issue not found" do
+    lambda do
+      issue = client.Issue.find('99999')
+    end.should raise_exception(Jira::Resource::HTTPError)
+  end
+
+  it "builds and fetches single issue" do
+    issue = client.Issue.build('id' => '10002')
+    issue.fetch
+
+    issue.should have_attributes(expected_attributes)
+  end
+
+  it "deletes an issue" do
+    issue = client.Issue.build('id' => "10002")
+    issue.delete.should be_true
+  end
+
+  it "should save a new record" do
+    subject = described_class.new(client)
+    subject.save('foo' => 'bar').should be_true
+  end
+
+  it "should save an existing record" do
+    subject = client.Issue.build('id' => '10002')
+    subject.fetch
+    subject.save('foo' => 'bar').should be_true
+  end
+
+end

data/spec/integration/project_spec.rb

@@ -0,0 +1,48 @@
+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
+
+  let(:expected_attributes) do
+    {
+      'self'   => "http://localhost:2990/jira/rest/api/2/project/SAMPLEPROJECT",
+      'key'    => "SAMPLEPROJECT",
+      'name'   => "Sample Project for Developing RoR RESTful API"
+    }
+  end
+
+  before(:each) do
+    stub_request(:get,
+                 "http://localhost:2990/jira/rest/api/2/project").
+                 to_return(:body => get_mock_response('project.json'))
+    stub_request(:get,
+                 "http://localhost:2990/jira/rest/api/2/project/SAMPLEPROJECT").
+                 to_return(:body => get_mock_response('project/SAMPLEPROJECT.json'))
+  end
+
+  it "should get all the projects" do
+    projects = client.Project.all
+    projects.length.should == 1
+
+    first = projects.first
+    first.should have_attributes(expected_attributes)
+  end
+
+  it "should get a single project by key" do
+    project = client.Project.find('SAMPLEPROJECT')
+
+    project.should have_attributes(expected_attributes)
+  end
+
+  it "builds and fetches single project" do
+    project = client.Project.build('key' => 'SAMPLEPROJECT')
+    project.fetch
+
+    project.should have_attributes(expected_attributes)
+  end
+end

data/spec/jira/client_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Jira::Client do
+
+  subject {Jira::Client.new('foo','bar')}
+
+  let(:response) do
+    response = mock("response")
+    response.stub(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+    response
+  end
+  
+  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 default options" do
+    Jira::Client::DEFAULT_OPTIONS.each do |key, value|
+      subject.options[key].should == value
+    end
+  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.options[:site].should == 'http://foo.com/'
+
+    # ... but leaves the rest intact
+    Jira::Client::DEFAULT_OPTIONS.keys.reject do |key|
+      key == :site
+    end.each do |key|
+      client.options[key].should == Jira::Client::DEFAULT_OPTIONS[key]
+    end
+
+    Jira::Client::DEFAULT_OPTIONS[:site].should_not == 'http://foo.com/'
+  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
+  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
+  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
+
+  it "is possible to set the request token" do
+    token = mock()
+    OAuth::RequestToken.should_receive(:new).with(subject.consumer, 'foo', 'bar').and_return(token)
+
+    request_token = subject.set_request_token('foo', 'bar')
+
+    request_token.should         == token
+    subject.request_token.should == token
+  end
+
+  describe "access token" do
+
+    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 "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")
+    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')
+
+      access_token.should         == token
+      subject.access_token.should == token
+    end
+
+  end
+
+  describe "http" do
+
+    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')
+      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')
+      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
+
+    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::Resource::HTTPError)
+    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 == []
+    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
+    end
+
+  end
+
+end