jiraby 0.0.1

data/spec/jira_spec.rb

@@ -0,0 +1,314 @@
+require_relative 'spec_helper'
+require_relative 'data/jira_issues'
+
+describe Jiraby::Jira do
+  before(:each) do
+    @jira = Jiraby::Jira.new('localhost:9292', 'username', 'password')
+    todo_stub = RuntimeError.new("RestClient call needs a stub")
+    RestClient.stub(:get).and_raise(todo_stub)
+    RestClient.stub(:post).and_raise(todo_stub)
+  end
+
+  describe '#initialize' do
+    before(:each) do
+    end
+
+    it "raises an error for unknown API version" do
+      lambda do
+        Jiraby::Jira.new('jira.example.com', nil, nil, '1.0')
+      end.should raise_error
+    end
+
+    it "accepts valid API versions" do
+      jira = Jiraby::Jira.new('jira.example.com', nil, nil, '2')
+      jira.api_version.should == '2'
+    end
+
+    it "accepts URL beginning with http://" do
+      jira = Jiraby::Jira.new('http://jira.example.com', nil, nil)
+      jira.url.should == 'http://jira.example.com'
+    end
+
+    it "accepts URL beginning with https://" do
+      jira = Jiraby::Jira.new('https://jira.example.com', nil, nil)
+      jira.url.should == 'https://jira.example.com'
+    end
+
+    it "prepends http:// to the URL if needed" do
+      jira = Jiraby::Jira.new('jira.example.com', nil, nil)
+      jira.url.should == 'http://jira.example.com'
+    end
+  end #initialize
+
+  describe '#auth_url' do
+    it "returns the full REST authorization URL" do
+      jira = Jiraby::Jira.new('jira.example.com', nil, nil)
+      jira.auth_url.should == 'http://jira.example.com/rest/auth/1/session'
+    end
+  end #auth_url
+
+  describe '#not_implemented_in' do
+    it "raises an exception when API version is one of those listed" do
+      jira = Jiraby::Jira.new('jira.example.com', nil, nil, '2')
+      lambda do
+        jira.not_implemented_in('Issue creation', '2')
+      end.should raise_error
+    end
+
+    it "returns nil when API version is not one of those listed" do
+      jira = Jiraby::Jira.new('jira.example.com', nil, nil, '2')
+      jira.not_implemented_in('Issue creation', '2.0.alpha1').should be_nil
+    end
+  end #not_implemented_in
+
+  context "REST wrappers" do
+    before(:each) do
+      @path = 'fake/path'
+      @resource = Jiraby::JSONResource.new(@jira.base_url)
+      @jira.rest.stub(:[]).with(@path).and_return(@resource)
+    end
+
+    describe "#_path_with_query" do
+      it "returns path as-is if query is empty" do
+        @jira._path_with_query("user/search").should == "user/search"
+      end
+
+      it "returns path with query parameters appended" do
+        path = "user/search"
+        query = {:username => "someone", :startAt => 0, :maxResults => 10}
+        expect_path = "user/search?username=someone&startAt=0&maxResults=10"
+        @jira._path_with_query(path, query).should == expect_path
+      end
+    end
+
+    describe "#get" do
+      it "sends a GET request" do
+        @resource.should_receive(:get)
+        @jira.get(@path)
+      end
+    end
+
+    describe "#put" do
+      it "sends a PUT request" do
+        @resource.should_receive(:put)
+        @jira.put(@path, {})
+      end
+    end
+
+    describe "#post" do
+      it "sends a POST request" do
+        @resource.should_receive(:post)
+        @jira.post(@path, {})
+      end
+    end
+
+    describe "#delete" do
+      it "sends a DELETE request" do
+        @resource.should_receive(:delete)
+        @jira.delete(@path)
+      end
+    end
+  end # REST wrappers
+
+  describe '#issue' do
+    it "returns an Issue for valid issue key" do
+      @jira.issue('TST-1').should be_a Jiraby::Issue
+    end
+
+    it "raises ArgumentError if key is nil" do
+      lambda do
+        @jira.issue(nil)
+      end.should raise_error(ArgumentError, /Issue key is required/)
+    end
+
+    it "raises ArgumentError if key is empty" do
+      lambda do
+        @jira.issue(' ')
+      end.should raise_error(ArgumentError, /Issue key is required/)
+    end
+
+    it "raises IssueNotFound for invalid issue key" do
+      lambda do
+        @jira.issue('BOGUS-429')
+      end.should raise_error(Jiraby::IssueNotFound, /Issue 'BOGUS-429' not found/)
+    end
+  end #issue
+
+  describe '#create_issue' do
+    before(:each) do
+      @response = {
+        "id" => "10000",
+        "key" => "TST-24",
+        "self" => "http://www.example.com/jira/rest/api/2/issue/10000"
+      }
+      @response_json = Yajl::Encoder.encode(@response)
+    end
+
+    it "sends a POST request to the Jira API" do
+      #@jira.resource.should_receive(:post).and_return(@response_json)
+      @jira.create_issue('TST', 'Bug')
+    end
+
+    it "returns a Jiraby::Issue" do
+      RestClient.stub(:post => @response_json)
+    end
+  end #create_issue
+
+  describe "#enumerator" do
+    it "returns an Enumerator instance" do
+      enum = @jira.enumerator(:get, 'user/search')
+      enum.should be_an Enumerator
+    end
+
+    it "gets multiple pages by incrementing `startAt`" do
+      page1 = (1..50).map { |num| Jiraby::Entity.new(:key => "TST-#{num}") }
+      page2 = (51..100).map { |num| Jiraby::Entity.new(:key => "TST-#{num}") }
+      page3 = (101..129).map { |num| Jiraby::Entity.new(:key => "TST-#{num}") }
+      jql = 'project=TST'
+      params = {:jql => jql, :maxResults => 50}
+      @jira.should_receive(:post).
+        with('search', params.merge(:startAt => 0)).
+        once.and_return(page1)
+      @jira.should_receive(:post).
+        with('search', params.merge(:startAt => 50)).
+        once.and_return(page2)
+      @jira.should_receive(:post).
+        with('search', params.merge(:startAt => 100)).
+        once.and_return(page3)
+
+      items = @jira.enumerator(:post, 'search', {:jql => jql}).to_a
+    end
+
+    it "works when REST method returns an Entity" do
+      entity = Jiraby::Entity.new(
+        :issues => [
+          {:key => 'TST-1'},
+          {:key => 'TST-2'},
+          {:key => 'TST-3'},
+        ]
+      )
+      @jira.stub(:post).and_return(entity)
+
+      enum = @jira.enumerator(:post, 'fake_search', {}, 'issues')
+      enum.count.should == 3
+    end
+
+    it "works when REST method returns an Array of Entity" do
+      issue_keys = ['TST-1', 'TST-2', 'TST-3']
+      entities = issue_keys.map {|key| Jiraby::Entity.new(:key => key)}
+      @jira.stub(:post).and_return(entities)
+
+      enum = @jira.enumerator(:post, 'fake_search')
+      enum.count.should == 3
+      enum.to_a.should == entities
+    end
+
+    it "supports the .next method" do
+      # FIXME: For some reason, .next works fine in this test, but when
+      # connected to an actual Jira instance, it blows up with
+      #   SystemStackError: stack level too deep
+      issue_keys = ['TST-1', 'TST-2', 'TST-3']
+      entities = issue_keys.map {|key| Jiraby::Entity.new(:key => key)}
+      @jira.stub(:post).and_return(entities)
+
+      enum = @jira.enumerator(:post, 'fake_search')
+      enum.next.key.should == 'TST-1'
+      enum.next.key.should == 'TST-2'
+      enum.next.key.should == 'TST-3'
+    end
+
+    it "raises an exception if response is not Entity or Array" do
+      @jira.stub(:post).and_return('this string')
+      enum = @jira.enumerator(:post, 'fake_search')
+      lambda do
+        enum.first
+      end.should raise_error(RuntimeError, /Unexpected data: this string/)
+    end
+  end
+
+  # TODO: Populate some more test issues in order to properly test this
+  describe '#search' do
+    before(:each) do
+      @jira.stub(:issue => Jiraby::Issue.new(@jira))
+    end
+
+    it "something or other" do
+      response = @jira.post(:search, {:jql => 'project=FOO'})
+    end
+
+    it "returns an Enumerator" do
+      require 'enumerator'
+      @jira.search('project=TST').should be_an Enumerator
+    end
+
+    it "yields one Issue instance for each issue key" do
+      @jira.search('project=TST').each do |issue|
+        issue.should be_a Jiraby::Issue
+      end
+    end
+  end #search
+
+  # FIXME: Test this using the fake Jira instance
+  describe '#count' do
+    it "returns the number of issues matching a JQL query" do
+      search_results = Jiraby::Entity.new({'total' => 5})
+      @jira.should_receive(:post).
+        with('search', anything).
+        and_return(search_results)
+      @jira.count('key = TST-1').should == 5
+    end
+
+    it "returns a count of all issues when JQL is empty" do
+      search_results = Jiraby::Entity.new({'total' => 15})
+      @jira.stub(:post).and_return(search_results)
+
+      @jira.count('').should == 15
+    end
+  end #count
+
+  describe '#project' do
+    before(:each) do
+      #@jira.resource.stub(:get).and_return({})
+      #@jira.resource.stub(:get).with('project/TST').and_return(json_data('project_TST.json'))
+    end
+
+    it "returns project data" do
+      project = @jira.project('TST')
+      project.should be_a Jiraby::Project
+      # TODO: Verify attributes (requires fleshing out Project class)
+    end
+
+    it "raises ProjectNotFound if the project is not found" do
+      lambda do
+        @jira.project('BOGUS')
+      end.should raise_error(Jiraby::ProjectNotFound, /Project 'BOGUS' not found/)
+    end
+  end #project
+
+  describe '#project_meta' do
+    it "returns the project createmeta info if the project exists" do
+      meta = @jira.project_meta('TST')
+      expect_keys = ['name', 'self', 'issuetypes', 'id', 'avatarUrls', 'key']
+      meta.keys.sort.should == expect_keys.sort
+    end
+
+    it "raises ProjectNotFound if the project doesn't exist" do
+      RestClient.stub(:get).and_raise(RestClient::ResourceNotFound)
+      lambda do
+        @jira.project_meta('BOGUS')
+      end.should raise_error(Jiraby::ProjectNotFound, /Project 'BOGUS' not found/)
+    end
+  end #project_meta
+
+  describe '#field_mapping' do
+    it "returns a mapping of field IDs to names" do
+      @jira.field_mapping.should == {
+        'description' => "Description",
+        'summary' => "Summary",
+        'customfield_123' => "My Field",
+      }
+    end
+  end #field_mapping
+
+end
+

