git_reflow 0.8.9 → 0.9.3

data/spec/lib/git_reflow/sandbox_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe GitReflow::Sandbox do
 
     it "when blocking is flagged off, the command exits silently" do
       allow(GitReflow::Sandbox).to receive(:run).and_call_original
-      expect { GitReflow::Sandbox.run("ls wtf", blocking: false) }.to_not raise_error SystemExit
+      expect { GitReflow::Sandbox.run("ls wtf", blocking: false) }.to_not raise_error
     end
   end
 end

data/spec/lib/git_reflow/workflow_spec.rb

@@ -1,59 +1,304 @@
-require 'spec_helper'
-
-describe GitReflow::Workflow do
-
-  class DummyWorkflow
-    include GitReflow::Workflow
-  end
-
-  let(:workflow) { DummyWorkflow }
-  let(:loader)   { double() }
-
-  describe ".current" do
-    subject { GitReflow::Workflow.current }
-
-    context "when no workflow is set" do
-      before  { allow(GitReflow::Config).to receive(:get).with("reflow.workflow").and_return('') }
-      specify { expect( subject ).to eql(GitReflow::Workflows::Core) }
-    end
-
-    context "when a workflow is set" do
-      let(:workflow_path) { File.join(File.expand_path("../../../fixtures", __FILE__), "/awesome_workflow.rb") }
-
-      before  { allow(GitReflow::Config).to receive(:get).with("reflow.workflow").and_return(workflow_path) }
-      specify { expect( subject ).to eql(GitReflow::Workflow::AwesomeWorkflow) }
-    end
-  end
-
-  describe ".command" do
-    it "creates a class method for a bogus command" do
-      class DummyWorkflow
-        include GitReflow::Workflow
-      end
-      workflow.command :bogus do
-        "Woohoo"
-      end
-
-      expect(DummyWorkflow.bogus).to eql("Woohoo")
-    end
-
-    it "creates a method for a bogus command with arguments" do
-      workflow.command :bogus, arguments: [:feature_branch] do |**params|
-        "Woohoo #{params[:feature_branch]}!"
-      end
-
-      expect(DummyWorkflow.bogus(feature_branch: "donuts")).to eql("Woohoo donuts!")
-    end
-
-    it "creates a class method for a bogus command with default options" do
-      workflow.command :bogus, arguments: [:feature_branch], defaults: {decoration: 'sprinkles'} do |**params|
-        donut_excitement = "Woohoo #{params[:feature_branch]}"
-        donut_excitement += " with #{params[:decoration]}" if params[:decoration]
-        "#{donut_excitement}!"
-      end
-
-      expect(DummyWorkflow.bogus(feature_branch: "donuts")).to eql("Woohoo donuts with sprinkles!")
-    end
-  end
-
-end
+require 'spec_helper'
+
+describe GitReflow::Workflow do
+
+  class DummyWorkflow
+    include GitReflow::Workflow
+  end
+
+  class DummyBundler
+    def gemfile(&block)
+      instance_eval &block
+    end
+
+    def source(name); end
+    def gem(name, *args); end
+  end
+
+  class DummyGemifiedWorkflow
+    include GitReflow::Workflow
+
+    command :whirl do
+      puts "whirl"
+    end
+  end
+
+  let(:workflow) { DummyWorkflow }
+  let(:loader)   { double() }
+
+  describe ".current" do
+    subject { GitReflow::Workflow.current }
+
+    before do
+      allow(GitReflow::Workflows::Core).to receive(:load_raw_workflow)
+    end
+
+    context "when no workflow is set" do
+      before  { allow(GitReflow::Config).to receive(:get).with("reflow.workflow").and_return('') }
+      specify { expect( subject ).to eql(GitReflow::Workflows::Core) }
+    end
+
+    context "when a global workflow is set" do
+      let(:workflow_path) { File.join(File.expand_path("../../../fixtures", __FILE__), "/awesome_workflow.rb") }
+
+      before  { allow(GitReflow::Config).to receive(:get).with("reflow.workflow").and_return(workflow_path) }
+      specify { expect( subject ).to eql(GitReflow::Workflows::Core) }
+    end
+
+    context "when a local workflow is set" do
+      let(:workflow_content) do
+        <<~WORKFLOW_CONTENT
+          command :dummy do
+            GitReflow.say "derp"
+          end
+        WORKFLOW_CONTENT
+      end
+
+      before do
+        allow(File).to receive(:exists?).with("#{GitReflow.git_root_dir}/Workflow").and_return(true)
+        allow(File).to receive(:read).with("#{GitReflow.git_root_dir}/Workflow").and_return(workflow_content)
+        expect(GitReflow::Workflows::Core).to receive(:load_raw_workflow).with(workflow_content).and_call_original
+      end
+
+      specify { expect( subject ).to respond_to(:dummy) }
+      specify { expect( subject ).to eql(GitReflow::Workflows::Core) }
+    end
+
+    context "when both a local and a global workflow are set" do
+      let(:workflow_path) { File.join(File.expand_path("../../../fixtures", __FILE__), "/awesome_workflow.rb") }
+      let(:workflow_content) do
+        <<~WORKFLOW_CONTENT
+          command :dummy do
+            GitReflow.say "derp"
+          end
+        WORKFLOW_CONTENT
+      end
+
+      before  do
+        allow(File).to receive(:exists?).with("#{GitReflow.git_root_dir}/Workflow").and_return(true)
+        allow(File).to receive(:read).with("#{GitReflow.git_root_dir}/Workflow").and_return(workflow_content)
+        allow(GitReflow::Config).to receive(:get).with("reflow.workflow").and_return(workflow_path)
+        allow(GitReflow::Workflows::Core).to receive(:load_raw_workflow).and_call_original
+      end
+
+      specify { expect(subject).to respond_to(:dummy) }
+      specify { expect(subject).to eql(GitReflow::Workflows::Core) }
+    end
+  end
+
+  describe ".before" do
+    it "executes the block before the command" do
+      GitReflow::Workflows::Core.load_raw_workflow <<~WORKFLOW_CONTENT
+        command :yips do
+          puts "Yips."
+        end
+
+        before :yips do
+          puts "Would you like a donut?"
+        end
+      WORKFLOW_CONTENT
+
+      allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_return(true)
+
+      expect { GitReflow.workflow.yips }.to have_output "Would you like a donut?\nYips."
+    end
+
+    it "executes blocks sequentially by order of appearance" do
+      GitReflow::Workflows::Core.load_raw_workflow <<~WORKFLOW_CONTENT
+        command :yips do
+          puts "Yips."
+        end
+
+        before :yips do
+          puts "Cupcake?"
+        end
+
+        before :yips do
+          puts "Would you like a donut?"
+        end
+      WORKFLOW_CONTENT
+
+      allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_return(true)
+
+      expect { GitReflow.workflow.yips }.to have_output "Cupcake?\nWould you like a donut?\nYips."
+    end
+
+    it "proxies any arguments returned to the command" do
+      GitReflow::Workflows::Core.load_raw_workflow <<~WORKFLOW_CONTENT
+        command :yips, arguments: { spiced: false } do |**params|
+          puts params[:spiced] ? "Too spicy." : "Yips."
+        end
+
+        before :yips do
+          puts "Wasabe?"
+          { spiced: true }
+        end
+      WORKFLOW_CONTENT
+
+      allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_return(true)
+
+      expect { GitReflow.workflow.yips }.to have_output "Wasabe?\nToo spicy."
+    end
+  end
+
+  describe ".after" do
+    it "executes the block after the command" do
+      GitReflow::Workflows::Core.load_raw_workflow <<~WORKFLOW_CONTENT
+        command :vroom do
+          puts "Vroom"
+        end
+
+        after :vroom do
+          puts "VROOOOM"
+        end
+      WORKFLOW_CONTENT
+
+      allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_return(true)
+
+      expect { GitReflow.workflow.vroom }.to have_output "Vroom\nVROOOOM"
+    end
+
+    it "executes blocks sequentially by order of appearance" do
+      GitReflow::Workflows::Core.load_raw_workflow <<~WORKFLOW_CONTENT
+        command :vroom do
+          puts "Vroom"
+        end
+
+        after :vroom do
+          puts "Vrooom"
+        end
+
+        after :vroom do
+          puts "VROOOOM"
+        end
+      WORKFLOW_CONTENT
+
+      allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_return(true)
+
+      expect { GitReflow.workflow.vroom }.to have_output "Vroom\nVrooom\nVROOOOM"
+    end
+  end
+
+  describe ".command" do
+    it "creates a class method for a bogus command" do
+      workflow.command :bogus do
+        GitReflow.say "Woohoo"
+      end
+
+      expect { DummyWorkflow.bogus }.to have_said("Woohoo")
+    end
+
+    it "creates a method for a bogus command with arguments" do
+      workflow.command :bogus, arguments: { feature_branch: nil } do |**params|
+        GitReflow.say "Woohoo #{params[:feature_branch]}!"
+      end
+
+      expect { DummyWorkflow.bogus(feature_branch: "arguments") }.to have_said("Woohoo arguments!")
+    end
+
+    it "creates a class method for a bogus command with default arguments" do
+      workflow.command :bogus, arguments: { feature_branch: nil, decoration: "sprinkles" } do |**params|
+        donut_excitement = "Woohoo #{params[:feature_branch]}"
+        donut_excitement += " with #{params[:decoration]}" if params[:decoration]
+        GitReflow.say "#{donut_excitement}!"
+      end
+
+      expect { DummyWorkflow.bogus(feature_branch: "donuts") }.to have_said("Woohoo donuts with sprinkles!")
+    end
+
+    it "creates a class method for a bogus command with flags" do
+      workflow.command :bogus, flags: { feature_branch: nil } do |**params|
+        GitReflow.say "Woohoo #{params[:feature_branch]}!"
+      end
+
+      expect { DummyWorkflow.bogus(feature_branch: "flags") }.to have_said("Woohoo flags!")
+    end
+
+    it "creates a class method for a bogus command with default flags" do
+      workflow.command :bogus, flags: { feature_branch: "donuts" } do |**params|
+        GitReflow.say "Woohoo #{params[:feature_branch]}!"
+      end
+
+      expect { DummyWorkflow.bogus }.to have_said("Woohoo donuts!")
+    end
+
+    it "creates a class method for a bogus command with switches" do
+      workflow.command :bogus, switches: { feature_branch: nil } do |**params|
+        GitReflow.say "Woohoo #{params[:feature_branch]}!"
+      end
+
+      expect { DummyWorkflow.bogus(feature_branch: "switches") }.to have_said("Woohoo switches!")
+    end
+
+    it "creates a class method for a bogus command with default switches" do
+      workflow.command :bogus, switches: { feature_branch: "donuts" } do |**params|
+        GitReflow.say "Woohoo #{params[:feature_branch]}!"
+      end
+
+      expect { DummyWorkflow.bogus }.to have_said("Woohoo donuts!")
+    end
+  end
+
+  describe ".use(workflow_name)" do
+    it "Uses a pre-existing workflow as a basis" do
+      allow(GitReflow::Workflows::Core).to receive(:load_workflow)
+      expect(GitReflow::Workflows::Core).to receive(:load_workflow)
+        .with(workflow.workflows["FlatMergeWorkflow"])
+        .and_return(true)
+      workflow.use "FlatMergeWorkflow"
+    end
+  end
+
+  describe ".use_gem(name, *ags)" do
+    let(:mock_bundler) { DummyBundler.new }
+
+    before do
+      allow(DummyGemifiedWorkflow).to receive(:gemfile) do |&block|
+        mock_bundler.gemfile(&block)
+      end
+      stub_run_for(DummyGemifiedWorkflow)
+    end
+
+    it "Installs a gem using Bundler's inline gemfile" do
+      stub_command(command: "gem list -ie whirly", options: { loud: false, raise: true }, return_value: "false")
+      expect(mock_bundler).to receive(:source).with("https://rubygems.org")
+      expect(mock_bundler).to receive(:gem).with("whirly", "0.2.6")
+
+      DummyGemifiedWorkflow.class_eval do
+        use_gem "whirly", "0.2.6"
+      end
+    end
+
+    it "Uses an existing gem if it's already installed" do
+      stub_command(command: "gem list -ie whirly", options: { loud: false, raise: false }, return_value: "true")
+      expect(DummyGemifiedWorkflow).to_not receive(:gemfile)
+
+      DummyGemifiedWorkflow.class_eval do
+        use_gem "whirly", "0.2.6"
+      end
+    end
+  end
+
+  describe ".use_gemfile(&block)" do
+    let(:mock_bundler) { DummyBundler.new }
+
+    before do
+      allow(DummyGemifiedWorkflow).to receive(:gemfile) do |&block|
+        mock_bundler.gemfile(&block)
+      end
+      stub_run_for(DummyGemifiedWorkflow)
+    end
+
+    it "runs bundler's inline gemfile with the provided block" do
+      expect(mock_bundler).to receive(:source).with("https://rubygems.org")
+      expect(mock_bundler).to receive(:gem).with("standard")
+
+      DummyGemifiedWorkflow.class_eval do
+        use_gemfile do
+          source "https://rubygems.org"
+          gem "standard"
+        end
+      end
+    end
+  end
+end

