reviewlette 0.0.9 → 1.0.0

data/lib/reviewlette/github_connection.rb

@@ -1,42 +1,46 @@
-require 'yaml'
 require 'octokit'
 
-class GithubConnection
-
-  attr_accessor :client, :repo
-
-  def initialize(repo, token)
-    @client  = Octokit::Client.new(access_token: token)
-    @repo    = repo
-  end
-
-  def list_pulls
-    @client.pull_requests(@repo)
+class Reviewlette
+  class GithubConnection
+    attr_accessor :client, :repo
+
+    def initialize(repo, token)
+      @client  = Octokit::Client.new(access_token: token)
+      @repo    = repo
+    end
+
+    def pull_requests
+      @client.pull_requests(@repo)
+    end
+
+    def labels(issue)
+      @client.labels_for_issue(@repo, issue).map(&:name)
+    end
+
+    def add_assignees(number, assignees)
+      @client.update_issue(@repo, number, assignees: assignees)
+    end
+
+    def comment_reviewers(number, reviewers, trello_card)
+      assignees = reviewers.map { |r| "@#{r.github_handle}" }.join(' and ')
+
+      comment = <<-eos
+  #{assignees} will review your pull request :dancers: check #{trello_card.url}
+  #{assignees}: Please review this pull request using our guidelines:
+  * test for acceptance criteria / functionality
+  * check if the new code is covered with tests
+  * check for unintended consequences
+  * encourage usage of the boyscout rule
+  * make sure the code is architected in the best way
+  * check that no unnecessary technical debt got introduced
+  * make sure that no unnecessary FIXMEs or TODOs got added
+      eos
+
+      @client.add_comment(@repo, number, comment)
+    end
+
+    def repo_exists?
+      @client.repository?(@repo)
+    end
   end
-
-  def add_assignee(number, assignee)
-    @client.update_issue(@repo, number, assignee: assignee)
-  end
-
-  def reviewer_comment(number, assignee, trello_card)
-    comment = "@#{assignee} is your reviewer :dancers: check #{trello_card.url} \n" \
-              "@#{assignee}: Please review this pull request using our guidelines: \n" \
-              "* test for acceptance criteria / functionality \n" \
-              "* check if the new code is covered with tests \n" \
-              "* check for unintended consequences \n" \
-              "* encourage usage of the boyscout rule \n" \
-              "* make sure the code is architected in the best way \n" \
-              "* check that no unnecessary technical debt got introduced \n" \
-              "* make sure that no unnecessary FIXMEs or TODOs got added \n"
-    @client.add_comment(@repo, number, comment)
-  end
-
-  def unassigned_pull_requests
-    list_pulls.select { |issue| !issue[:assignee] }
-  end
-
-  def repo_exists?
-    @client.repository?(@repo)
-  end
-
 end

data/lib/reviewlette/trello_connection.rb

@@ -1,45 +1,46 @@
 require 'yaml'
 require 'trello'
 
-
-class TrelloConnection
-
-  attr_accessor :board
-
-  def initialize
-    @trello = YAML.load_file("#{File.dirname(__FILE__)}/../../config/trello.yml")
-    Trello.configure do |config|
-      config.developer_public_key = @trello['consumerkey']
-      config.member_token = @trello['oauthtoken']
+class Reviewlette
+  class TrelloConnection
+
+    attr_accessor :board
+
+    def initialize(config = nil)
+      config ||= YAML.load_file("#{File.dirname(__FILE__)}/../../config/trello.yml")
+      Trello.configure do |conf|
+        conf.developer_public_key = config['consumerkey']
+        conf.member_token = config['oauthtoken']
+      end
+      @board = Trello::Board.find(config['board_id'])
     end
-    @board = Trello::Board.find(@trello['board_id'])
-  end
 
-  def add_reviewer_to_card(reviewer, card)
-    reviewer = find_member_by_username(reviewer)
-    card.add_member(reviewer)
-  end
+    def add_reviewer_to_card(reviewer, card)
+      reviewer = find_member_by_username(reviewer)
+      card.add_member(reviewer)
+    end
 
