octopolo 0.0.1

data/spec/octopolo/scripts/new_deployable_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "octopolo/scripts/new_deployable"
+
+module Octopolo
+  module Scripts
+    describe NewDeployable do
+      subject { NewDeployable.new }
+
+      context "#execute" do
+        it "delegates the work to DatedBranchCreator" do
+          DatedBranchCreator.should_receive(:perform).with(Git::DEPLOYABLE_PREFIX)
+          subject.execute
+        end
+      end
+    end
+  end
+end
+

data/spec/octopolo/scripts/new_staging_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "octopolo/scripts/new_staging"
+
+module Octopolo
+  module Scripts
+    describe NewStaging do
+      subject { NewStaging.new }
+
+      context "#execute" do
+        it "delegates to DatedBranchCreator to create the branch" do
+          DatedBranchCreator.should_receive(:perform).with(Git::STAGING_PREFIX)
+          subject.execute
+        end
+      end
+    end
+  end
+end
+

data/spec/octopolo/scripts/octopolo_setup_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+require "octopolo/scripts/octopolo_setup"
+
+module Octopolo
+  module Scripts
+    describe OctopoloSetup do
+      let(:config) { stub(:config) }
+      let(:cli) { stub(:cli) }
+      let(:user_config) { stub(:user_config) }
+
+      subject { OctopoloSetup }
+
+      before do
+        subject.config = config
+        subject.cli = cli
+        subject.user_config = user_config
+      end
+
+      context ".invoke" do
+        it "ensures that git extras is installed" do
+          subject.should_receive(:verify_git_extras_setup)
+          subject.should_receive(:verify_user_setup)
+
+          subject.invoke
+        end
+      end
+
+      context ".verify_git_extras_setup" do
+        it "installs git-extras if it is not already installed" do
+          subject.should_receive(:git_extras_installed?) { false }
+          subject.should_receive(:install_git_extras)
+          subject.verify_git_extras_setup
+        end
+
+        it "does nothing if git-extras is already installed" do
+          subject.should_receive(:git_extras_installed?) { true }
+          subject.should_receive(:install_git_extras).never
+          subject.verify_git_extras_setup
+        end
+      end
+
+      context ".git_extras_installed?" do
+        it "returns true if git-extras command exists" do
+          cli.should_receive(:perform).with("which git-extras", false) { "/usr/local/lib/git-extras" }
+          subject.git_extras_installed?.should be_true
+        end
+
+        it "returns false if git-extras command does not exist" do
+          cli.should_receive(:perform).with("which git-extras", false) { "" }
+          subject.git_extras_installed?.should be_false
+        end
+      end
+
+      context ".install_git_extras" do
+        it "installs git-extras through homebrew" do
+          cli.should_receive(:say).with("Updating Homebrew to ensure latest git-extras formula.")
+          cli.should_receive(:perform).with("brew update")
+          cli.should_receive(:say).with("Installing git-extras")
+          cli.should_receive(:perform).with("brew install git-extras")
+
+          subject.install_git_extras
+        end
+      end
+
+      context ".verify_user_setup" do
+        it "verifies that the user's full name and github credentials are set up" do
+          subject.should_receive(:verify_user_full_name)
+          subject.should_receive(:verify_user_github_credentials)
+
+          subject.verify_user_setup
+        end
+      end
+
+      context ".verify_user_full_name" do
+        let(:name) { "Joe Person" }
+
+        it "does nothing if the full name is configured" do
+          user_config.stub(full_name: name)
+          cli.should_receive(:say).with("Full name '#{name}' already configured.")
+          cli.should_receive(:prompt).never
+          user_config.should_receive(:full_name=).never
+
+          subject.verify_user_full_name
+        end
+
+        it "asks and stores the full name if not configured" do
+          user_config.stub(full_name: ENV["USER"])
+          cli.should_receive(:prompt).with("Your full name:") { name }
+          user_config.should_receive(:full_name=).with(name)
+
+          subject.verify_user_full_name
+        end
+      end
+
+      context ".verify_user_github_credentials" do
+        it "does nothing if github credentials are set" do
+          GitHub.should_receive(:check_connection)
+          GithubAuth.should_not_receive(:invoke)
+          cli.should_receive(:say).with("Successfully configured API token.")
+
+          subject.verify_user_github_credentials
+        end
+
+        it "prompts to set up authentication otherwise" do
+          GitHub.should_receive(:check_connection).and_raise(GitHub::BadCredentials.new "token rejected")
+          cli.should_receive(:say).with("token rejected")
+          GithubAuth.should_not_receive(:invoke)
+
+          subject.verify_user_github_credentials
+        end
+
+        it "does nothing if it gets TryAgain" do
+          GitHub.should_receive(:check_connection).and_raise(GitHub::TryAgain.new "no token. make one and try again.")
+          cli.should_receive(:say).with("no token. make one and try again.")
+          expect { subject.verify_user_github_credentials }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/octopolo/scripts/pivotal_auth_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/scripts/pivotal_auth"
+
+module Octopolo
+  module Scripts
+    describe PivotalAuth do
+      # stub any attributes in the config that you need
+      let(:user_config) { stub(:user_config) }
+      let(:cli) { stub(:cli) }
+      let(:email) { "example@example.com" }
+      let(:password) { "don't tell anyone" }
+      let(:client) { stub(:pivotal_client) }
+      let(:token) { "deadbeef" }
+
+      subject { PivotalAuth.new }
+
+      before do
+        subject.cli = cli
+        subject.user_config = user_config
+      end
+
+      context "#execute" do
+        let(:bad_credentials_message) { "OMG TYPE IT RIGHT" }
+
+        it "asks for username and password, generates the token, and writes to disk" do
+          subject.should_receive(:ask_credentials)
+          subject.should_receive(:request_token)
+          subject.should_receive(:store_token)
+
+          subject.execute
+        end
+
+        it "gracefully handles invalid credentials" do
+          subject.should_receive(:ask_credentials)
+          subject.should_receive(:request_token).and_raise(Pivotal::BadCredentials.new(bad_credentials_message))
+          subject.should_not_receive(:store_token)
+          cli.should_receive(:say).with(bad_credentials_message)
+
+          expect { subject.execute }.to_not raise_error
+        end
+      end
+
+      context "#ask_credentials" do
+        it "asks for and captures the user's Pivotal Tracker credentials" do
+          cli.should_receive(:prompt).with("Your Pivotal Tracker email: ") { email }
+          cli.should_receive(:prompt_secret).with("Your Pivotal Tracker password (never stored): ") { password }
+          subject.send(:ask_credentials)
+          expect(subject.email).to eq(email)
+          expect(subject.password).to eq(password)
+        end
+      end
+
+      context "#request_token" do
+        before do
+          subject.email = email
+          subject.password = password
+        end
+
+        it "leverages the Pivotal Tracker client to fetch the token via API" do
+          Pivotal::Client.should_receive(:fetch_token).with(email, password) { token }
+          subject.send(:request_token)
+          expect(subject.token).to eq(token)
+        end
+      end
+
+      context "#store_token" do
+        it "stores the token in the config" do
+          subject.token = token
+          user_config.should_receive(:set).with(:pivotal_token, token)
+          subject.send(:store_token)
+        end
+      end
+    end
+  end
+end
+
+# vim: set ft=ruby : #