data/spec/lib/git_reflow/workflows/core_spec.rb

@@ -5,14 +5,51 @@ describe GitReflow::Workflows::Core do
   let(:existing_pull_requests)    { Fixture.new('pull_requests/pull_requests.json').to_json_hashie }
   let(:existing_gh_pull_request)  { GitReflow::GitServer::GitHub::PullRequest.new existing_pull_requests.first }
   let(:pull_request_message_file) { "#{GitReflow.git_root_dir}/.git/GIT_REFLOW_PR_MSG" }
+  let(:workflow)                  { described_class }
 
   before do
-    allow(GitReflow).to receive(:current_branch).and_return(feature_branch)
+    allow(workflow).to receive(:current_branch).and_return(feature_branch)
     allow_any_instance_of(HighLine).to receive(:choose)
   end
 
+  describe ".load_workflow(workflow_path)" do
+    let(:workflow_path) { "/tmp/Workflow" }
+    subject { GitReflow::Workflows::Core.load_workflow(workflow_path) }
+
+    before { allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_call_original }
+
+    it "returns `nil` if the workflow path doesn't exist" do
+      allow(File).to receive(:exists?).and_return(false)
+      expect(subject).to be_nil
+    end
+
+    it "evaluates the workflow file in the context of the class" do
+      workflow_content = "# testing"
+      allow(File).to receive(:exists?).with("#{GitReflow.git_root_dir}/Workflow").and_return(false)
+      allow(File).to receive(:exists?).with(workflow_path).and_return(true)
+      expect(File).to receive(:read).with(workflow_path).and_return(workflow_content)
+      expect(GitReflow::Workflows::Core).to receive(:load_raw_workflow).with(workflow_content)
+      subject
+    end
+  end
+
+  describe ".load_raw_workflow(workflow_string)" do
+    before { allow(GitReflow::Workflows::Core).to receive(:load_workflow).and_call_original }
+    it "evaluates the raw string in the context of the Core workflow" do
+      workflow_content = <<~WORKFLOW_CONTENT
+        command :dummy do
+          puts "Dummy"
+        end
+      WORKFLOW_CONTENT
+      fake_binding = instance_double(Binding)
+      expect(fake_binding).to receive(:eval).with(workflow_content)
+      expect(described_class).to receive(:binding).and_return(fake_binding)
+      GitReflow::Workflows::Core.load_raw_workflow(workflow_content)
+    end
+  end
+
   describe ".setup" do