-  def comment_on_card(comment, card)
-    card.add_comment(comment)
-  end
+    def comment_reviewers(card, repo_name, issue_id, reviewers)
+      comment = reviewers.map { |r| "@#{r.trello_handle}" }.join(' and ')
+      comment += " will review https://github.com/#{repo_name}/issues/#{issue_id}"
+      card.add_comment(comment)
+    end
 
-  def move_card_to_list(card, column_name)
-    column = find_column(column_name)
-    card.move_to_list(column)
-  end
+    def move_card_to_list(card, column_name)
+      column = find_column(column_name)
+      card.move_to_list(column)
+    end
 
-  def find_column(column_name)
-    @board.lists.find { |x| x.name == column_name }
-  end
+    def find_column(column_name)
+      @board.lists.find { |x| x.name == column_name }
+    end
 
-  def find_member_by_username(username)
-    @board.members.find { |m| m.username == username }
-  end
+    def find_member_by_username(username)
+      @board.members.find { |m| m.username == username }
+    end
 
-  def find_card_by_id(id)
-    @board.cards.find { |c| c.short_id == id.to_i }
+    def find_card_by_id(id)
+      @board.cards.find { |c| c.short_id == id.to_i }
+    end
   end
-
 end
-

data/lib/reviewlette/version.rb

@@ -0,0 +1,3 @@
+class Reviewlette
+  VERSION = '1.0.0'
+end

data/reviewlette.gemspec

@@ -1,11 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'reviewlette'
+require 'reviewlette/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "reviewlette"
-  spec.version       = VERSION
+  spec.version       = Reviewlette::VERSION
   spec.authors       = ["jschmid1"]
   spec.email         = ["jschmid@suse.de"]
   spec.summary       = %q{Randomly assignes a reviewer to your Pullrequest and corresponding Trello Card.}
@@ -18,9 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'ruby-trello', '=1.1.1'
-  spec.add_runtime_dependency 'octokit', '>=3.8.0'
-  spec.add_runtime_dependency 'sequel', '=4.13.0'
-  spec.add_runtime_dependency 'sqlite3', '=1.3.9'
+  spec.add_runtime_dependency 'ruby-trello'
+  spec.add_runtime_dependency 'octokit'
 end
-

data/spec/github_connection_spec.rb

@@ -1,46 +1,49 @@
 require 'spec_helper'
 
-describe GithubConnection do
-
-  subject { GithubConnection }
-  let( :connection ) { subject.new(repo, token) }
-  let( :repo ) { "test" }
-  let( :token ) { "foo" }
+describe Reviewlette::GithubConnection do
+  subject { described_class.new(repo, token) }
+  let(:repo) { 'test' }
+  let(:token) { 'foo' }
+  let(:member1) { double(name: 'test1', github_handle: 'githubtest1') }
+  let(:member2) { double(name: 'test2', github_handle: 'githubtest2') }
 
   describe '.new' do
     it 'initializes octokit client and repo' do
       expect(Octokit::Client).to receive(:new).with(:access_token => token)
-      expect(connection.repo).to eq(repo)
+      expect(subject.repo).to eq(repo)
     end
   end
 
-  describe '#add_assignee' do
-    it 'adds an assignee to the gh issue' do
-      expect(connection.client).to receive(:update_issue).with(repo, 11, :assignee => 'test')
-      connection.add_assignee(11, 'test')
+  describe '#add_assignees' do
+    it 'adds assignees to the GitHub issue' do
+      expect(subject.client).to receive(:update_issue).with(repo, 11, assignees: ['test'])
+      subject.add_assignees(11, ['test'])
     end
   end
 
-  describe '#reviewer_comment' do
+  describe '#comment_reviewers' do
     it 'comments on a given issue' do
-      card = Trello::Card.new
+      card      = Trello::Card.new
+      reviewers = [member1, member2]
+
       allow(card).to receive(:url).and_return('url')
-      expect(connection.client).to receive(:add_comment).with(repo, 11, anything)
-      connection.reviewer_comment(11, 'test', card)
+      expect(subject.client).to receive(:add_comment).with(repo, 11, anything)
+
+      subject.comment_reviewers(11, reviewers, card)
     end
   end
 