data/spec/octopolo/scripts/pull_request_spec.rb

@@ -0,0 +1,217 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/scripts/pull_request"
+
+module Octopolo
+  module Scripts
+    describe PullRequest 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, current_branch: "bug-123-something", reserved_branch?: false) }
+      let(:pull_request_url) { "http://github.com/tstmedia/octopolo/pull/0" }
+      let(:pull_request) { stub(:pull_request) }
+
+      subject { PullRequest.new }
+
+      before do
+        PullRequest.any_instance.stub({
+          :cli => cli,
+          :config => config,
+          :git => git
+        })
+      end
+
+      context "#new" do
+        it "defaults the destination branch to the deploy branch" do
+          expect(subject.destination_branch).to eq(config.deploy_branch)
+        end
+
+        it "accepts an alternate destination branch" do
+          expect(PullRequest.new('foo').destination_branch).to eq("foo")
+        end
+      end
+
+      context "#execute" do
+        it "if connected to GitHub, asks some questions, creates the pull request, and opens it" do
+          GitHub.should_receive(:connect).and_yield
+          subject.should_receive(:ask_questionaire)
+          subject.should_receive(:create_pull_request)
+          subject.should_receive(:update_pivotal)
+          subject.should_receive(:update_jira)
+          subject.should_receive(:open_pull_request)
+
+          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 pull request" do
+          subject.should_receive(:announce)
+          subject.should_receive(:ask_title)
+          subject.should_receive(:ask_pivotal_ids)
+          subject.should_receive(:ask_jira_ids)
+
+          subject.send(:ask_questionaire)
+        end
+
+        context "when checking for staging branch" do
+          before do
+            subject.stub(:announce)
+            subject.stub(:ask_title)
+            subject.stub(:ask_pivotal_ids)
+            subject.stub(:ask_jira_ids)
+          end
+          it "exits when branch name is reserved" do
+            subject.git.stub(:reserved_branch?).and_return true
+
+            subject.should_receive(:alert_reserved_and_exit)
+
+            subject.send(:ask_questionaire)
+          end
+
+          it "should not ask if the branch is not staging" do
+            subject.git.stub(:reserved_branch?).and_return false
+
+            subject.should_not_receive(:alert_reserved_and_exit)
+
+            subject.send(:ask_questionaire)
+          end
+        end
+      end
+
+      context "#announce" do
+        before do
+          subject.destination_branch = "foo"
+        end
+
+        it "displays information about the pull request to be created" do
+          cli.should_receive(:say).with("Preparing a pull request for #{config.github_repo}/#{git.current_branch} to #{config.github_repo}/#{subject.destination_branch}.")
+          subject.send(:announce)
+        end
+      end
+
+      context "#ask_title" do
+        let(:title) { "title" }
+
+        it "asks for and captures a title for the pull request" do
+          cli.should_receive(:prompt).with("Title:") { title }
+          subject.send(:ask_title)
+          expect(subject.title).to eq(title)
+        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_pull_request" do
+        let(:attributes) { stub(:hash) }
+
+        before do
+          subject.stub(:pull_request_attributes) { attributes }
+        end
+
+        it "creates and stores the pull request" do
+          GitHub::PullRequest.should_receive(:create).with(config.github_repo, attributes) { pull_request }
+          subject.send(:create_pull_request)
+          expect(subject.pull_request).to eq(pull_request)
+        end
+      end
+
+      # GitHub::PullRequest.create config.github_repo, answers.merge({
+      #   destination_branch: config.deploy_branch,
+      #   source_branch: Git.current_branch,
+      # })
+      context "#pull_request_attributes" do
+        before do
+          subject.title = "title"
+          subject.destination_branch = "some-branch",
+          subject.pivotal_ids = %w(123)
+        end
+
+        it "combines the anssers with a handful of deault values" do
+          subject.send(:pull_request_attributes).should == {
+            title: subject.title,
+            destination_branch: subject.destination_branch,
+            source_branch: git.current_branch,
+            pivotal_ids: subject.pivotal_ids,
+            jira_ids: subject.jira_ids,
+          }
+        end
+      end
+
+      context "#update_pivotal" do
+        before do
+          subject.pivotal_ids = %w(123 234)
+          subject.pull_request = 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.pull_request = 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 "#open_pull_request" do
+        before do
+          subject.pull_request = pull_request
+          pull_request.stub(:url) { pull_request_url }
+        end
+
+        it "copies the pull request's URL to the clipboard and opens it in the browser" do
+          cli.should_receive(:copy_to_clipboard) { pull_request.url}
+          cli.should_receive(:open) { pull_request.url }
+          subject.send(:open_pull_request)
+        end
+      end
+    end
+  end
+end