octopolo 0.3.6 → 0.4.0

data/spec/octopolo/github/issue_spec.rb

@@ -0,0 +1,243 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/github/issue"
+require_relative "../../../lib/octopolo/github/issue_creator"
+
+module Octopolo
+  module GitHub
+    describe Issue do
+      let(:repo_name) { "account/repo" }
+      let(:issue_number) { 7 }
+      let(:issue_hash) { stub }
+      let(:comments) { stub }
+      let(:octo) { stub }
+
+      context ".new" do
+        it "remembers the issue identifiers" do
+          i = Issue.new repo_name, issue_number
+          i.repo_name.should == repo_name
+          i.number.should == issue_number
+        end
+
+        it "optionally accepts the github data" do
+          i = Issue.new repo_name, issue_number, octo
+          i.data.should == octo
+        end
+
+        it "fails if not given a repo name" do
+          expect { Issue.new nil, issue_number }.to raise_error(Issue::MissingParameter)
+        end
+
+        it "fails if not given a issue number" do
+          expect { Issue.new repo_name, nil }.to raise_error(Issue::MissingParameter)
+        end
+      end
+
+      context "#data" do
+        let(:issue) { Issue.new repo_name, issue_number }
+
+        it "fetches the details from GitHub" do
+          GitHub.should_receive(:issue).with(issue.repo_name, issue.number) { octo }
+          issue.data.should == octo
+        end
+
+        it "catches the information" do
+          GitHub.should_receive(:issue).once { octo }
+          issue.data
+          issue.data
+        end
+
+        it "fails if given invalid information" do
+          GitHub.should_receive(:issue).and_raise(Octokit::NotFound)
+          expect { issue.data }.to raise_error(Issue::NotFound)
+        end
+      end
+
+      context "fetching its attributes from Octokit" do
+        let(:issue) { Issue.new repo_name, issue_number }
+
+        before do
+          issue.stub(data: octo)
+        end
+
+        context "#title" do
+          let(:octo) { stub(title: "the title") }
+
+          it "retrieves from the github data" do
+            issue.title.should == octo.title
+          end
+        end
+
+        context "#comments" do
+          it "fetches through octokit" do
+            GitHub.should_receive(:issue_comments).with(issue.repo_name, issue.number) { comments }
+            issue.comments.should == comments
+          end
+
+          it "caches the result" do
+            GitHub.should_receive(:issue_comments).once { comments }
+            issue.comments
+            issue.comments
+          end
+        end
+
+        context "#commenter_names" do
+          let(:comment1) { stub(user: stub(login: "pbyrne")) }
+          let(:comment2) { stub(user: stub(login: "anfleene")) }
+
+          before do
+            issue.stub(comments: [comment1, comment2])
+          end
+
+          it "returns only unique values" do
+            # make it same commenter
+            comment2.user.stub(login: comment1.user.login)
+            names = issue.commenter_names
+            names.size.should == 1
+          end
+        end
+
+        context "#without_octopolo_users" do
+          let(:users) { ["anfleene", "tst-octopolo"] }
+
+          it "excludes the github octopolo users" do
+            issue.exclude_octopolo_user(users).should_not include("tst-octopolo")
+            issue.exclude_octopolo_user(users).should include("anfleene")
+          end
+        end
+
+        context "#url" do
+          let(:octo) { stub(html_url: "http://example.com") }
+
+          it "retrieves from the github data" do
+            issue.url.should == octo.html_url
+          end
+        end
+
+        context "#external_urls" do
+          # nicked from https://github.com/tstmedia/ngin/issue/1151
+          let(:body) do
+            <<-END
+              http://thedesk.tstmedia.com/admin.php?pg=request&reqid=44690 - verified
+              http://thedesk.tstmedia.com/admin.php?pg=request&reqid=44693 - verified
+
+                development_ftp_server: ftp.tstmedia.com
+                development_username: startribuneftptest@ftp.tstmedia.com
+                development_password: JUm1kU7STYt0
+              http://www.ngin.com.stage.ngin-staging.com/api/volleyball/stats/summaries?id=68382&gender=girls&tst_test=1&date=8/24/2012
+            END
+          end
+
+          before do
+            issue.stub(body: body)
+          end
+
+          it "parses from the body" do
+            urls = issue.external_urls
+            urls.size.should == 3
+            urls.should include "http://thedesk.tstmedia.com/admin.php?pg=request&reqid=44690"
+            urls.should include "http://thedesk.tstmedia.com/admin.php?pg=request&reqid=44693"
+            urls.should include "http://www.ngin.com.stage.ngin-staging.com/api/volleyball/stats/summaries?id=68382&gender=girls&tst_test=1&date=8/24/2012"
+          end
+        end
+
+        context "#body" do
+          let(:octo) { stub(body: "asdf") }
+
+          it "retrieves from the github data" do
+            issue.body.should == octo.body
+          end
+
+          it "returns an empty string if the GitHub data has no body" do
+            octo.stub(body: nil)
+            issue.body.should == ""
+          end
+        end
+      end
+
+      context "#human_app_name" do
+        let(:repo_name) { "account_name/repo_name" }
+        let(:issue) { Issue.new repo_name, issue_number }
+
+        it "infers from the repo_name" do
+          issue.repo_name = "account/foo"
+          issue.human_app_name.should == "Foo"
+          issue.repo_name = "account/foo_bar"
+          issue.human_app_name.should == "Foo Bar"
+        end
+      end
+
+      context "#write_comment(message)" do
+        let(:issue) { Issue.new repo_name, issue_number }
+        let(:message) { "Test message" }
+        let(:error) { Octokit::UnprocessableEntity.new }
+
+        it "creates the message through octokit" do
+          GitHub.should_receive(:add_comment).with(issue.repo_name, issue.number, ":octocat: #{message}")
+
+          issue.write_comment message
+        end
+
+        it "raises CommentFailed if an exception occurs" do
+          GitHub.should_receive(:add_comment).and_raise(error)
+
+          expect { issue.write_comment message }.to raise_error(Issue::CommentFailed, "Unable to write the comment: '#{error.message}'")
+        end
+      end
+
+      context ".create repo_name, options" do
+        let(:options) { stub(:hash) }
+        let(:number) { stub(:integer) }
+        let(:data) { stub(:data)}
+        let(:creator) { stub(:issue_creator, number: number, data: data)}
+        let(:issue) { stub(:issue) }
+
+        it "passes on to IssueCreator and returns a new Issue" do
+          IssueCreator.should_receive(:perform).with(repo_name, options) { creator }
+          Issue.should_receive(:new).with(repo_name, number, data) { issue }
+          Issue.create(repo_name, options).should == issue
+        end
+      end
+
+      context "labeling" do
+        let(:label1) { Label.new(name: "low-risk", color: "343434") }
+        let(:label2) { Label.new(name: "high-risk", color: '565656') }
+        let(:issue) { Issue.new repo_name, issue_number }
+
+        context "#add_labels" do
+          it "sends the correct arguments to add_labels_to_issue for multiple labels" do
+            allow(Label).to receive(:build_label_array) {[label1,label2]}
+            expect(GitHub).to receive(:add_labels_to_issue).with(repo_name, issue_number, ["low-risk","high-risk"])
+            issue.add_labels([label1, label2])
+          end
+
+          it "sends the correct arguments to add_labels_to_issue for a single label" do
+            allow(Label).to receive(:build_label_array) {[label1]}
+            expect(GitHub).to receive(:add_labels_to_issue).with(repo_name, issue_number, ["low-risk"])
+            issue.add_labels(label1)
+          end
+        end
+
+        context "#remove_from_issue" do
+
+          it "sends the correct arguments to remove_label" do
+            allow(Label).to receive(:build_label_array) {[label1]}
+            expect(GitHub).to receive(:remove_label).with(repo_name, issue_number, "low-risk")
+            issue.remove_labels(label1)
+          end
+
+          it "calls remove_label only once" do
+            allow(Label).to receive(:build_label_array) {[label1]}
+            expect(GitHub).to receive(:remove_label).once
+            issue.remove_labels(label1)
+          end
+
+          it "calls remove_label twice" do
+            allow(Label).to receive(:build_label_array) {[label1, label2]}
+            expect(GitHub).to receive(:remove_label).twice
+            issue.remove_labels([label1,label2])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/octopolo/github/pull_request_creator_spec.rb