-  describe '#list_pulls' do
+  describe '#pull_requests' do
     it 'lists all pullrequests for a given repository' do
-      expect(connection.client).to receive(:pull_requests).with(repo)
-      connection.list_pulls
+      expect(subject.client).to receive(:pull_requests).with(repo)
+      subject.pull_requests
     end
   end
 
   describe '#repo_exists?' do
     it 'checks if a certain repository exists' do
-      expect(connection.client).to receive(:repository?).with(repo)
-      connection.repo_exists?
+      expect(subject.client).to receive(:repository?).with(repo)
+      subject.repo_exists?
     end
 
   end

data/spec/reviewlette_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 
 describe Reviewlette do
-  subject { Reviewlette }
+  let(:instance) { described_class.new members: [member1, member2] }
+  subject { instance }
 
-  let(:reviewlette)    { subject.new }
-
-  let(:members_config) { { 'members' => [member1, member2] } }
-  let(:member1)        { { 'name' => 'test1',  'suse_username' => 'test1', 'trello_username' => 'trellotest1' } }
-  let(:member2)        { { 'name' => 'test2', 'suse_username' => 'test2', 'trello_username' => 'trellotest2' } }
+  let(:member1) { double(name: 'test1', github_handle: 'pinky', trello_handle: 'trellotest1') }
+  let(:member2) { double(name: 'test2', github_handle: 'brain', trello_handle: 'trellotest2') }
 
   let(:github_config)  { { token: token, repos: [repo, repo2] } }
   let(:token)          { '1234' }
@@ -15,71 +13,171 @@ describe Reviewlette do
   let(:repo2)          { 'SUSE/foo' }
 
   before do
-    allow(TrelloConnection).to receive(:new).and_return TrelloConnection
-    allow(GithubConnection).to receive(:new).with(repo, token).and_return GithubConnection
+    allow(described_class::TrelloConnection).to receive(:new).and_return described_class::TrelloConnection
+    allow(described_class::GithubConnection).to receive(:new).with(repo, token).and_return described_class::GithubConnection
     allow(YAML).to receive(:load_file).with(/github\.yml/).and_return github_config
-    allow(YAML).to receive(:load_file).with(/members\.yml/).and_return members_config
   end
 
   describe '.new' do
     it 'sets trello connections' do
-      expect(TrelloConnection).to receive(:new)
-      subject.new
+      expect(described_class::TrelloConnection).to receive(:new)
+      subject
     end
   end
 
   describe '.run' do
     it 'iterates over all open repositories and looks for unassigned pull requests' do
       github_config[:repos].each do |r|
-        expect(reviewlette).to receive(:check_repo).with(r, token)
-        reviewlette.check_repo(r, token)
+        expect(subject).to receive(:check_repo).with(r, token)
+        subject.check_repo(r, token)
       end
     end
   end
 
   describe '.check_repo' do
+    context 'invalid repo' do
+      it 'skips the repo' do
+        expect(described_class::GithubConnection).to receive(:repo_exists?).and_return false
+        expect { subject.check_repo(repo, token) }.to output(/does not exist/).to_stdout
+      end
+    end
+
     it 'iterates over all open pull requests and extracts trello ids from name' do
-      expect(GithubConnection).to receive(:repo_exists?).and_return true
-      expect(GithubConnection).to receive(:unassigned_pull_requests).and_return([{number: 11, title: 'test_issue_12'}])
-      expect(TrelloConnection).to receive(:find_card_by_id).with(12)
+      expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+      expect(described_class::GithubConnection).to receive(:pull_requests).and_return([{number: 11, title: 'test_issue_12'}])
+      expect(described_class::GithubConnection).to receive(:labels).and_return([])
+      expect(described_class::TrelloConnection).to receive(:find_card_by_id).with(12)
 
-      reviewlette.check_repo(repo, token)
+      subject.check_repo(repo, token)
     end
 