-    subject { GitReflow::Workflows::Core.setup }
+    subject { workflow.setup }
 
     before do
       allow(File).to receive(:exist?).and_return(false)
@@ -27,7 +64,8 @@ describe GitReflow::Workflows::Core do
     context "core.editor git config has already been set" do
       before  do
         allow(GitReflow::Config).to receive(:get) { "" }
-        allow(GitReflow::Config).to receive(:get).with('core.editor').and_return('emacs')
+        allow(workflow.git_config).to receive(:get) { "" }
+        allow(workflow.git_config).to receive(:get).with('core.editor').and_return('emacs')
       end
 
       specify { expect { subject }.to_not have_run_command_silently "git config -f #{GitReflow::Config::CONFIG_FILE_PATH} --replace-all core.editor \"#{GitReflow.default_editor}\"", blocking: false }
@@ -36,8 +74,7 @@ describe GitReflow::Workflows::Core do
     context "git-reflow has not been setup before" do
       it "notifies the user of global setup" do
         expect { subject }.to have_said "We'll walk you through setting up git-reflow's defaults for all your projects.", :notice
-        expect { subject }.to have_said "In the future, you can run \`git-reflow setup\` from the root of any project you want to setup differently.", :notice
-        expect { subject }.to have_said "To adjust these settings globally, you can run \`git-reflow setup --global\`.", :notice
+        expect { subject }.to have_said "In the future, you can run \`git-reflow setup --local\` from the root of any project you want to setup differently.", :notice
       end
 
       it "creates a .gitconfig.reflow file and includes it in the user's global git config" do