@@ -34,7 +34,7 @@ module Octopolo
       end
 
       context "#perform" do
-        let(:pull_request_data) { stub(:mash, number: 123) }
+        let(:data) { stub(:mash, number: 123) }
 
         before do
           creator.stub({
@@ -46,10 +46,10 @@ module Octopolo
         end
 
         it "generates the pull request with the given details and retains the information" do
-          GitHub.should_receive(:create_pull_request).with(repo_name, destination_branch, source_branch, title, body) { pull_request_data }
-          creator.perform.should == pull_request_data
-          creator.number.should == pull_request_data.number
-          creator.pull_request_data.should == pull_request_data
+          GitHub.should_receive(:create_pull_request).with(repo_name, destination_branch, source_branch, title, body) { data }
+          creator.perform.should == data
+          creator.number.should == data.number
+          creator.data.should == data
         end
 
         it "raises CannotCreate if any exception occurs" do
@@ -72,17 +72,17 @@ module Octopolo
         end
       end
 
-      context "#pull_request_data" do
-        let(:details) { stub(:pull_request_data) }
+      context "#data" do
+        let(:details) { stub(:data) }
 
         it "returns the stored pull request details" do
-          creator.pull_request_data = details
-          creator.pull_request_data.should == details
+          creator.data = details
+          creator.data.should == details
         end
 
         it "raises an exception if no information has been captured yet" do
-          creator.pull_request_data = nil
-          expect { creator.pull_request_data }.to raise_error(PullRequestCreator::NotYetCreated)
+          creator.data = nil
+          expect { creator.data }.to raise_error(PullRequestCreator::NotYetCreated)
         end
       end
 

data/spec/octopolo/github/pull_request_spec.rb

@@ -20,7 +20,7 @@ module Octopolo
 
         it "optionally accepts the github data" do
           pr = PullRequest.new repo_name, pr_number, octo
-          pr.pull_request_data.should == octo
+          pr.data.should == octo
         end
 
         it "fails if not given a repo name" do
@@ -32,23 +32,23 @@ module Octopolo
         end
       end
 
-      context "#pull_request_data" do
+      context "#data" do
         let(:pull) { PullRequest.new repo_name, pr_number }
 
         it "fetches the details from GitHub" do
           GitHub.should_receive(:pull_request).with(pull.repo_name, pull.number) { octo }
-          pull.pull_request_data.should == octo
+          pull.data.should == octo
         end
 
         it "catches the information" do
           GitHub.should_receive(:pull_request).once { octo }
-          pull.pull_request_data
-          pull.pull_request_data
+          pull.data
+          pull.data
         end
 
         it "fails if given invalid information" do
           GitHub.should_receive(:pull_request).and_raise(Octokit::NotFound)
-          expect { pull.pull_request_data }.to raise_error(PullRequest::NotFound)
+          expect { pull.data }.to raise_error(PullRequest::NotFound)
         end
       end
 
@@ -56,7 +56,7 @@ module Octopolo
         let(:pull) { PullRequest.new repo_name, pr_number }
 
         before do
-          pull.stub(pull_request_data: octo)
+          pull.stub(data: octo)
         end
 
         context "#title" do
@@ -130,11 +130,11 @@ module Octopolo
 
           before do
             pull.stub(comments: [comment1, comment2], author_names: [])
+            GitHub::User.stub(:new).with("pbyrne").and_return(stub(:author_name => "pbyrne"))
+            GitHub::User.stub(:new).with("anfleene").and_return(stub(:author_name => "anfleene"))
           end
 
           it "returns the names of the commit authors" do
-            GitHub.stub(:user).with("pbyrne").and_return(Hashie::Mash.new(:name => "pbyrne"))
-            GitHub.stub(:user).with("anfleene").and_return(Hashie::Mash.new(:name => "anfleene"))
             names = pull.commenter_names
             names.should_not be_empty
             names.size.should == 2
@@ -160,8 +160,8 @@ module Octopolo
           let(:users) { ["anfleene", "tst-octopolo"] }
 
           it "excludes the github octopolo users" do
-            pull.exlude_octopolo_user(users).should_not include("tst-octopolo")
-            pull.exlude_octopolo_user(users).should include("anfleene")
+            pull.exclude_octopolo_user(users).should_not include("tst-octopolo")
+            pull.exclude_octopolo_user(users).should include("anfleene")
           end
         end
 
@@ -276,13 +276,13 @@ module Octopolo
       context ".create repo_name, options" do
         let(:options) { stub(:hash) }
         let(:number) { stub(:integer) }
-        let(:pull_request_data) { stub(:pull_request_data)}
-        let(:creator) { stub(:pull_request_creator, number: number, pull_request_data: pull_request_data)}
+        let(:data) { stub(:data)}
+        let(:creator) { stub(:pull_request_creator, number: number, data: data)}
         let(:pull_request) { stub(:pull_request) }
 
         it "passes on to PullRequestCreator and returns a new PullRequest" do
           PullRequestCreator.should_receive(:perform).with(repo_name, options) { creator }
-          PullRequest.should_receive(:new).with(repo_name, number, pull_request_data) { pull_request }
+          PullRequest.should_receive(:new).with(repo_name, number, data) { pull_request }
           PullRequest.create(repo_name, options).should == pull_request
         end
       end
@@ -295,13 +295,13 @@ module Octopolo
         context "#add_labels" do
           it "sends the correct arguments to add_labels_to_pull for multiple labels" do
             allow(Label).to receive(:build_label_array) {[label1,label2]}
-            expect(GitHub).to receive(:add_labels_to_pull).with(repo_name, pr_number, ["low-risk","high-risk"])
+            expect(GitHub).to receive(:add_labels_to_issue).with(repo_name, pr_number, ["low-risk","high-risk"])
             pull_request.add_labels([label1, label2])
           end
 
           it "sends the correct arguments to add_labels_to_pull for a single label" do
             allow(Label).to receive(:build_label_array) {[label1]}
-            expect(GitHub).to receive(:add_labels_to_pull).with(repo_name, pr_number, ["low-risk"])
+            expect(GitHub).to receive(:add_labels_to_issue).with(repo_name, pr_number, ["low-risk"])
             pull_request.add_labels(label1)
           end
         end

data/spec/octopolo/github_spec.rb

@@ -54,6 +54,14 @@ module Octopolo
         end
       end
 
+      context ".issue *args" do
+        it "sends onto the client wrapper" do
+          client.should_receive(:issue).with("a", "b") { data }
+          result = GitHub.issue("a", "b")
+          result.should == data
+        end
+      end
+
       context ".pull_request_commits *args" do
         it "sends onto the client wrapper" do
           client.should_receive(:pull_request_commits).with("a", "b") { data }
@@ -96,6 +104,13 @@ module Octopolo
         end
       end
 
+      context ".create_issue" do
+        it "sends the issue to the API" do
+          client.should_receive(:create_issue).with("repo", "title", "body") { data }
+          GitHub.create_issue("repo", "title", "body").should == data
+        end
+      end
+
       context ".add_comment" do
         it "sends the comment to the API" do
           client.should_receive(:add_comment).with("repo", 123, "contents of comment")

data/spec/octopolo/scripts/issue_spec.rb

@@ -0,0 +1,233 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/scripts/issue"
+require_relative "../../../lib/octopolo/github/issue"
+
+module Octopolo
+  module Scripts
+    describe Issue do
+      let(:config) do
+        stub(:config, {
+          deploy_branch: "production",
+          github_repo: "tstmedia/foo",
+          use_pivotal_tracker: true,
+          use_jira: true
+        })
+      end
+      let(:cli) { stub(:cli) }
+      let(:git) { stub(:Git) }
+      let(:issue_url) { "http://github.com/tstmedia/octopolo/issues/0" }
+      let(:issue) { stub(:issue) }
+
+      subject { Issue.new }
+
+      before do
+        Issue.any_instance.stub({
+          :cli => cli,
+          :config => config,
+          :git => git
+        })
+      end
+
+      context "#new" do
+        it "accepts options" do
+          expect(Issue.new(:foo => 'bar').options).to eq(:foo => 'bar')
+        end
+      end
+
+      context "#execute" do
+        it "if connected to GitHub, asks some questions, creates the issue, and opens it" do
+          GitHub.should_receive(:connect).and_yield
+          expect(subject).to receive(:ask_questionaire)
+          expect(subject).to receive(:create_issue)
+          expect(subject).to receive(:update_pivotal)
+          expect(subject).to receive(:update_jira)
+          expect(subject).to receive(:update_label)
+          expect(subject).to receive(:open_in_browser)
+
+          subject.execute
+        end
+
+        it "if not connected to GitHub, does nothing" do
+          GitHub.should_receive(:connect) # and not yield, no github credentials
+          expect { subject.execute }.to_not raise_error
+        end
+      end
+
+      context "#ask_questionaire" do
+        it "asks appropriate questions to create a issue" do
+          expect(subject).to receive(:announce)
+          expect(subject).to receive(:ask_title)
+          expect(subject).to receive(:ask_pivotal_ids)
+          expect(subject).to receive(:ask_jira_ids)
+          expect(subject).to receive(:ask_label)
+
+          subject.send(:ask_questionaire)
+        end
+      end
+
+      context "#announce" do
+        it "displays information about the issue to be created" do
+          cli.should_receive(:say).with("Preparing an issue for #{config.github_repo}.")
+          subject.send(:announce)
+        end
+      end
+
+      context "#ask_title" do
+        let(:title) { "title" }
+
+        it "asks for and captures a title for the issue" do
+          cli.should_receive(:prompt).with("Title:") { title }
+          subject.send(:ask_title)
+          expect(subject.title).to eq(title)
+        end
+      end
+
+      context "#ask_label" do
+        let(:label1) {Octopolo::GitHub::Label.new(name: "low-risk", color: '151515')}
+        let(:label2) {Octopolo::GitHub::Label.new(name: "high-risk", color: '151515')}
+        let(:choices) {["low-risk","high-risk","None"]}
+
+        it "asks for and capture a label" do
+          allow(Octopolo::GitHub::Label).to receive(:all) {[label1,label2]}
+          expect(cli).to receive(:ask).with("Label:", choices)
+          subject.send(:ask_label)
+        end
+
+        it "asks for a label" do
+          allow(Octopolo::GitHub::Label).to receive(:all) {[label1,label2]}
+          allow(Octopolo::GitHub::Label).to receive(:get_names) {choices}
+          allow(cli).to receive(:ask) {"low-risk"}
+          expect(subject.send(:ask_label)).to eq(label1)
+        end
+      end
+
+      context "#ask_pivotal_ids" do
+        let(:ids_with_whitespace) { "123 456" }
+        let(:ids_with_commas) { "234, 567" }
+
+        it "asks for and captures IDs for related pivotal tasks" do
+          cli.should_receive(:prompt).with("Pivotal Tracker story ID(s):") { ids_with_whitespace }
+          subject.send(:ask_pivotal_ids)
+          expect(subject.pivotal_ids).to eq(%w(123 456))
+        end
+
+        it "asks for and captures IDs with commas" do
+          cli.should_receive(:prompt).with("Pivotal Tracker story ID(s):") { ids_with_commas }
+          subject.send(:ask_pivotal_ids)
+          expect(subject.pivotal_ids).to eq(%w(234 567))
+        end
+
+        it "sets to an empty array if not provided an ansswer" do
+          cli.should_receive(:prompt).with("Pivotal Tracker story ID(s):") { "" }
+          subject.send(:ask_pivotal_ids)
+          expect(subject.pivotal_ids).to eq([])
+        end
+      end
+
+      context "#create_issue" do
+        let(:attributes) { stub(:hash) }
+
+        before do
+          subject.stub(:issue_attributes) { attributes }
+        end
+
+        it "creates and stores the issue" do
+          GitHub::Issue.should_receive(:create).with(config.github_repo, attributes) { issue }
+          subject.send(:create_issue)
+          expect(subject.issue).to eq(issue)
+        end
+      end
+
+      context "#issue_attributes" do
+        before do
+          subject.title = "title"
+          subject.pivotal_ids = %w(123)
+        end
+
+        it "combines the anssers with a handful of deault values" do
+          subject.send(:issue_attributes).should == {
+            title: subject.title,
+            pivotal_ids: subject.pivotal_ids,
+            jira_ids: subject.jira_ids,
+            editor: nil
+          }
+        end
+      end
+
+      context "#label_choices" do
+        let(:label1) { Octopolo::GitHub::Label.new(name: "low-risk", color: '151515') }
+        let(:label2) { Octopolo::GitHub::Label.new(name: "high-risk", color: '151515') }
+        let(:github_labels) { [label1, label2] }
+
+        it "returns the labels plus 'None'" do
+          allow(Octopolo::GitHub::Label).to receive(:all) { github_labels }
+          expect(subject.send(:label_choices)).to eq github_labels
+        end
+      end
+
+      context "#update_pivotal" do
+        before do
+          subject.pivotal_ids = %w(123 234)
+          subject.issue = stub(url: "test")
+        end
+        let(:story_commenter) { stub(perform: true) }
+
+        it "creates a story commenter for each pivotal_id" do
+          Pivotal::StoryCommenter.should_receive(:new).with("123", "test") { story_commenter }
+          Pivotal::StoryCommenter.should_receive(:new).with("234", "test") { story_commenter }
+          subject.send(:update_pivotal)
+        end
+
+      end
+
+      context "#update_jira" do
+        before do
+          subject.jira_ids = %w(123 234)
+          subject.issue = stub(url: "test")
+        end
+        let(:story_commenter) { stub(perform: true) }
+
+        it "creates a story commenter for each pivotal_id" do
+          Jira::StoryCommenter.should_receive(:new).with("123", "test") { story_commenter }
+          Jira::StoryCommenter.should_receive(:new).with("234", "test") { story_commenter }
+          subject.send(:update_jira)
+        end
+      end
+
+      context "#update_label" do
+        before do
+          subject.label = "high-risk"
+          subject.issue = stub()
+        end
+        it "calls update_label with proper arguments" do
+          expect(subject.issue).to receive(:add_labels).with('high-risk')
+          subject.send(:update_label)
+        end
+
+        context "doesn't know yet label" do
+          before do
+            subject.label = nil
+          end
+          it "doesn't call update_label when label is don't know yet" do
+            expect(subject.issue).to_not receive(:add_labels)
+            subject.send(:update_label)
+          end
+        end
+
+      end
+
+      context "#open_in_browser" do
+        before do
+          subject.issue = issue
+          issue.stub(:url) { issue_url }
+        end
+
+        it "copies the issue's URL to the clipboard and opens it in the browser" do
+          cli.should_receive(:copy_to_clipboard) { issue.url}
+          cli.should_receive(:open) { issue.url }
+          subject.send(:open_in_browser)
+        end
+      end
+    end
+  end
+end