-    it 'adds assignee and reviewer comment on github, adds comment on trello and moves card' do
-      card = Trello::Card.new
+    it 'iterates over all pull requests and skips those with no card id' do
+      expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+      expect(described_class::GithubConnection).to receive(:pull_requests).and_return([{ number: 11, title: 'no card id' }])
+      expect(described_class::GithubConnection).to receive(:labels).and_return([])
 
-      expect(GithubConnection).to receive(:repo_exists?).and_return true
-      expect(GithubConnection).to receive(:unassigned_pull_requests).and_return([{number: 11, title: 'test_issue_12'}])
-      expect(TrelloConnection).to receive(:find_card_by_id).with(12).and_return(card)
-      expect(reviewlette).to receive(:select_reviewer).and_return({'suse_username' => 'test', 'github_username' => 'testgit'})
+      expect { subject.check_repo(repo, token) }.to output(/Pull request not assigned to a trello card/).to_stdout
+    end
+
+    it 'adds assignees and reviewers comment on github, adds comment on trello and moves card' do
+      card        = Trello::Card.new
+      user        = double(github_handle: 'testgit', trello_handle: 'testtrello')
+      pullrequest = { number: 11, title: 'test_issue_12', assignees: [] }
 
-      expect(GithubConnection).to receive(:add_assignee).with(11, 'testgit')
-      expect(GithubConnection).to receive(:reviewer_comment).with(11, 'testgit', card)
+      expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+      expect(described_class::GithubConnection).to receive(:pull_requests).and_return([pullrequest])
+      expect(described_class::GithubConnection).to receive(:labels).and_return([])
+      expect(described_class::TrelloConnection).to receive(:find_card_by_id).with(12).and_return(card)
+      expect(subject).to receive(:select_reviewers).and_return([user])
 
-      expect(TrelloConnection).to receive(:comment_on_card).with("@ will review https://github.com/SUSE/test/issues/11", card)
-      expect(TrelloConnection).to receive(:move_card_to_list).with(card, 'In review')
+      expect(described_class::GithubConnection).to receive(:add_assignees).with(11, ['testgit'])
+      expect(described_class::GithubConnection).to receive(:comment_reviewers).with(11, [user], card)
 
-      reviewlette.check_repo(repo, token)
+      expect(described_class::TrelloConnection).to receive(:comment_reviewers).with(card, 'SUSE/test', 11, [user])
+      expect(described_class::TrelloConnection).to receive(:move_card_to_list).with(card, 'In review')
+
+      subject.check_repo(repo, token)
     end
 
-  end
+    context 'pull request with one reviewer but two wanted' do
+      it 'selects a second reviewer' do
+        card = Trello::Card.new
+        pullrequest = { number: 11, title: 'pr title 42', assignees: [OpenStruct.new({login: 'pinky'})] }
+        expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+        expect(described_class::GithubConnection).to receive(:pull_requests).and_return([pullrequest])
+        expect(described_class::GithubConnection).to receive(:labels).and_return(['2 reviewers'])
+        expect(described_class::TrelloConnection).to receive(:find_card_by_id).with(42).and_return(card)
+
+        expect(described_class::GithubConnection).to receive(:add_assignees).with(11, ['pinky', 'brain'])
+        expect(described_class::GithubConnection).to receive(:comment_reviewers).with(11, [member1, member2], card)
+        expect(described_class::TrelloConnection).to receive(:comment_reviewers).with(card, repo, 11, [member1, member2])
+        expect(described_class::TrelloConnection).to receive(:move_card_to_list).with(card, 'In review')
+        expect(subject).to receive(:select_reviewers).with(card, 2, [member1]).and_return([member1, member2])
+        subject.check_repo(repo, token)
+      end
+    end
 