data/spec/json_resource_spec.rb

@@ -0,0 +1,222 @@
+require_relative 'spec_helper'
+require 'jiraby/jira'
+require 'jiraby/json_resource'
+
+describe Jiraby::JSONResource do
+  before(:each) do
+    @jr = Jiraby::JSONResource.new('http://example.com')
+  end
+
+  describe "#initialize" do
+    # Ensure that `options` contains appropriate JSON headers
+    def should_include_json_headers(options)
+      options.should include(:headers)
+      options[:headers].should include(:content_type)
+      options[:headers][:content_type].should == :json
+      options[:headers].should include(:accept)
+      options[:headers][:accept].should == :json
+    end
+
+    it "returns a JSONResource instance" do
+      jr = Jiraby::JSONResource.new('http://example.com')
+      jr.should be_a Jiraby::JSONResource
+    end
+
+    it "sets options[:headers] to send/receive JSON" do
+      jr = Jiraby::JSONResource.new('http://example.com')
+      should_include_json_headers(jr.options)
+    end
+
+    it "merges additional options" do
+      options = {:headers => {:foo => 'bar'}, :other => 'x'}
+      jr = Jiraby::JSONResource.new('http://example.com', options)
+      should_include_json_headers(jr.options)
+      jr.options.should include(:other)
+      jr.options[:other].should == 'x'
+      jr.options[:headers].should include(:foo)
+      jr.options[:headers][:foo].should == 'bar'
+    end
+  end #initialize
+
+  describe "#[]" do
+    it "returns a JSONResource instance" do
+      @jr['subpath'].should be_a Jiraby::JSONResource
+    end
+  end #[]
+
+  describe "#get" do
+    it "invokes #wrap with :_head" do
+      @jr.should_receive(:wrap).with(:_get, {})
+      @jr.get({})
+    end
+  end #get
+
+  describe "#delete" do
+    it "invokes #wrap with :_delete" do
+      @jr.should_receive(:wrap).with(:_delete, {})
+      @jr.delete({})
+    end
+  end #delete
+
+  describe "#head" do
+    it "invokes #wrap with :_head" do
+      @jr.should_receive(:wrap).with(:_head, {})
+      @jr.head({})
+    end
+  end #head
+
+  describe "#post" do
+    it "invokes #wrap_with_payload with :_post" do
+      @jr.should_receive(:wrap_with_payload).with(:_post, {}, {})
+      @jr.post({}, {})
+    end
+  end #post
+
+  describe "#put" do
+    it "invokes #wrap_with_payload with :_put" do
+      @jr.should_receive(:wrap_with_payload).with(:_put, {}, {})
+      @jr.put({}, {})
+    end
+  end #put
+
+  describe "#patch" do
+    it "invokes #wrap_with_payload with :_patch" do
+      @jr.should_receive(:wrap_with_payload).with(:_patch, {}, {})
+      @jr.patch({}, {})
+    end
+  end #patch
+
+  describe "#wrap" do
+    before(:each) do
+      @headers = {}
+    end
+
+    it "invokes a REST method with additional headers and block" do
+      @jr.should_receive(:_get).with(@headers).and_return('{}')
+      @jr.wrap(:_get, @headers)
+    end
+
+    it "returns the parsed JSON response as a hash" do
+      response_hash = {"status" => "ok"}
+      @jr.should_receive(:_get).
+        with(@headers).
+        and_return(response_hash.to_json)
+      result = @jr.wrap(:_get, @headers)
+      result.should == response_hash
+    end
+
+    it "when RestClient::Exception occurs, returns exception response as a hash" do
+      error_hash = {"error" => "Error message"}
+      exception = RestClient::Exception.new
+      exception.response = error_hash.to_json
+      got_response = @jr.wrap(:_get, {}) do
+        raise exception
+      end
+      got_response.should == error_hash
+    end
+  end #wrap
+
+  describe "#wrap_with_payload" do
+    before(:each) do
+      @payload = {"name" => "Foo"}
+      @headers = {}
+    end
+
+    it "when payload is a hash, it's encoded as JSON" do
+      @jr.should_receive(:_put).with(@payload.to_json, @headers).and_return('{}')
+      @jr.wrap_with_payload(:_put, @payload, @headers)
+    end
+
+    it "when payload is already a JSON string, it's sent as-is" do
+      json_payload = @payload.to_json
+      @jr.should_receive(:_put).with(json_payload, @headers).and_return('{}')
+      @jr.wrap_with_payload(:_put, json_payload, @headers)
+    end
+
+    it "invokes a REST method with additional headers and block" do
+      @headers['extra'] = 'something'
+      @jr.should_receive(:_put).with(@payload.to_json, @headers).and_return('{}')
+      @jr.wrap_with_payload(:_put, @payload, @headers)
+    end
+
+    it "returns the parsed JSON response as a hash" do
+      json_payload = @payload.to_json
+      response_hash = {"status" => "ok"}
+      @jr.should_receive(:_put).
+        with(json_payload, @headers).
+        and_return(response_hash.to_json)
+      result = @jr.wrap_with_payload(:_put, json_payload, @headers)
+      result.should == response_hash
+    end
+
+    it "when RestClient::Exception occurs, returns exception response as a hash" do
+      error_hash = {"error" => "Error message"}
+      exception = RestClient::Exception.new
+      exception.response = error_hash.to_json
+      got_response = @jr.wrap_with_payload(:_put, {}, {}) do
+        raise exception
+      end
+      got_response.should == error_hash
+    end
+  end #wrap_with_payload
+
+  describe "#parsed_response" do
+    it "returns a Hash if the response is a JSON object" do
+      hash = {
+        'foo' => 'bar',
+        'nested' => {
+          'a' => 'z',
+          'x' => 'y',
+        }
+      }
+      json = Yajl::Encoder.encode(hash)
+      @jr.parsed_response(json).should == hash
+    end
+
+    it "returns an Array of Hashes if the response is a JSON object array" do
+      hash_array = [{'foo' => 'bar'}, {'goo' => 'car'}]
+      json = Yajl::Encoder.encode(hash_array)
+      @jr.parsed_response(json).should == hash_array
+    end
+
+    it "returns nil if the response is an empty string" do
+      @jr.parsed_response("").should be_nil
+    end
+
+    it "raises JSONParseError when parsing fails" do
+      lambda do
+        @jr.parsed_response('bogus json')
+      end.should raise_error(Jiraby::JSONParseError)
+    end
+  end #parsed_response
+
+  describe "#maybe_error_response" do
+    it "yields the block return value if no exception occurs" do
+      expect_response = "The normalexpected response"
+      got_response = @jr.maybe_error_response do
+        expect_response
+      end
+      got_response.should == expect_response
+    end
+
+    it "re-raises RestClient::RequestTimeout" do
+      exception = RestClient::RequestTimeout.new
+      lambda do
+        @jr.maybe_error_response do
+          raise exception
+        end
+      end.should raise_error(exception)
+    end
+
+    it "yields the exception's response if a RestClient::Excception occurs" do
+      exception = RestClient::Exception.new
+      exception.response = "The exception response"
+      got_response = @jr.maybe_error_response do
+        raise exception
+      end
+      got_response.should == exception.response
+    end
+  end #maybe_error_response
+
+end # describe Jiraby::JSONResource
+