@@ -84,9 +121,9 @@ describe GitReflow::Workflows::Core do
 
   describe ".start" do
     let(:feature_branch) { 'new_feature' }
-    subject              { GitReflow::Workflows::Core.start feature_branch: feature_branch }
+    subject              { workflow.start feature_branch: feature_branch }
 
-    it "updates the local repo and starts creates a new branch" do
+    it "updates the local repo and creates a new branch" do
       expect { subject }.to have_run_commands_in_order [
         "git checkout master",
         "git pull origin master",
@@ -108,13 +145,23 @@ describe GitReflow::Workflows::Core do
     end
 
     it "starts from a different base branch when one is supplied" do
-      expect { GitReflow::Workflows::Core.start feature_branch: feature_branch, base: 'development' }.to have_run_commands_in_order [
+      expect { workflow.start feature_branch: feature_branch, base: 'development' }.to have_run_commands_in_order [
         "git checkout development",
         "git pull origin development",
         "git push origin development:refs/heads/#{feature_branch}",
         "git checkout --track -b #{feature_branch} origin/#{feature_branch}"
       ]
     end
+
+    it "starts from a different base branch when one is configured" do
+      allow(GitReflow::Config).to receive(:get).with("reflow.base-branch").and_return("sudo-master")
+      expect { workflow.start feature_branch: feature_branch }.to have_run_commands_in_order [
+        "git checkout sudo-master",
+        "git pull origin sudo-master",
+        "git push origin sudo-master:refs/heads/#{feature_branch}",
+        "git checkout --track -b #{feature_branch} origin/#{feature_branch}"
+      ]
+    end
   end
 
   describe ".review" do
@@ -125,11 +172,11 @@ describe GitReflow::Workflows::Core do
     let(:inputs)         { {} }
 
     before do
-      allow(GitReflow).to receive(:remote_user).and_return(user)
+      allow(workflow).to receive(:remote_user).and_return(user)
       allow(GitReflow).to receive(:git_server).and_return(GitReflow::GitServer)
-      allow(GitReflow.git_server).to receive(:get_build_status).and_return(Struct.new(:state, :description, :url, :target_url).new)
-      allow(GitReflow.git_server).to receive(:find_open_pull_request).and_return(nil)
-      allow(GitReflow.git_server).to receive(:create_pull_request).and_return(existing_gh_pull_request)
+      allow(workflow.git_server).to receive(:get_build_status).and_return(Struct.new(:state, :description, :url, :target_url).new)
+      allow(workflow.git_server).to receive(:find_open_pull_request).and_return(nil)
+      allow(workflow.git_server).to receive(:create_pull_request).and_return(existing_gh_pull_request)
       allow(File).to receive(:open).with(pull_request_message_file, 'w')
       allow(File).to receive(:read).with(pull_request_message_file).and_return("bingo")
       allow(File).to receive(:delete)
@@ -139,7 +186,7 @@ describe GitReflow::Workflows::Core do
       })
     end
 
-    subject { GitReflow::Workflows::Core.review inputs }
+    subject { workflow.review inputs }
 
     it "fetches updates to the base branch" do
       expect { subject }.to have_run_command "git fetch origin master"
@@ -152,7 +199,7 @@ describe GitReflow::Workflows::Core do
     it "uses the current branch name as the text for the PR" do
       fake_file = double
       expect(File).to receive(:open).with(pull_request_message_file, "w").and_yield(fake_file)