-  describe '.select_reviewer' do
-    it 'excludes members on vacation' do
-      card       = Trello::Card.new
+    context 'pull request with two reviewers but no "2 reviewers" label' do
+      it 'keeps both reviewers' do
+        card = Trello::Card.new
+        pullrequest = { number: 11, title: 'pr title 42', assignees: [ OpenStruct.new({login: 'pinky'}), OpenStruct.new({login: 'brain'})] }
+        expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+        expect(described_class::GithubConnection).to receive(:pull_requests).and_return([pullrequest])
+        expect(described_class::GithubConnection).to receive(:labels).and_return([])
+        expect(described_class::TrelloConnection).to receive(:find_card_by_id).with(42).and_return(card)
+
+        expect(described_class::GithubConnection).not_to receive(:add_assignees)
+        expect(described_class::TrelloConnection).not_to receive(:move_card_to_list).with(card, 'In review')
+        subject.check_repo(repo, token)
+      end
+    end
 
-      allow(card).to receive(:members).and_return([])
-      expect(Vacations).to receive(:members_on_vacation).and_return([member1['suse_username']])
-      expect(reviewlette.select_reviewer(nil, card)).to eq(member2)
+    context 'pull request with already correct number of reviewers' do
+      it 'does not assign nor comment in GitHub or Trello' do
+        card = Trello::Card.new
+        pullrequest = { number: 11, title: 'pr title 42', assignees: [ OpenStruct.new({login: 'pinky'}), OpenStruct.new({login: 'pinky'})] }
+        expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+        expect(described_class::GithubConnection).to receive(:pull_requests).and_return([pullrequest])
+        expect(described_class::GithubConnection).to receive(:labels).and_return(['2 reviewers'])
+        expect(described_class::TrelloConnection).to receive(:find_card_by_id).with(42).and_return(card)
+
+        expect(described_class::GithubConnection).not_to receive(:add_assignees)
+        expect(described_class::GithubConnection).not_to receive(:comment_reviewers)
+        expect(described_class::TrelloConnection).not_to receive(:comment_reviewers)
+        expect(described_class::TrelloConnection).not_to receive(:move_card_to_list).with(card, 'In review')
+        subject.check_repo(repo, token)
+      end
     end
 
+    it 'does not find a reviewer' do
+      card = Trello::Card.new
+
+      expect(described_class::GithubConnection).to receive(:repo_exists?).and_return true
+      expect(described_class::GithubConnection).to receive(:pull_requests).and_return([{ number: 11, title: 'test_issue_12', assignees: [] }])
+      expect(described_class::GithubConnection).to receive(:labels).and_return([])
+      expect(described_class::TrelloConnection).to receive(:find_card_by_id).with(12).and_return(card)
+      expect(subject).to receive(:select_reviewers).and_return []
+
+      expect { subject.check_repo(repo, token) }.to output(/Could not find a reviewer/).to_stdout
+    end
+
+  end
+
+  describe '.select_reviewers' do
     it 'excludes the owner of the trello card' do
       card = Trello::Card.new
+      reviewers = [member1, member2]
+
+      allow(card).to receive_message_chain(:members, :map).and_return(reviewers)
+      expect(subject.select_reviewers(card).size).to eq(1)
+    end
+
+    it 'selects n reviewers' do
+      card = Trello::Card.new
+
+      allow(card).to receive_message_chain(:members, :map).and_return([member1])
+      expect(subject.select_reviewers(card, 2)).to match_array([member1, member2])
+    end
+
+    it 'selects only one reviewer if no second is available' do
+      card = Trello::Card.new
+
+      allow(card).to receive_message_chain(:members, :map).and_return([member2.trello_handle])
+      expect(subject.select_reviewers(card, 2)).to eq([member1])
+    end
+  end
+
+  describe '.how_many_should_review' do
+    subject { instance.how_many_should_review(labels) }
+
+    context 'with "2 reviewers" label' do
+      let(:labels) { ['foo', '2 reviewers', 'bar'] }
+      it { is_expected.to eq(2) }
+    end
 
-      allow(card).to receive_message_chain(:members, :map).and_return(['trellotest1'])
-      expect(Vacations).to receive(:members_on_vacation).and_return([])
-      expect(reviewlette.select_reviewer(nil, card)).to eq(members_config['members'].last)
+    context 'with no "2 reviewers" label' do
+      let(:labels) { ['foo', 'bar'] }
+      it { is_expected.to eq(1) }
     end
   end
 end