toolshed 1.0.2 → 1.0.3

data/lib/toolshed/server_administration/ssh.rb

@@ -1,3 +1,5 @@
+require 'toolshed/password'
+
 require 'net/ssh'
 
 module Toolshed
@@ -81,8 +83,8 @@ module Toolshed
         end
 
         def set_ssh_options
-          self.ssh_options.merge!({ keys: [self.keys] }) unless self.keys.blank?
-          self.ssh_options.merge!({ password: self.password.read_user_input_password('password') }) if self.keys.blank?
+          self.ssh_options.merge!({ keys: [self.keys] }) unless keys.nil? || keys.empty?
+          self.ssh_options.merge!({ password: self.password.read_user_input_password('password') }) if keys.nil? || keys.empty?
         end
     end
   end

data/lib/toolshed/ticket_tracking/jira.rb

@@ -1,3 +1,5 @@
+require 'jira'
+
 module Toolshed
   module TicketTracking
     class Jira < Base
@@ -8,11 +10,11 @@ module Toolshed
       attr_accessor :project, :client, :owner, :ticket, :default_pull_request_title_format
 
       def initialize(options={})
-        username = (options[:username].nil?) ? Toolshed::Client::ticket_tracker_username : options[:username]
-        password = (options[:password].nil?) ? Toolshed::Client::ticket_tracker_password : options[:password]
+        username = (options[:username].nil?) ? Toolshed::Client.instance.ticket_tracker_username : options[:username]
+        password = (options[:password].nil?) ? Toolshed::Client.instance.ticket_tracker_password : options[:password]
 