-      expect(fake_file).to receive(:write).with(GitReflow.current_branch)
+      expect(fake_file).to receive(:write).with(workflow.current_branch)
       subject
     end
 
@@ -176,7 +223,7 @@ describe GitReflow::Workflows::Core do
     context "and a PR template exists" do
       let(:template_content) { "hey now" }
       before do
-        allow(GitReflow).to receive(:pull_request_template).and_return(template_content)
+        allow(workflow).to receive(:pull_request_template).and_return(template_content)
       end
 
       it "uses the template's content for the PR" do
@@ -185,7 +232,6 @@ describe GitReflow::Workflows::Core do
         expect(fake_file).to receive(:write).with(template_content)
         subject
       end
-
     end
 
     context "providing a base branch" do
@@ -198,7 +244,7 @@ describe GitReflow::Workflows::Core do
       end
 
       it "creates a pull request using the custom base branch" do
-        expect(GitReflow.git_server).to receive(:create_pull_request).with({
+        expect(workflow.git_server).to receive(:create_pull_request).with({
           title: 'bingo',
           body: "\n",
           head: "#{user}:#{feature_branch}",
@@ -208,6 +254,25 @@ describe GitReflow::Workflows::Core do
       end
     end
 
+    context 'when a base branch is configured' do
+      before do
+        stub_command_line_inputs('Submit pull request? (Y)' => 'yes')
+        allow(GitReflow::Config).to receive(:get).and_call_original
+        allow(GitReflow::Config).to receive(:get).with('reflow.base-branch').and_return('racecar')
+        inputs.delete(:base)
+      end
+
+      it 'creates a pull request using the custom base branch' do
+        expect(GitReflow.git_server).to receive(:create_pull_request).with({
+          title: 'bingo',
+          body: "\n",
+          head: "#{user}:#{feature_branch}",
+          base: 'racecar'
+        })
+        subject
+      end
+    end
+
     context "providing only a title" do
       let(:inputs) {{ title: "Amazing new feature" }}
 
@@ -218,7 +283,7 @@ describe GitReflow::Workflows::Core do
       end
 
       it "creates a pull request with only the given title" do
-        expect(GitReflow.git_server).to receive(:create_pull_request).with({
+        expect(workflow.git_server).to receive(:create_pull_request).with({
           title: inputs[:title],
           body: nil,
           head: "#{user}:#{feature_branch}",
@@ -236,7 +301,7 @@ describe GitReflow::Workflows::Core do
     end
 
     context "providing only a body" do
-      let(:inputs) {{ body:  "Please pull this in!" }}
+      let(:inputs) {{ message:  "Please pull this in!" }}
 
       before do
         stub_command_line_inputs({
@@ -245,9 +310,9 @@ describe GitReflow::Workflows::Core do
       end
 
       it "creates a pull request with the body as both title and body" do
-        expect(GitReflow.git_server).to receive(:create_pull_request).with({
-          title: inputs[:body],
-          body: inputs[:body],
+        expect(workflow.git_server).to receive(:create_pull_request).with({
+          title: inputs[:message],
+          body: inputs[:message],
           head: "#{user}:#{feature_branch}",
           base: 'master'
         })
@@ -256,7 +321,7 @@ describe GitReflow::Workflows::Core do
     end
 
     context "providing both title and body" do
-      let(:inputs) {{ title: "Amazing new feature", body:  "Please pull this in!" }}
+      let(:inputs) {{ title: "Amazing new feature", message:  "Please pull this in!" }}
 
       before do
         stub_command_line_inputs({
@@ -265,9 +330,9 @@ describe GitReflow::Workflows::Core do
       end
 
       it "creates a pull request with only the given title" do
-        expect(GitReflow.git_server).to receive(:create_pull_request).with({
+        expect(workflow.git_server).to receive(:create_pull_request).with({
           title: inputs[:title],
-          body: inputs[:body],
+          body: inputs[:message],
           head: "#{user}:#{feature_branch}",
           base: 'master'
         })
@@ -277,7 +342,7 @@ describe GitReflow::Workflows::Core do
 
     context "with existing pull request" do
       before do
-        expect(GitReflow.git_server).to receive(:find_open_pull_request).and_return(existing_gh_pull_request)
+        expect(workflow.git_server).to receive(:find_open_pull_request).and_return(existing_gh_pull_request)
         allow(existing_gh_pull_request).to receive(:display_pull_request_summary)
       end
 
@@ -297,7 +362,7 @@ describe GitReflow::Workflows::Core do
       end
 
       it "creates a pull request" do
-        expect(GitReflow.git_server).to receive(:create_pull_request).with({
+        expect(workflow.git_server).to receive(:create_pull_request).with({
           title: 'bingo',
           body: "\n",
           head: "#{user}:#{feature_branch}",
@@ -307,9 +372,27 @@ describe GitReflow::Workflows::Core do
       end
 
       it "notifies the user that the pull request was created" do
-        expect(GitReflow.git_server).to receive(:create_pull_request).and_return(existing_gh_pull_request)
+        expect(workflow.git_server).to receive(:create_pull_request).and_return(existing_gh_pull_request)
         expect{ subject }.to have_said "Successfully created pull request ##{existing_gh_pull_request.number}: #{existing_gh_pull_request.title}\nPull Request URL: #{existing_gh_pull_request.html_url}\n", :success
       end
+
+      context "when pull request creation fails" do
+        let(:github_error) { Github::Error::UnprocessableEntity.new(eval(Fixture.new('pull_requests/pull_request_branch_nonexistent_error.json').to_s)) }
+
+        it "retries creating a pull request" do
+          call_count = 0
+          allow(workflow.git_server).to receive(:create_pull_request) do
+            call_count += 1
+            (call_count <= 1) ? raise(github_error) : existing_gh_pull_request
+          end
+          expect{ subject }.to have_said "Successfully created pull request ##{existing_gh_pull_request.number}: #{existing_gh_pull_request.title}\nPull Request URL: #{existing_gh_pull_request.html_url}\n", :success
+        end
+
+        it "reports failures even after retrying" do
+          allow(workflow.git_server).to receive(:create_pull_request).and_raise github_error
+          expect { subject }.to have_said "Github Error: #{github_error.to_s}", :error
+        end
+      end
     end
 
     context "aborting during PR template review" do
@@ -320,7 +403,7 @@ describe GitReflow::Workflows::Core do
       end
 
       it "does not create a pull request" do
-        expect(GitReflow.git_server).to_not receive(:create_pull_request)
+        expect(workflow.git_server).to_not receive(:create_pull_request)
         subject
       end
 
@@ -334,17 +417,17 @@ describe GitReflow::Workflows::Core do
     let(:feature_branch)     { 'new-feature' }
     let(:destination_branch) { nil }
 
-    subject { GitReflow::Workflows::Core.status destination_branch: destination_branch }
+    subject { workflow.status destination_branch: destination_branch }
 
     before do
       allow(GitReflow).to receive(:git_server).and_return(GitReflow::GitServer)
-      allow(GitReflow.git_server).to receive(:get_build_status).and_return(Struct.new(:state, :description, :url, :target_url).new)
+      allow(workflow.git_server).to receive(:get_build_status).and_return(Struct.new(:state, :description, :url, :target_url).new)
       allow(GitReflow).to receive(:current_branch).and_return(feature_branch)
       allow(existing_gh_pull_request).to receive(:display_pull_request_summary)
     end
 
     context "with no existing pull request" do
-      before { allow(GitReflow.git_server).to receive(:find_open_pull_request).with({from: feature_branch, to: 'master'}).and_return(nil) }
+      before { allow(workflow.git_server).to receive(:find_open_pull_request).with({from: feature_branch, to: 'master'}).and_return(nil) }
       it     { expect{ subject }.to have_said "No pull request exists for #{feature_branch} -> master", :notice }
       it     { expect{ subject }.to have_said "Run 'git reflow review master' to start the review process", :notice }
     end
@@ -352,7 +435,7 @@ describe GitReflow::Workflows::Core do
     context "with an existing pull request" do
       let(:destination_branch) { 'master' }
       before do
-        allow(GitReflow.git_server).to receive(:find_open_pull_request).and_return(existing_gh_pull_request)
+        allow(workflow.git_server).to receive(:find_open_pull_request).and_return(existing_gh_pull_request)
       end
 
       it "displays a summary of the pull request" do
@@ -364,7 +447,19 @@ describe GitReflow::Workflows::Core do
         let(:destination_branch) { 'develop' }
 
         it "uses the custom destination branch to lookup the pull request" do
-          expect(GitReflow.git_server).to receive(:find_open_pull_request).with({from: feature_branch, to: destination_branch}).and_return(existing_gh_pull_request)
+          expect(workflow.git_server).to receive(:find_open_pull_request).with({from: feature_branch, to: destination_branch}).and_return(existing_gh_pull_request)
+          subject
+        end
+      end
+
+      context "when custom base-branch is configured" do
+        before do
+          allow(GitReflow::Config).to receive(:get).and_call_original
+          allow(GitReflow::Config).to receive(:get).with('reflow.base-branch').and_return('racecar')
+        end
+        subject { workflow.status }
+        it "uses the custom configured base-branch to lookup the pull request" do
+          expect(GitReflow.git_server).to receive(:find_open_pull_request).with({from: feature_branch, to: 'racecar'}).and_return(existing_gh_pull_request)
           subject
         end
       end
@@ -374,7 +469,7 @@ describe GitReflow::Workflows::Core do
   describe ".deploy" do
     let(:deploy_command) { "bundle exec cap #{destination} deploy" }
     let(:destination)    { nil }
-    subject              { GitReflow::Workflows::Core.deploy(destination_server: destination) }
+    subject              { workflow.deploy(destination_server: destination) }
 
     before do
       stub_command_line_inputs({
@@ -409,16 +504,16 @@ describe GitReflow::Workflows::Core do
   describe ".stage" do
     let(:feature_branch) { 'new-feature' }
 
-    subject { GitReflow::Workflows::Core.stage }
+    subject { workflow.stage }
 
     before do
-      allow(GitReflow).to receive(:current_branch).and_return(feature_branch)
-      allow(GitReflow::Config).to receive(:get).and_call_original
+      allow(workflow).to receive(:current_branch).and_return(feature_branch)
+      allow(workflow.git_config).to receive(:get).and_call_original
       allow(GitReflow::Workflows::Core).to receive(:deploy)
     end
 
     it "checks out and updates the staging branch" do
-      expect(GitReflow::Config).to receive(:get).with('reflow.staging-branch', local: true).and_return('staging')
+      expect(workflow.git_config).to receive(:get).with('reflow.staging-branch', local: true).and_return('staging')
       expect { subject }.to have_run_commands_in_order([
         "git checkout staging",
         "git pull origin staging",
@@ -429,9 +524,9 @@ describe GitReflow::Workflows::Core do
 
     context "merge is not successful" do
       before do
-        allow(GitReflow::Config).to receive(:get).with('reflow.staging-branch', local: true).and_return('staging')
-        allow(GitReflow).to receive(:run_command_with_label).and_call_original
-        expect(GitReflow).to receive(:run_command_with_label).with("git merge #{feature_branch}", with_system: true).and_return(false)
+        allow(workflow.git_config).to receive(:get).with('reflow.staging-branch', local: true).and_return('staging')
+        allow(workflow).to receive(:run_command_with_label).and_call_original
+        expect(workflow).to receive(:run_command_with_label).with("git merge #{feature_branch}", with_system: true).and_return(false)
       end
 
       it "notifies the user of unsuccessful merge" do
@@ -450,9 +545,9 @@ describe GitReflow::Workflows::Core do
 
     context "merge is successful" do
       before do
-        allow(GitReflow::Config).to receive(:get).with('reflow.staging-branch', local: true).and_return('staging')
-        allow(GitReflow).to receive(:run_command_with_label).and_call_original
-        expect(GitReflow).to receive(:run_command_with_label).with("git merge #{feature_branch}", with_system: true).and_return(true).and_call_original
+        allow(workflow.git_config).to receive(:get).with('reflow.staging-branch', local: true).and_return('staging')
+        allow(workflow).to receive(:run_command_with_label).and_call_original
+        expect(workflow).to receive(:run_command_with_label).with("git merge #{feature_branch}", with_system: true).and_return(true).and_call_original
       end
 
       specify { expect{ subject }.to have_run_command "git push origin staging" }
@@ -470,19 +565,19 @@ describe GitReflow::Workflows::Core do
 
     context "no staging branch has been setup" do
       before do
-        allow(GitReflow::Config).to receive(:get).with('reflow.staging-branch', local: true).and_return('')
+        allow(workflow.git_config).to receive(:get).with('reflow.staging-branch', local: true).and_return('')
         stub_command_line_inputs({
           "What's the name of your staging branch? (default: 'staging') " => "bobby"
           })
       end
 
       it "sets the reflow.staging-branch git config to 'staging'" do
-        expect(GitReflow::Config).to receive(:set).with("reflow.staging-branch", "bobby", local: true)
+        expect(workflow.git_config).to receive(:set).with("reflow.staging-branch", "bobby", local: true)
         subject
       end
 
       it "checks out and updates the staging branch" do
-        allow(GitReflow::Config).to receive(:set).with("reflow.staging-branch", "bobby", local: true)
+        allow(workflow.git_config).to receive(:set).with("reflow.staging-branch", "bobby", local: true)
         expect { subject }.to have_run_commands_in_order([
           "git checkout bobby",
           "git pull origin bobby",
@@ -519,23 +614,25 @@ describe GitReflow::Workflows::Core do
     let(:user)           { 'reenhanced' }
     let(:repo)           { 'repo' }
 
-    subject { GitReflow::Workflows::Core.deliver }
+    subject { workflow.deliver }
 
     before do
       allow(GitReflow).to receive(:git_server).and_return(GitReflow::GitServer)
       allow(GitReflow).to receive(:remote_user).and_return(user)
+      allow(workflow).to receive(:remote_user).and_return(user)
       allow(GitReflow).to receive(:current_branch).and_return(feature_branch)
-      allow(GitReflow.git_server).to receive(:get_build_status).and_return(Struct.new(:state, :description, :url, :target_url).new)
+      allow(workflow).to receive(:current_branch).and_return(feature_branch)
+      allow(workflow.git_server).to receive(:get_build_status).and_return(Struct.new(:state, :description, :url, :target_url).new)
     end
 
     context "pull request does not exist" do
-      before  { allow(GitReflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'master').and_return(nil) }
+      before  { allow(workflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'master').and_return(nil) }
       specify { expect{ subject }.to have_said "No pull request exists for #{user}:#{feature_branch}\nPlease submit your branch for review first with \`git reflow review\`", :deliver_halted }
     end
 
     context "pull request exists" do
       before do
-        allow(GitReflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'master').and_return(existing_gh_pull_request)
+        allow(workflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'master').and_return(existing_gh_pull_request)
         allow(GitReflow::Workflows::Core).to receive(:status)
       end
 
@@ -586,11 +683,16 @@ describe GitReflow::Workflows::Core do
         end
 
         context "but forcing the deliver" do
-          subject { GitReflow::Workflows::Core.deliver force: true }
+          subject { workflow.deliver force: true }
 
           before do
             allow(existing_gh_pull_request).to receive(:good_to_merge?).with(force: true).and_return(true)
-            allow(existing_gh_pull_request).to receive(:merge!).with(force: true, base: 'master', skip_lgtm: true)
+            allow(existing_gh_pull_request).to receive(:merge!).with(
+              force: true,
+              merge_method: "squash",
+              base: 'master',
+              skip_lgtm: false
+            )
           end
 
           it "displays the status of the PR" do
@@ -599,28 +701,74 @@ describe GitReflow::Workflows::Core do
           end
 
           it "merges the feature branch anyway" do
-            expect(existing_gh_pull_request).to receive(:merge!).with(force: true, base: 'master', skip_lgtm: true)
+            expect(existing_gh_pull_request).to receive(:merge!).with(
+              force: true,
+              merge_method: "squash",
+              base: 'master',
+              skip_lgtm: false
+            )
             subject
           end
         end
       end
 
       context "and using a custom base branch" do
-        subject { GitReflow::Workflows::Core.deliver base: 'development' }
+        subject { workflow.deliver base: 'development' }
         before do
-          expect(GitReflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'development').and_return(existing_gh_pull_request)
+          expect(workflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'development').and_return(existing_gh_pull_request)
           allow(existing_gh_pull_request).to receive(:good_to_merge?).and_return(true)
         end
 
 
         it "displays the status of the PR" do
-          allow(existing_gh_pull_request).to receive(:merge!).with(base: 'development')
+          allow(existing_gh_pull_request).to receive(:merge!).with(
+            base: 'development',
+            merge_method: "squash",
+            force: false,
+            skip_lgtm: false
+          )
           expect(GitReflow::Workflows::Core).to receive(:status).with(destination_branch: 'development')
           subject
         end
 
         it "merges the feature branch" do
-          expect(existing_gh_pull_request).to receive(:merge!).with(base: 'development')
+          expect(existing_gh_pull_request).to receive(:merge!).with(
+            base: "development",
+            merge_method: "squash",
+            force: false,
+            skip_lgtm: false
+          )
+          subject
+        end
+      end
+
+      context "when a custom base-branch is configured" do
+        subject { workflow.deliver }
+        before do
+          expect(GitReflow.git_server).to receive(:find_open_pull_request).with( from: feature_branch, to: 'racecar').and_return(existing_gh_pull_request)
+          allow(existing_gh_pull_request).to receive(:good_to_merge?).and_return(true)
+          allow(GitReflow::Config).to receive(:get).with('reflow.base-branch').and_return('racecar')
+        end
+
+
+        it "displays the status of the PR" do
+          allow(existing_gh_pull_request).to receive(:merge!).with(
+            base: 'racecar',
+            merge_method: "squash",
+            force: false,
+            skip_lgtm: false
+          )
+          expect(GitReflow::Workflows::Core).to receive(:status).with(destination_branch: 'racecar')
+          subject
+        end
+
+        it "merges the feature branch" do
+          expect(existing_gh_pull_request).to receive(:merge!).with(
+            base: "racecar",
+            merge_method: "squash",
+            force: false,
+            skip_lgtm: false
+          )
           subject
         end
       end
@@ -628,36 +776,46 @@ describe GitReflow::Workflows::Core do
   end
 
   describe ".refresh" do
-    subject { GitReflow::Workflows::Core.refresh }
+    subject { workflow.refresh }
 
     it "updates the feature branch with default remote repo and base branch" do
-      expect(GitReflow).to receive(:update_feature_branch).with(remote: 'origin', base: 'master')
+      expect(workflow).to receive(:update_feature_branch).with(remote: 'origin', base: 'master')
       subject
     end
 
     context "providing a custom base branch" do
-      subject { GitReflow::Workflows::Core.refresh base: 'development' }
+      subject { workflow.refresh base: 'development' }
 
       it "updates the feature branch with default remote repo and base branch" do
-        expect(GitReflow).to receive(:update_feature_branch).with(remote: 'origin', base: 'development')
+        expect(workflow).to receive(:update_feature_branch).with(remote: 'origin', base: 'development')
+        subject
+      end
+    end
+
+    context "when a custom base branch is configured" do
+      before { allow(workflow.git_config).to receive(:get).with('reflow.base-branch').and_return('racecar') }
+      subject { workflow.refresh }
+
+      it "updates the feature branch with custom base branch" do
+        expect(workflow).to receive(:update_feature_branch).with(remote: 'origin', base: 'racecar')
         subject
       end
     end
 
     context "provding a custom remote repo" do
-      subject { GitReflow::Workflows::Core.refresh remote: 'upstream' }
+      subject { workflow.refresh remote: 'upstream' }
 
       it "updates the feature branch with default remote repo and base branch" do
-        expect(GitReflow).to receive(:update_feature_branch).with(remote: 'upstream', base: 'master')
+        expect(workflow).to receive(:update_feature_branch).with(remote: 'upstream', base: 'master')
         subject
       end
     end
 
     context "providing a custom base branch and remote repo" do
-      subject { GitReflow::Workflows::Core.refresh remote: 'upstream', base: 'development' }
+      subject { workflow.refresh remote: 'upstream', base: 'development' }
 
       it "updates the feature branch with default remote repo and base branch" do
-        expect(GitReflow).to receive(:update_feature_branch).with(remote: 'upstream', base: 'development')
+        expect(workflow).to receive(:update_feature_branch).with(remote: 'upstream', base: 'development')
         subject
       end
     end