lita-github 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96790f8b19467db1f1534304ce67a2129c90e9e8
-  data.tar.gz: 3b99912b047f352b94457b769967458f7e9b5cd2
+  metadata.gz: 0cc46959df4d539d8ae57127dc70528eb0f8c693
+  data.tar.gz: d1a064ef57e8a8dd86e72cb4336b93f221ced29a
 SHA512:
-  metadata.gz: 1f2e72eb7d50a462147e7266ba607727af6442a8c2aec2b6cdd10fa4b944acd942a33d895a9e8b53694a742eac2dad1f7cc9a3246242458bdea497577a67af15
-  data.tar.gz: b75bc26eeea1a9863fdda9102f5be53a7b2d719c5f2dc5fc117b66fb4f44cb86bbd3c0eff8fedf3186f8ebe79a37ce48eb11124635ec42fea34ca0f5b55ea4f5
+  metadata.gz: 3e9d24e71ecc36a25262e459c924c60ed4f0c2667a0008a6122fe2fbde1ea23628c91620280677f28dadc2b48685ff43365ac247774b7d06a627dad867d10300
+  data.tar.gz: 0368bb271581c4aa7939a423c1cd16e62d6ec795d2f1df84701aed8bc7bc5c6e33bde356bb74f3d9d13e7e2f491fffd1b05f04d9b0ed2c23e864fac456919289

data/README.md