-        self.owner      = Toolshed::Client.ticket_tracker_owner
-        self.default_pull_request_title_format = Toolshed::Client.default_pull_request_title_format ||= "[summary]"
+        self.owner      = Toolshed::Client.instance.ticket_tracker_owner
+        self.default_pull_request_title_format = Toolshed::Client.instance.default_pull_request_title_format ||= "[summary]"
 
         self.client = JIRA::Client.new({
           username:     username,
@@ -71,7 +73,7 @@ module Toolshed
 
       class << self
         def username
-          return Toolshed::Client::ticket_tracker_username unless Toolshed::Client::ticket_tracker_username.nil?
+          return Toolshed::Client.instance.ticket_tracker_username unless Toolshed::Client.instance.ticket_tracker_username.nil?
 
           # prompt to ask for username
           puts "Jira username? "
@@ -79,7 +81,7 @@ module Toolshed
         end
 
         def password
-          return Toolshed::Client::ticket_tracker_password unless Toolshed::Client::ticket_tracker_password.nil?
+          return Toolshed::Client.instance.ticket_tracker_password unless Toolshed::Client.instance.ticket_tracker_password.nil?
 
           # prompt to ask for password
           system "stty -echo"

data/lib/toolshed/ticket_tracking/pivotal_tracker.rb

@@ -1,3 +1,5 @@
+require 'pivotal-tracker'
+
 module Toolshed
   module TicketTracking
     class PivotalTracker < Base
@@ -9,9 +11,9 @@ module Toolshed
       attr_accessor :project_id, :token, :story, :default_pull_request_title_format
 
       def initialize(options={})
-        username = Toolshed::Client::pivotal_tracker_username
-        password = Toolshed::Client::pivotal_tracker_password
-        self.default_pull_request_title_format = Toolshed::Client.default_pull_request_title_format ||= "[title]"
+        username = Toolshed::Client.instance.pivotal_tracker_username
+        password = Toolshed::Client.instance.pivotal_tracker_password
+        self.default_pull_request_title_format = Toolshed::Client.instance.default_pull_request_title_format ||= "[title]"
 
         unless (options[:username].nil?)
           username = options[:username]
@@ -23,7 +25,7 @@ module Toolshed
 
         self.token = ::PivotalTracker::Client.token(username, password)
 
-        self.project_id = (options[:project_id].nil?) ? Toolshed::Client.default_pivotal_tracker_project_id : options[:project_id]
+        self.project_id = (options[:project_id].nil?) ? Toolshed::Client.instance.default_pivotal_tracker_project_id : options[:project_id]
         @pt_project = ::PivotalTracker::Project.find(self.project_id)
         self.story = @pt_project.stories.find(options[:ticket_id])
       end
@@ -74,7 +76,7 @@ module Toolshed
 
       class << self
         def username
-          username = Toolshed::Client::pivotal_tracker_username
+          username = Toolshed::Client.instance.pivotal_tracker_username
           if (username.nil?)
             # prompt to ask for username
             puts "PivotalTracker username? "
@@ -85,7 +87,7 @@ module Toolshed
         end
 
         def password
-          password = Toolshed::Client::pivotal_tracker_password
+          password = Toolshed::Client.instance.pivotal_tracker_password
           if (password.nil?)
             # prompt to ask for password
             system "stty -echo"

data/lib/toolshed/time_tracking/harvest.rb

@@ -1,3 +1,5 @@
+require 'harvested'
+
 module Toolshed
   module TimeTracking
     class Harvest
@@ -9,21 +11,13 @@ module Toolshed
       attr_accessor :harvest_client, :project_id, :line_break, :start_list_item, :end_list_item, :start_unorder_list, :end_unorder_list, :format
 
       def initialize(options={})
-        username = Toolshed::Client::time_tracking_username
-        password = Toolshed::Client::time_tracking_password
-        owner = Toolshed::Client.time_tracking_owner
-
-        unless (options[:username].nil?)
-          username = options[:username]
-        end
+        username = Toolshed::Client.instance.time_tracking_username
+        password = Toolshed::Client.instance.time_tracking_password
+        owner = Toolshed::Client.instance.time_tracking_owner
 
-        unless (options[:password].nil?)
-           password = options[:password]
-        end
-
-        unless (options[:sub_domain].nil?)
-           owner = options[:sub_domain]
-        end
+        username = options[:username] unless options[:username].nil?
+        password = options[:password] unless options[:password].nil?
+        owner = options[:sub_domain] unless options[:sub_domain].nil?
 
         self.harvest_client = ::Harvest.client(subdomain: owner, username: username, password: password)
         self.project_id = options[:project_id] unless !options.has_key?(:project_id)

data/lib/toolshed/version.rb

@@ -1,3 +1,27 @@
+# encoding: UTF-8
+
+# Module for toolshed
 module Toolshed
-  VERSION = "1.0.2"
+  VERSION = '1.0.3'
+
+  # Display the version information with the toolshed banner
+  class Version
+    def self.banner
+      formatted_version = format('%80s', "Version: #{Toolshed::VERSION}")
+      formatted_authors_string = format('%80s', 'Authors: Jake Waller')
+puts <<-EOS
+ ______   ___    ___   _       _____ __ __    ___  ___   
+|      | /   \  /   \ | |     / ___/|  |  |  /  _]|   \  
+|      ||     ||     || |    (   \_ |  |  | /  [_ |    \ 
+|_|  |_||  O  ||  O  || |___  \__  ||  _  ||    _]|  D  |
+  |  |  |     ||     ||     | /  \ ||  |  ||   [_ |     |
+  |  |  |     ||     ||     | \    ||  |  ||     ||     |
+  |__|   \___/  \___/ |_____|  \___||__|__||_____||_____|
+                                                         
+#{formatted_version}
+#{formatted_authors_string}
+EOS
+      exit
+    end
+  end
 end

data/test/commands/checkout_branch_test.rb

@@ -2,19 +2,23 @@ require 'commands/commands_helper'
 require 'toolshed/commands/checkout_branch'
 
 class CheckoutBranchTest < Test::Unit::TestCase
+  def setup
+    @branch = Toolshed::Git::Branch.new
+    Toolshed.expects(:die).at_least(0).returns('die')
+  end
+
   def test_checkout_branch
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
 
     new_branch_name = random_branch_name
     create_and_checkout_branch(new_branch_name)
 
-    output = capture_stdout { Toolshed::Commands::CheckoutBranch.new.execute({}, { branch_name: current_branch }) }
-
-    assert_match /Switched to 'master'/, output
+    results = Toolshed::Commands::CheckoutBranch.new.execute({}, { branch_name: current_branch })
+    assert_equal 'die', results
   end
 
   def test_checkout_branch_prompt
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
 
     new_branch_name = random_branch_name
     create_and_checkout_branch(new_branch_name)   
@@ -22,7 +26,7 @@ class CheckoutBranchTest < Test::Unit::TestCase
     # stub the possible input
     Toolshed::Commands::CheckoutBranch.any_instance.stubs(:read_user_input).returns(current_branch)
 
-    output = capture_stdout { Toolshed::Commands::CheckoutBranch.new.execute({}) }
-    assert_match /Switched to 'master'/, output
+    results = Toolshed::Commands::CheckoutBranch.new.execute({})
+    assert_equal 'die', results
   end
 end

data/test/commands/create_branch_test.rb

@@ -2,63 +2,68 @@ require 'commands/commands_helper'
 require 'toolshed/commands/create_branch'
 
 class CreateBranchTest < Test::Unit::TestCase
+  def setup
+    @branch = Toolshed::Git::Branch.new
+    Toolshed.expects(:die).at_least(0).returns('die')
+  end
+
   def test_create_new_branch_passing_in_branch_name_branch_from
-    Toolshed::Client.pull_from_remote_name = 'origin'
-    Toolshed::Client.push_to_remote_name = 'origin'
+    Toolshed::Client.instance.pull_from_remote_name = 'origin'
+    Toolshed::Client.instance.push_to_remote_name = 'origin'
 
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
     new_branch_name = ::Faker::Lorem.word.downcase
 
-    output = capture_stdout { Toolshed::Commands::CreateBranch.new.execute({}, { branch_name: new_branch_name, branch_from: 'development' }) }
+    output = Toolshed::Commands::CreateBranch.new.execute({}, { branch_name: new_branch_name, branch_from: 'development' })
 
-    assert_match /Branch #{new_branch_name} has been created/, output
+    assert_match 'die', output
 
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    assert_equal 'development', Toolshed::Git::Base.branched_from
+    assert_equal new_branch_name, @branch.name
+    assert_equal 'development', Toolshed::Git::Branch.from
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     delete_branch(new_branch_name)
   end
 
   def test_create_new_branch_not_passing_in_branch_name_or_branch_from
-    Toolshed::Client.pull_from_remote_name = 'origin'
-    Toolshed::Client.push_to_remote_name = 'origin'
+    Toolshed::Client.instance.pull_from_remote_name = 'origin'
+    Toolshed::Client.instance.push_to_remote_name = 'origin'
 
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
     new_branch_name = ::Faker::Lorem.word.downcase
 
     # stub the possible input
     Toolshed::Commands::CreateBranch.any_instance.stubs(:read_user_input_branch_name).returns(new_branch_name)
     Toolshed::Commands::CreateBranch.any_instance.stubs(:read_user_input_branch_from).returns('development')
 
-    output = capture_stdout { Toolshed::Commands::CreateBranch.new.execute({}) }
+    output = Toolshed::Commands::CreateBranch.new.execute({})
 
-    assert_match /Branch #{new_branch_name} has been created/, output
+    assert_match 'die', output
 
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    assert_equal 'development', Toolshed::Git::Base.branched_from
+    assert_equal new_branch_name, @branch.name
+    assert_equal 'development', Toolshed::Git::Branch.from
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     delete_branch(new_branch_name)
   end
 
   def test_create_new_branch_without_passing_in_branch_from
-    Toolshed::Client.pull_from_remote_name = 'origin'
-    Toolshed::Client.push_to_remote_name = 'origin'
+    Toolshed::Client.instance.pull_from_remote_name = 'origin'
+    Toolshed::Client.instance.push_to_remote_name = 'origin'
 
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
     new_branch_name = ::Faker::Lorem.word.downcase
 
     # stub the possible input
     Toolshed::Commands::CreateBranch.any_instance.stubs(:read_user_input_branch_name).returns(new_branch_name)
 
-    output = capture_stdout { Toolshed::Commands::CreateBranch.new.execute({}, { branch_name: new_branch_name }) }
+    output = Toolshed::Commands::CreateBranch.new.execute({}, { branch_name: new_branch_name })
 
-    assert_match /Branch #{new_branch_name} has been created/, output
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    assert_equal 'master', Toolshed::Git::Base.branched_from
+    assert_match 'die', output
+    assert_equal new_branch_name, @branch.name
+    assert_equal 'master', Toolshed::Git::Branch.from
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     delete_branch(new_branch_name)
   end
 end

data/test/commands/create_pull_request_test.rb

@@ -1,15 +1,23 @@
 require 'commands/commands_helper'
 require 'toolshed/commands/create_pull_request'
+require 'toolshed/git/github'
+require 'toolshed/ticket_tracking/pivotal_tracker'
+require 'toolshed/git/branch'
 
 class CreatePullRequestTest < Test::Unit::TestCase
+  def setup
+    @branch = Toolshed::Git::Branch.new
+    Toolshed.expects(:die).at_least(0).returns('Exiting')
+  end
+
   def test_create_github_pull_request_no_ticket_tracking
-    Toolshed::Client.ticket_tracking_tool = ''
-    Toolshed::Client.git_tool = 'github'
-    Toolshed::Client.github_username = 'sample'
-    Toolshed::Client.github_password = 'sample'
+    Toolshed::Client.instance.ticket_tracking_tool = ''
+    Toolshed::Client.instance.git_tool = 'github'
+    Toolshed::Client.instance.github_username = 'sample'
+    Toolshed::Client.instance.github_password = 'sample'
 
-    Toolshed::Client.pull_from_repository_user = 'sample'
-    Toolshed::Client.pull_from_repository_name = 'sample_repo'
+    Toolshed::Client.instance.pull_from_repository_user = 'sample'
+    Toolshed::Client.instance.pull_from_repository_name = 'sample_repo'
 
     # mock up the pull request
     expected_result = {
@@ -29,34 +37,34 @@ class CreatePullRequestTest < Test::Unit::TestCase
       body: {
         title: 'Sample',
          body: 'Sample Body',
-         head: "#{Toolshed::Client.github_username}:#{Toolshed::Git::Base.branch_name}",
-         base: Toolshed::Git::Base.branched_from
+         head: "#{Toolshed::Client.instance.github_username}:#{@branch.name}",
+         base: Toolshed::Git::Branch.from
       }.to_json
     })
 
     HTTParty.
       expects(:post).
-      with("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.pull_from_repository_user}/#{Toolshed::Client.pull_from_repository_name}/pulls", github_default_options).
+      with("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.instance.pull_from_repository_user}/#{Toolshed::Client.instance.pull_from_repository_name}/pulls", github_default_options).
       returns(http_party_mock)
 
     # stub the possible input
     Toolshed::Commands::CreatePullRequest.any_instance.stubs(:read_user_input_add_note_to_ticket).returns(false)
 
-    output = capture_stdout { Toolshed::Commands::CreatePullRequest.new.execute({}, { title: 'Sample', body: 'Sample Body' }) }
-    assert_match /Created Pull Request: github.com\/pulls\/1/, output
+    result = Toolshed::Commands::CreatePullRequest.new.execute({}, { title: 'Sample', body: 'Sample Body' })
+    assert_equal 'github.com/pulls/1', result.pull_request_url
   end
 
   def test_create_github_pull_request_with_pivotal_tracker
-    Toolshed::Client.ticket_tracking_tool = 'pivotal_tracker'
-    Toolshed::Client.git_tool = 'github'
-    Toolshed::Client.github_username = 'sample'
-    Toolshed::Client.github_password = 'sample'
-    Toolshed::Client.pivotal_tracker_username = 'ptusername'
-    Toolshed::Client.pivotal_tracker_password = 'ptpassword'
-    Toolshed::Client.default_pivotal_tracker_project_id = '1234'
-    Toolshed::Client.pull_from_repository_user = 'sample'
-    Toolshed::Client.pull_from_repository_name = 'sample_repo'
-    Toolshed::Client.use_defaults = true
+    Toolshed::Client.instance.ticket_tracking_tool = 'pivotal_tracker'
+    Toolshed::Client.instance.git_tool = 'github'
+    Toolshed::Client.instance.github_username = 'sample'
+    Toolshed::Client.instance.github_password = 'sample'
+    Toolshed::Client.instance.pivotal_tracker_username = 'ptusername'
+    Toolshed::Client.instance.pivotal_tracker_password = 'ptpassword'
+    Toolshed::Client.instance.default_pivotal_tracker_project_id = '1234'
+    Toolshed::Client.instance.pull_from_repository_user = 'sample'
+    Toolshed::Client.instance.pull_from_repository_name = 'sample_repo'
+    Toolshed::Client.instance.use_defaults = true
 
     # mock up the pull request
     expected_result = {
@@ -76,14 +84,14 @@ class CreatePullRequestTest < Test::Unit::TestCase
       body: {
         title: 'Sample',
          body: 'Sample Body',
-         head: "#{Toolshed::Client.github_username}:#{Toolshed::Git::Base.branch_name}",
-         base: Toolshed::Git::Base.branched_from
+         head: "#{Toolshed::Client.instance.github_username}:#{@branch.name}",
+         base: Toolshed::Git::Branch.from
       }.to_json
     })
 
     HTTParty.
       expects(:post).
-      with("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.pull_from_repository_user}/#{Toolshed::Client.pull_from_repository_name}/pulls", github_default_options).
+      with("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.instance.pull_from_repository_user}/#{Toolshed::Client.instance.pull_from_repository_name}/pulls", github_default_options).
       returns(http_party_mock)
 
     # mock up the pivotal_tracker stuff
@@ -96,7 +104,7 @@ class CreatePullRequestTest < Test::Unit::TestCase
     pivotal_tracker_mock.stubs(:id => '1')
 
     PivotalTracker::Project.expects(:find).
-    with(Toolshed::Client.default_pivotal_tracker_project_id).
+    with(Toolshed::Client.instance.default_pivotal_tracker_project_id).
     returns(pivotal_tracker_mock)
 
     # mock up the story information
@@ -120,14 +128,14 @@ class CreatePullRequestTest < Test::Unit::TestCase
     Toolshed::Commands::CreatePullRequest.any_instance.stubs(:read_user_input_ticket_tracker_ticket_id).returns('1')
     Toolshed::Commands::CreatePullRequest.any_instance.stubs(:read_user_input_add_note_to_ticket).returns(false)
 
-    output = capture_stdout { Toolshed::Commands::CreatePullRequest.new.execute({}, { title: 'Sample', body: 'Sample Body' }) }
-    assert_match /Created Pull Request: github.com\/pulls\/1/, output
+    result = Toolshed::Commands::CreatePullRequest.new.execute({}, { title: 'Sample', body: 'Sample Body' })
+    assert_equal 'github.com/pulls/1', result.pull_request_url
   end
 
   def test_create_github_pull_request_with_invalid_ticket_tracker
-    Toolshed::Client.ticket_tracking_tool = 'unfuddle'
-    Toolshed::Client.git_tool = 'github'
-    output = capture_stdout { Toolshed::Commands::CreatePullRequest.new.execute({}, { title: 'Sample', body: 'Sample Body' }) }
-    assert_match /Ticket tracking tool is not supported at this time/, output
+    Toolshed::Client.instance.ticket_tracking_tool = 'unfuddle'
+    Toolshed::Client.instance.git_tool = 'github'
+    result = Toolshed::Commands::CreatePullRequest.new.execute({}, { title: 'Sample', body: 'Sample Body' })
+    assert_equal nil, result.pull_request_url
   end
 end

data/test/commands/delete_branch_test.rb

@@ -2,72 +2,82 @@ require 'commands/commands_helper'
 require 'toolshed/commands/delete_branch'
 
 class DeleteBranchTest < Test::Unit::TestCase
+  def setup
+    Toolshed.expects(:die).at_least(0).returns('Exiting')
+    @branch = Toolshed::Git::Branch.new
+  end
+
   def test_delete_branch_with_branch_name_passed
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
 
     new_branch_name = random_branch_name
     create_and_checkout_branch(new_branch_name, 'master')
 
     # go to the remote repo and verify it exists
     Dir.chdir(File.join(TEST_ROOT, "remote"))
-    remote_current_branch = Toolshed::Git::Base.branch_name
-    Toolshed::Git::Base.checkout(new_branch_name)
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    Toolshed::Git::Base.checkout(remote_current_branch)
+    remote_current_branch = @branch.name
+    Toolshed::Git::Branch.checkout(new_branch_name)
+    assert_equal new_branch_name, @branch.name
+    Toolshed::Git::Branch.checkout(remote_current_branch)
 
     Dir.chdir(File.join(TEST_ROOT, "local"))
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
 
-    output = capture_stdout { Toolshed::Commands::DeleteBranch.new.execute({}, { branch_name: new_branch_name }) }
-    assert_match /#{new_branch_name} has been deleted/, output
+    delete_branch_command = Toolshed::Commands::DeleteBranch.new
+    delete_branch_command.expects(:confirm_delete).returns(true)
+    result = delete_branch_command.execute({}, { branch_name: new_branch_name })
+    assert_equal 'Exiting', result
 
     branch_found = `git branch | grep #{new_branch_name}`
     assert_equal '', branch_found
   end
 
   def test_delete_branch_with_ticket_id_only_passed
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
 
     new_branch_name = "1234333_#{random_branch_name}"
     create_and_checkout_branch(new_branch_name, 'master')
 
     # go to the remote repo and verify it exists
     Dir.chdir(File.join(TEST_ROOT, "remote"))
-    remote_current_branch = Toolshed::Git::Base.branch_name
-    Toolshed::Git::Base.checkout(new_branch_name)
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    Toolshed::Git::Base.checkout(remote_current_branch)
+    remote_current_branch = @branch.name
+    Toolshed::Git::Branch.checkout(new_branch_name)
+    assert_equal new_branch_name, @branch.name
+    Toolshed::Git::Branch.checkout(remote_current_branch)
 
     Dir.chdir(File.join(TEST_ROOT, "local"))
-    Toolshed::Git::Base.checkout(current_branch)
-
-    output = capture_stdout { Toolshed::Commands::DeleteBranch.new.execute({}, { branch_name: '1234333' }) }
-    assert_match /#{new_branch_name} has been deleted/, output
+    Toolshed::Git::Branch.checkout(current_branch)
+    delete_branch_command = Toolshed::Commands::DeleteBranch.new
+    delete_branch_command.expects(:confirm_delete).returns(true)
+    result = delete_branch_command.execute({}, { branch_name: '1234333' })
+    assert_equal 'Exiting', result
 
     branch_found = `git branch | grep #{new_branch_name}`
     assert_equal '', branch_found
   end
 
   def test_delete_branch_without_branch_name_passed
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = @branch.name
 
     new_branch_name = random_branch_name
     create_and_checkout_branch(new_branch_name, 'master')
 
     # go to the remote repo and verify it exists
     Dir.chdir(File.join(TEST_ROOT, "remote"))
-    remote_current_branch = Toolshed::Git::Base.branch_name
-    Toolshed::Git::Base.checkout(new_branch_name)
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    Toolshed::Git::Base.checkout(remote_current_branch)
+    remote_current_branch = @branch.name
+    Toolshed::Git::Branch.checkout(new_branch_name)
+    assert_equal new_branch_name, @branch.name
+    Toolshed::Git::Branch.checkout(remote_current_branch)
 
     Dir.chdir(File.join(TEST_ROOT, "local"))
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
 
     Toolshed::Commands::DeleteBranch.any_instance.stubs(:read_user_input).returns(new_branch_name)
 
-    output = capture_stdout { Toolshed::Commands::DeleteBranch.new.execute({}) }
-    assert_match /#{new_branch_name} has been deleted/, output
+    delete_branch_command = Toolshed::Commands::DeleteBranch.new
+    delete_branch_command.expects(:confirm_delete).returns(true)
+    result = delete_branch_command.execute({})
+    assert_equal 'Exiting', result
 
     branch_found = `git branch | grep #{new_branch_name}`
     assert_equal '', branch_found