@@ -3,7 +3,6 @@ lita-github
 [![Build Status](https://img.shields.io/travis/PagerDuty/lita-github/master.svg)](https://travis-ci.org/PagerDuty/lita-github)
 [![MIT License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](https://tldrlegal.com/license/apache-license-2.0-(apache-2.0))
 [![RubyGems :: lita-github Gem Version](http://img.shields.io/gem/v/lita-github.svg)](https://rubygems.org/gems/lita-github)
-[![Code Climate Quality](https://img.shields.io/codeclimate/github/PagerDuty/lita-github.svg)](https://codeclimate.com/github/PagerDuty/lita-github)
 [![Code Climate Coverage](http://img.shields.io/codeclimate/coverage/github/PagerDuty/lita-github.svg)](https://codeclimate.com/github/PagerDuty/lita-github)
 
 Copyright 2014 PagerDuty, Inc.
@@ -57,6 +56,8 @@ Here is the current functionality:
   * **Note:** This method is disabled by default, you need to enable it by setting `config.handlers.github.repo_delete_enabled = true` in your configuration file
 
 ### Github PR Handler
+* `!gh pr info #42 PagerDuty/lita-github`
+  * output some information about the PR. Such as: state (open|closed|merged), build status, user who opened, user who merged, amongst others...
 * `!gh pr merge #42 PagerDuty/lita-github` or `!shipit #42 PagerDuty/lita-github`
   * This merges the specified pull request
   * This method can be disabled by setting `config.handlers.github.pr_merge_enabled = false` in your configuration file

data/lib/lita-github/version.rb

@@ -16,6 +16,6 @@
 
 # Administer your Hub of Gits with Lita!
 module LitaGithub
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
   MAJ, MIN, REV = VERSION.split('.').map(&:to_i)
 end

data/lib/lita/handlers/github_pr.rb

@@ -35,6 +35,13 @@ module Lita
 
       on :loaded, :setup_octo # from LitaGithub::Octo
 
+      route(
+        /#{LitaGithub::R::A_REG}pr\s+?info\s+?#(?<pr>\d+?)\s+?#{LitaGithub::R::REPO_REGEX}/,
+        :pr_info,
+        command: true,
+        help: { 'gh pr info #42 PagerDuty/lita-github' => 'show some information about the pull request' }
+      )
+
       route(
         /(?:#{LitaGithub::R::A_REG}(?:pr merge|shipit)|shipit)\s+?#(?<pr>\d+?)\s+?#{LitaGithub::R::REPO_REGEX}/,
         :pr_merge, command: true, confirmation: true,
@@ -45,18 +52,36 @@ module Lita
         }
       )
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def pr_info(response)
+        org, repo, pr = pr_match(response)
+        full_name = rpo(org, repo)
+
+        pr_h = pull_request(full_name, pr)
+        return response.reply(t('not_found', pr: pr, org: org, repo: repo)) if pr_h[:fail] && pr_h[:not_found]
+
+        info = build_pr_info(pr_h[:pr], full_name)
+        comparison_url = "https://github.com/#{full_name}/compare/#{info[:base_sha]}...#{info[:pr_sha]}"
+        info.merge!(repo: full_name, compare: comparison_url)
+
+        reply = t('pr_info.header', info) << t('pr_info.status', info)
+        reply << (info[:state] == :merged ? t('pr_info.merged', info) : t('pr_info.mergeable', info))
+        reply << t('pr_info.commit_info', info) << t('pr_info.comments', info)
+
+        response.reply(reply)
+      end
+
       def pr_merge(response)
         return response.reply(t('method_disabled')) if func_disabled?(__method__)
         org, repo, pr = pr_match(response)
+        fullname = rpo(org, repo)
 
-        begin
-          pr_obj = octo.pull_request(rpo(org, repo), pr)
-        rescue Octokit::NotFound
-          return response.reply(t('not_found', pr: pr, org: org, repo: repo))
-        end
+        pr_h = pull_request(fullname, pr)
+        return response.reply(t('not_found', pr: pr, org: org, repo: repo)) if pr_h[:fail] && pr_h[:not_found]
 
-        branch = pr_obj[:head][:ref]
-        title = pr_obj[:title]
+        branch = pr_h[:pr][:head][:ref]
+        title = pr_h[:pr][:title]
         commit = "Merge pull request ##{pr} from #{org}/#{branch}\n\n#{title}"
 
         status = merge_pr(org, repo, pr, commit)
@@ -70,6 +95,8 @@ module Lita
           response.reply(t('pr_merge.fail', pr: pr, title: title, url: url, msg: status[:message]))
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
       private
 
@@ -78,6 +105,29 @@ module Lita
         [organization(md['org']), md['repo'], md['pr']]
       end
 
+      def pull_request(full_name, pr_num)
+        ret = { fail: false, not_found: false }
+        begin
+          ret[:pr] = octo.pull_request(full_name, pr_num)
+        rescue Octokit::NotFound
+          ret[:fail] = true
+          ret[:not_found] = true
+        end
+        ret
+      end
+
+      def build_pr_info(pr_obj, full_name)
+        info = {}
+
+        build_pr_header!(info, pr_obj)
+        build_pr_commitinfo!(info, pr_obj)
+        build_pr_status!(info, pr_obj, full_name)
+        build_pr_merge!(info, pr_obj)
+        build_pr_comments!(info, pr_obj)
+
+        info
+      end
+
       def merge_pr(org, repo, pr, commit)
         status = nil
         # rubocop:disable Lint/HandleExceptions
@@ -89,6 +139,50 @@ module Lita
         # rubocop:enable Lint/HandleExceptions
         status
       end
+
+      def build_pr_header!(info, pr_obj)
+        info[:title]            = pr_obj[:title]
+        info[:number]           = pr_obj[:number]
+        info[:url]              = pr_obj[:html_url]
+        info
+      end
+
+      def build_pr_commitinfo!(info, pr_obj)
+        info[:commits]          = pr_obj[:commits]
+        info[:plus]             = pr_obj[:additions]
+        info[:minus]            = pr_obj[:deletions]
+        info[:changed_files]    = pr_obj[:changed_files]
+        info[:pr_sha]           = pr_obj[:head][:sha]
+        info[:base_sha]         = pr_obj[:base][:sha]
+        info[:pr_sha_short]     = info[:pr_sha].slice(0, 7)
+        info
+      end
+
+      def build_pr_status!(info, pr_obj, full_name)
+        user = octo.user(pr_obj[:user][:login])
+        info[:user]             = pr_obj[:user][:login]
+        info[:user]             << " (#{user[:name]})" if user.key?(:name)
+        info[:state]            = pr_obj[:merged] ? :merged : pr_obj[:state].to_sym
+        info[:state_str]        = pr_obj[:merged] ? 'Merged' : pr_obj[:state].capitalize
+        info[:build_status]     = octo.combined_status(full_name, info[:pr_sha])[:state]
+        info
+      end
+
+      def build_pr_merge!(info, pr_obj)
+        info[:mergeable]        = pr_obj[:mergeable]
+        if info[:state] == :merged
+          merger = octo.user(pr_obj[:merged_by][:login])
+          info[:merged_by] = pr_obj[:merged_by][:login]
+          info[:merged_by] << " (#{merger[:name]})" if merger.key?(:name)
+        end
+        info
+      end
+
+      def build_pr_comments!(info, pr_obj)
+        info[:review_comments]  = pr_obj[:review_comments]
+        info[:comments]         = pr_obj[:comments]
+        info
+      end
     end
 
     Lita.register_handler(GithubPR)

data/lib/lita/handlers/github_repo.rb

@@ -89,9 +89,10 @@ module Lita
 
       def repo_info(response)
         org, repo = repo_match(response)
+        full_name = rpo(org, repo)
         opts = {}
-        r_obj = octo.repository(rpo(org, repo))
-        p_obj = octo.pull_requests(rpo(org, repo))
+        r_obj = octo.repository(full_name)
+        p_obj = octo.pull_requests(full_name)
 
         opts[:repo]             = r_obj[:full_name]
         opts[:description]      = r_obj[:description]
@@ -116,6 +117,7 @@ module Lita
         o
       end
 
+      # TODO: convert this to a mixin method for reuse
       def repo_match(response)
         md = response.match_data
         [organization(md['org']), md['repo']]
@@ -159,12 +161,13 @@ module Lita
       end
 
       def create_repo(org, repo, opts)
+        full_name = rpo(org, repo)
         reply = nil
         begin
           octo.create_repository(repo, opts)
         ensure
-          if repo?(rpo(org, repo))
-            repo_url = "https://github.com/#{rpo(org, repo)}"
+          if repo?(full_name)
+            repo_url = "https://github.com/#{full_name}"
             reply = t('repo_create.pass', org: org, repo: repo, repo_url: repo_url)
           else
             reply = t('repo_create.fail', org: org, repo: repo)
@@ -174,11 +177,12 @@ module Lita
       end
 
       def delete_repo(org, repo)
+        full_name = rpo(org, repo)
         reply = nil
         begin
-          octo.delete_repository(rpo(org, repo))
+          octo.delete_repository(full_name)
         ensure
-          if repo?(rpo(org, repo))
+          if repo?(full_name)
             reply = t('repo_delete.fail', org: org, repo: repo)
           else
             reply = t('repo_delete.pass', org: org, repo: repo)

data/locales/en.yml

@@ -22,6 +22,13 @@ en:
         method_disabled: "Sorry, this function has either been disabled or not enabled in the config"
         exception: "An unexpected exception was hit during the GitHub API operation. Please make sure all arguments are proper and try again, or try checking the GitHub status (gh status)"
         not_found: "Pull request #%{pr} on %{org}/%{repo} not found"
+        pr_info:
+          header: "%{repo} #%{number}: %{title} :: %{url}\n"
+          status: "Opened By: %{user} | State: %{state_str} | Build: %{build_status}"
+          merged: " | Merged By: %{merged_by}\n"
+          mergeable: " | Mergeable: %{mergeable}\n"
+          commit_info: "Head: %{pr_sha_short} | Commits: %{commits} (+%{plus}/-%{minus}) :: %{compare}\n"
+          comments: "PR Comments: %{comments} | Code Comments: %{review_comments}\n"
         pr_merge:
           pass: "Merged pull request #%{pr} from %{org}/%{branch}\n%{title}"
           fail: "Failed trying to merge PR #%{pr} (%{title}) :: %{url}\nMessage: %{msg}"

data/spec/unit/lita/handlers/github_pr_spec.rb

@@ -10,8 +10,12 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
   let(:github_pr) { Lita::Handlers::GithubPR.new('robot') }
   let(:github_org) { 'GrapeDuty' }
   let(:github_repo) { 'lita-test' }
+  let(:full_name) { "#{github_org}/#{github_repo}" }
   let(:disabled_reply) { 'Sorry, this function has either been disabled or not enabled in the config' }
 
+  ####
+  # Helper Methods
+  ####
   describe '.pr_match' do
     it 'should return the content of the match data' do
       mock_md = { 'org' => github_org, 'repo' => github_repo, 'pr' => 42 }
@@ -20,6 +24,351 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     end
   end
 
+  describe '.merge_pr' do
+    before do
+      @octo_obj = double('Octokit::Client', merge_pull_request: :ohai)
+      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+    end
+
+    let(:pr_num) { 42 }
+    let(:ref) { '1234567890' }
+
+    context 'when all goes to plan' do
+      it 'should call octo.merge_pull_request with the proper args' do
+        expect(@octo_obj).to receive(:merge_pull_request).with(full_name, pr_num, ref)
+          .and_return(:ohai)
+        github_pr.send(:merge_pr, github_org, github_repo, pr_num, ref)
+      end
+
+      it 'should return the return of octo.merge_pull_request' do
+        x = github_pr.send(:merge_pr, github_org, github_repo, 42, '1234567890')
+        expect(x).to eql :ohai
+      end
+    end
+
+    context 'when the merging throws an exception' do
+      before do
+        allow(@octo_obj).to receive(:merge_pull_request).with(full_name, pr_num, ref)
+          .and_raise(StandardError.new)
+      end
+
+      it 'should return nil' do
+        expect(github_pr.send(:merge_pr, github_org, github_repo, pr_num, ref)).to be_nil
+      end
+    end
+  end
+
+  describe '.build_pr_header!' do
+    let(:pr_obj) do
+      { title: 'abc123', number: 42, html_url: 'https://github.com/' }
+    end
+
+    it 'should return a Hash' do
+      info = {}
+      x = github_pr.send(:build_pr_header!, info, pr_obj)
+      expect(x).to be_an_instance_of Hash
+    end
+
+    it 'should set the :title key' do
+      info = {}
+      github_pr.send(:build_pr_header!, info, pr_obj)
+      expect(info[:title]).to eql pr_obj[:title]
+    end
+
+    it 'should set the :number key' do
+      info = {}
+      github_pr.send(:build_pr_header!, info, pr_obj)
+      expect(info[:number]).to eql pr_obj[:number]
+    end
+
+    it 'should set the :url key' do
+      info = {}
+      github_pr.send(:build_pr_header!, info, pr_obj)
+      expect(info[:url]).to eql pr_obj[:html_url]
+    end
+  end
+
+  describe '.build_pr_commitinfo!' do
+    let(:pr_obj) do
+      {
+        commits: 1, additions: 4, deletions: 2, changed_files: 1,
+        head: { sha: '1234567890' }, base: { sha: '0987654321' }
+      }
+    end
+    let(:info) { {} }
+
+    it 'should return a Hash' do
+      expect(github_pr.send(:build_pr_commitinfo!, info, pr_obj)).to be_an_instance_of Hash
+    end
+
+    it 'should set the :commits key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:commits]).to eql pr_obj[:commits]
+    end
+
+    it 'should set the :plus key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:plus]).to eql pr_obj[:additions]
+    end
+
+    it 'should set the :minus key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:minus]).to eql pr_obj[:deletions]
+    end
+
+    it 'should set the :changed_files key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:changed_files]).to eql pr_obj[:changed_files]
+    end
+
+    it 'should set the :pr_sha key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:pr_sha]).to eql pr_obj[:head][:sha]
+    end
+
+    it 'should be set the :base_sha key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:base_sha]).to eql pr_obj[:base][:sha]
+    end
+
+    it 'should set the :pr_sha_short key' do
+      github_pr.send(:build_pr_commitinfo!, info, pr_obj)
+      expect(info[:pr_sha_short]).to eql info[:pr_sha].slice(0, 7)
+    end
+  end
+
+  describe '.build_pr_status!' do
+    before do
+      @user_obj = { name: 'Tim Heckman' }
+      @cs_obj = { state: 'success' }
+      @octo_obj = double('Octokit::Client', user: @user_obj, combined_status: @cs_obj)
+      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+    end
+
+    let(:pr_obj) do
+      {
+        user: { login: 'theckman' }, state: 'closed', merged: true, pr_sha: '1234567890'
+      }
+    end
+    let(:info) { { pr_sha: '1234567890' } }
+
+    it 'should return an instance of Hash' do
+      expect(github_pr.send(:build_pr_status!, info, pr_obj, full_name))
+        .to be_an_instance_of Hash
+    end
+
+    it 'should call octo.user' do
+      expect(@octo_obj).to receive(:user).with('theckman')
+      github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+    end
+
+    it 'should call octo.combined_status and set it to :build_status' do
+      expect(@octo_obj).to receive(:combined_status)
+        .with(full_name, '1234567890')
+        .and_return(@cs_obj)
+      github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+      expect(info[:build_status]).to eql 'success'
+    end
+
+    context 'when user has a name set' do
+      it 'should include the name' do
+        github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+        expect(info[:user]).to eql 'theckman (Tim Heckman)'
+      end
+    end
+
+    context 'when the PR has been merged' do
+      it 'should set the :state key to :merged' do
+        github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+        expect(info[:state]).to eql :merged
+      end
+
+      it 'should set the :state_str to "Merged"' do
+        github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+        expect(info[:state_str]).to eql 'Merged'
+      end
+    end
+
+    context 'when user has no name set' do
+      before do
+        @octo_obj = double('Octokit::Client', user: {}, combined_status: @cs_obj)
+        allow(github_pr).to receive(:octo).and_return(@octo_obj)
+      end
+
+      it 'should not include the real name parenthesis' do
+        github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+        expect(info[:user]).to eql 'theckman'
+      end
+    end
+
+    context 'when PR not merged' do
+      context 'when status is open' do
+        let(:pr_obj) do
+          {
+            user: { login: 'theckman' }, state: 'open', merged: false
+          }
+        end
+
+        it 'should set the :state key to :open' do
+          github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+          expect(info[:state]).to eql :open
+        end
+
+        it 'should set the :state_str to "Open"' do
+          github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+          expect(info[:state_str]).to eql 'Open'
+        end
+      end
+
+      context 'when status is closed' do
+        let(:pr_obj) do
+          {
+            user: { login: 'theckman' }, state: 'closed', merged: false
+          }
+        end
+
+        it 'should set the :state key to :closed' do
+          github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+          expect(info[:state]).to eql :closed
+        end
+
+        it 'should set the :state_str to "Closed"' do
+          github_pr.send(:build_pr_status!, info, pr_obj, full_name)
+          expect(info[:state_str]).to eql 'Closed'
+        end
+      end
+    end
+  end
+
+  describe '.build_pr_merge!' do
+    before do
+      @user_obj = { name: 'Tim Heckman' }
+      @octo_obj = double('Octokit::Client', user: @user_obj)
+      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+    end
+
+    let(:pr_obj) do
+      {
+        state: :open, mergeable: true
+      }
+    end
+    let(:info) { { state: :open } }
+
+    it 'should return an instance of Hash' do
+      expect(github_pr.send(:build_pr_merge!, info, pr_obj))
+        .to be_an_instance_of Hash
+    end
+
+    it 'should set the :mergable key' do
+      github_pr.send(:build_pr_merge!, info, pr_obj)
+      expect(info[:mergeable]).to eql true
+    end
+
+    context 'when not merged' do
+      it 'should not set the :merged_by key' do
+        github_pr.send(:build_pr_merge!, info, pr_obj)
+        expect(info.key?(:merged_by)).to be_falsey
+      end
+    end
+
+    context 'when merged' do
+      let(:pr_obj) do
+        {
+          state: :merged, mergeable: nil, merged_by: { login: 'theckman' }
+        }
+      end
+      let(:info) { { state: :merged } }
+
+      it 'should grab some user info about who merged' do
+        expect(@octo_obj).to receive(:user).with('theckman').and_return(@user_obj)
+        github_pr.send(:build_pr_merge!, info, pr_obj)
+      end
+
+      context 'when user has a name field' do
+        it 'should set the :merged_by key' do
+          github_pr.send(:build_pr_merge!, info, pr_obj)
+          expect(info[:merged_by]).to eql 'theckman (Tim Heckman)'
+        end
+      end
+
+      context 'when the user has no name field' do
+        before do
+          @user_obj = {}
+          @octo_obj = double('Octokit::Client', user: @user_obj)
+          allow(github_pr).to receive(:octo).and_return(@octo_obj)
+        end
+
+        it 'should set the :merged_by key without parenthesis' do
+          github_pr.send(:build_pr_merge!, info, pr_obj)
+          expect(info[:merged_by]).to eql 'theckman'
+        end
+      end
+    end
+  end
+
+  describe '.build_pr_comments!' do
+    let(:pr_obj) { { comments: 1, review_comments: 3 } }
+    let(:info) { {} }
+
+    it 'should return a Hash' do
+      expect(github_pr.send(:build_pr_comments!, info, pr_obj)).to be_an_instance_of Hash
+    end
+
+    it 'should set the :comments key' do
+      github_pr.send(:build_pr_comments!, info, pr_obj)
+      expect(info[:comments]).to eql 1
+    end
+
+    it 'should set the :review_comments key' do
+      github_pr.send(:build_pr_comments!, info, pr_obj)
+      expect(info[:review_comments]).to eql 3
+    end
+  end
+
+  describe '.build_pr_info' do
+    before do
+      allow(github_pr).to receive(:build_pr_header!).and_return(nil)
+      allow(github_pr).to receive(:build_pr_commitinfo!).and_return(nil)
+      allow(github_pr).to receive(:build_pr_status!).and_return(nil)
+      allow(github_pr).to receive(:build_pr_merge!).and_return(nil)
+      allow(github_pr).to receive(:build_pr_comments!).and_return(nil)
+    end
+
+    let(:pr_obj) { :ohai }
+
+    it 'should return an instance of Hash' do
+      expect(github_pr.send(:build_pr_info, pr_obj, full_name)).to be_an_instance_of Hash
+    end
+
+    it 'should call .build_pr_header!' do
+      expect(github_pr).to receive(:build_pr_header!).with({}, pr_obj).and_return(nil)
+      github_pr.send(:build_pr_info, pr_obj, full_name)
+    end
+
+    it 'should call .build_pr_commitinfo!' do
+      expect(github_pr).to receive(:build_pr_commitinfo!).with({}, pr_obj).and_return(nil)
+      github_pr.send(:build_pr_info, pr_obj, full_name)
+    end
+
+    it 'should call .build_pr_status!' do
+      expect(github_pr).to receive(:build_pr_status!).with({}, pr_obj, full_name).and_return(nil)
+      github_pr.send(:build_pr_info, pr_obj, full_name)
+    end
+
+    it 'should call .build_pr_merge!' do
+      expect(github_pr).to receive(:build_pr_merge!).with({}, pr_obj).and_return(nil)
+      github_pr.send(:build_pr_info, pr_obj, full_name)
+    end
+
+    it 'should call .build_pr_comments!' do
+      expect(github_pr).to receive(:build_pr_comments!).with({}, pr_obj).and_return(nil)
+      github_pr.send(:build_pr_info, pr_obj, full_name)
+    end
+  end
+
+  ####
+  # Handlers
+  ####
   describe '.merge_pr' do
     before do
       @merge_status = { sha: 'abc456', merged: true, message: 'Pull Request successfully merged' }
@@ -49,6 +398,75 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     end
   end
 
+  describe '.pr_info' do
+    context 'when PR is not merged' do
+      before do
+        @pr_info = {
+          title: 'Test Pull Request (Not Real)', number: 42,
+          url: "https://github.com/#{github_org}/#{github_repo}/pulls/42",
+          commits: 1, plus: 42, minus: 0, changed_files: 1, pr_sha: '1234567890',
+          base_sha: '0987654321', pr_sha_short: '1234567', user: 'theckman (Tim Heckman)',
+          state: :open, state_str: 'Open', build_status: 'success', mergeable: true,
+          review_comments: 2, comments: 1
+        }
+        @pr_resp = { fail: false, not_found: false, pr: @pr_info }
+        allow(github_pr).to receive(:pull_request).and_return(@pr_resp)
+        allow(github_pr).to receive(:build_pr_info).and_return(@pr_info)
+      end
+
+      it 'should reply with the expeced output' do
+        r = 'GrapeDuty/lita-test #42: Test Pull Request (Not Real) :: ' \
+              "https://github.com/GrapeDuty/lita-test/pulls/42\n" \
+              "Opened By: theckman (Tim Heckman) | State: Open | Build: success | Mergeable: true\n" \
+              'Head: 1234567 | Commits: 1 (+42/-0) :: ' \
+              "https://github.com/GrapeDuty/lita-test/compare/0987654321...1234567890\n" \
+              "PR Comments: 1 | Code Comments: 2\n"
+        send_command("gh pr info #42 #{github_org}/#{github_repo}")
+        expect(replies.last).to eql r
+      end
+    end
+
+    context 'when the PR has been merged' do
+      before do
+        @pr_info = {
+          title: 'Test Pull Request (Not Real)', number: 42,
+          url: "https://github.com/#{github_org}/#{github_repo}/pulls/42",
+          commits: 1, plus: 42, minus: 0, changed_files: 1, pr_sha: '1234567890',
+          base_sha: '0987654321', pr_sha_short: '1234567', user: 'theckman (Tim Heckman)',
+          state: :merged, state_str: 'Merged', build_status: 'success', mergeable: true,
+          merged_by: 'theckman (Tim Heckman)', review_comments: 2, comments: 1
+        }
+        @pr_resp = { fail: false, not_found: false, pr: @pr_info }
+        allow(github_pr).to receive(:pull_request).and_return(@pr_resp)
+        allow(github_pr).to receive(:build_pr_info).and_return(@pr_info)
+      end
+
+      it 'should reply with the expeced output' do
+        r = 'GrapeDuty/lita-test #42: Test Pull Request (Not Real) :: ' \
+              "https://github.com/GrapeDuty/lita-test/pulls/42\n" \
+              'Opened By: theckman (Tim Heckman) | State: Merged | Build: success | ' \
+              "Merged By: theckman (Tim Heckman)\n" \
+              'Head: 1234567 | Commits: 1 (+42/-0) :: ' \
+              "https://github.com/GrapeDuty/lita-test/compare/0987654321...1234567890\n" \
+              "PR Comments: 1 | Code Comments: 2\n"
+        send_command("gh pr info #42 #{github_org}/#{github_repo}")
+        expect(replies.last).to eql r
+      end
+    end
+
+    context 'when the PR was not found' do
+      before do
+        @pr_resp = { fail: true, not_found: true, pr: @pr_info }
+        allow(github_pr).to receive(:pull_request).and_return(@pr_resp)
+      end
+
+      it 'should reply with the not found error' do
+        send_command("gh pr info #42 #{github_org}/#{github_repo}")
+        expect(replies.last).to eql 'Pull request #42 on GrapeDuty/lita-test not found'
+      end
+    end
+  end
+
   describe '.pr_merge' do
     before do
       @cfg_obj = double('Lita::Configuration', pr_merge_enabled: true)
@@ -66,7 +484,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
         allow(github_pr).to receive(:func_disabled?).and_return(true)
       end
 
-      it 'should no-op and say such if the command is disabled' do
+      it 'should no-op and say such' do
         send_command("shipit #42 #{github_org}/#{github_repo}")
         expect(replies.last).to eql disabled_reply
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-github
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Tim Heckman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-29 00:00:00.000000000 Z
+date: 2014-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -218,3 +218,4 @@ test_files:
 - spec/unit/lita/handlers/github_pr_spec.rb
 - spec/unit/lita/handlers/github_repo_spec.rb
 - spec/unit/lita/handlers/github_spec.rb
+has_rdoc: