toolshed 0.0.5 → 0.0.6

data/lib/toolshed.rb

@@ -1,6 +1,8 @@
 require "toolshed/version"
 require 'httparty'
 require 'pivotal-tracker'
+require 'harvested'
+require 'veto'
 
 module Toolshed
   BLANK_REGEX = /\S+/
@@ -20,6 +22,10 @@ end
 
 require 'toolshed/base'
 require 'toolshed/client'
-require 'toolshed/github'
-require 'toolshed/pivotal_tracker'
+require 'toolshed/git/git'
+require 'toolshed/git/github'
+require 'toolshed/ticket_tracking/ticket_tracking'
+require 'toolshed/ticket_tracking/pivotal_tracker'
+require 'toolshed/time_tracking/time_tracking'
+require 'toolshed/time_tracking/harvest'
 require 'toolshed/error'

data/test/commands/checkout_branch_test.rb

@@ -0,0 +1,28 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/checkout_branch'
+
+class CheckoutBranchTest < Test::Unit::TestCase
+  def test_checkout_branch
+    current_branch = Toolshed::Git::Base.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
+  end
+
+  def test_checkout_branch_prompt
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = random_branch_name
+    create_and_checkout_branch(new_branch_name)   
+
+    # 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
+  end
+end

data/test/commands/commands_helper.rb

@@ -0,0 +1,2 @@
+require 'helper'
+require 'git/git_helper'

data/test/commands/create_branch_test.rb

@@ -0,0 +1,44 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/create_branch'
+
+class CreateBranchTest < Test::Unit::TestCase
+  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'
+
+    current_branch = Toolshed::Git::Base.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' }) }
+
+    assert_match /Branch #{new_branch_name} has been created/, output
+
+    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
+    assert_equal 'development', Toolshed::Git::Base.branched_from
+
+    Toolshed::Git::Base.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'
+
+    current_branch = Toolshed::Git::Base.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({}) }
+
+    assert_match /Branch #{new_branch_name} has been created/, output
+
+    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
+    assert_equal 'development', Toolshed::Git::Base.branched_from
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+end

data/test/commands/create_pull_request_test.rb

@@ -0,0 +1,125 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/create_pull_request'
+
+class CreatePullRequestTest < Test::Unit::TestCase
+  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.pull_from_repository_user = 'sample'
+    Toolshed::Client.pull_from_repository_name = 'sample_repo'
+
+    # mock up the pull request
+    expected_result = {
+      "html_url" => "github.com/pulls/1",
+    }.to_json
+    http_mock = mock('Net::HTTPResponse')
+    http_mock.stubs(:code => '200', :message => "OK", :content_type => "text/html", :body => expected_result)
+
+    http_party_mock = mock('HTTParty')
+    http_party_mock.stubs(:response => http_mock)
+
+    # create new github object
+    github = Toolshed::Git::Github.new
+
+    github_default_options = github.default_options
+    github_default_options.merge!({
+      body: {
+        title: 'Sample',
+         body: 'Sample Body',
+         head: "#{Toolshed::Client.github_username}:#{Toolshed::Git::Base.branch_name}",
+         base: Toolshed::Git::Base.branched_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).
+      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
+  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
+
+    # mock up the pull request
+    expected_result = {
+      "html_url" => "github.com/pulls/1",
+    }.to_json
+    http_mock = mock('Net::HTTPResponse')
+    http_mock.stubs(:code => '200', :message => "OK", :content_type => "text/html", :body => expected_result)
+
+    http_party_mock = mock('HTTParty')
+    http_party_mock.stubs(:response => http_mock)
+
+    # create new github object
+    github = Toolshed::Git::Github.new
+
+    github_default_options = github.default_options
+    github_default_options.merge!({
+      body: {
+        title: 'Sample',
+         body: 'Sample Body',
+         head: "#{Toolshed::Client.github_username}:#{Toolshed::Git::Base.branch_name}",
+         base: Toolshed::Git::Base.branched_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).
+      returns(http_party_mock)
+
+
+    # mock up the pivotal_tracker stuff
+    PivotalTracker::Client.expects(:token).
+    with(Toolshed::TicketTracking::PivotalTracker.username, Toolshed::TicketTracking::PivotalTracker.password).
+    returns('3454354token')
+
+    # mock up the project response
+    pivotal_tracker_mock = mock('PivotalTracker::Client')
+    pivotal_tracker_mock.stubs(:id => '1')
+
+    PivotalTracker::Project.expects(:find).
+    with(Toolshed::Client.default_pivotal_tracker_project_id).
+    returns(pivotal_tracker_mock)
+
+    # mock up the story information
+    pivotal_tracker_story_mock = mock('PivotalTracker::Story')
+    pivotal_tracker_story_mock.stubs(:url => 'http://www.example.com', :id => '1', :name => "Test Title")
+
+    Toolshed::TicketTracking::PivotalTracker.any_instance.expects(:story_information).
+    with('1').
+    returns(pivotal_tracker_story_mock)
+
+    # stub the possible input
+    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
+  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
+  end
+end

data/test/commands/delete_branch_test.rb

@@ -0,0 +1,75 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/delete_branch'
+
+class DeleteBranchTest < Test::Unit::TestCase
+  def test_delete_branch_with_branch_name_passed
+    current_branch = Toolshed::Git::Base.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)
+
+    Dir.chdir(File.join(TEST_ROOT, "local"))
+    Toolshed::Git::Base.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
+
+    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
+
+    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)
+
+    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
+
+    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
+
+    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)
+
+    Dir.chdir(File.join(TEST_ROOT, "local"))
+    Toolshed::Git::Base.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
+
+    branch_found = `git branch | grep #{new_branch_name}`
+    assert_equal '', branch_found
+  end
+end

data/test/commands/push_branch_test.rb

@@ -0,0 +1,49 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/push_branch'
+
+class PushBranchTest < Test::Unit::TestCase
+  def test_push_branch_current_working_branch
+    Toolshed::Client.push_to_remote_name = 'origin'
+
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = random_branch_name
+    create_and_checkout_branch(new_branch_name, 'master')
+
+    output = capture_stdout { Toolshed::Commands::PushBranch.new.execute({}) }
+    assert_match /#{new_branch_name} has been pushed/, output
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+
+  def test_push_branch_by_ticket_id
+    Toolshed::Client.push_to_remote_name = 'origin'
+
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = "555558_#{random_branch_name}"
+    create_and_checkout_branch(new_branch_name, 'master')
+
+    output = capture_stdout { Toolshed::Commands::PushBranch.new.execute({}, { branch_name: '555558' }) }
+    assert_match /#{new_branch_name} has been pushed/, output
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+
+  def test_push_branch_current_working_branch_with_force
+    Toolshed::Client.push_to_remote_name = 'origin'
+
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = random_branch_name
+    create_and_checkout_branch(new_branch_name, 'master')
+
+    output = capture_stdout { Toolshed::Commands::PushBranch.new.execute({}, { force: true }) }
+    assert_match /#{new_branch_name} has been pushed/, output
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+end

data/test/config.rb

@@ -0,0 +1 @@
+TEST_ROOT = File.expand_path(File.dirname(__FILE__))

data/test/git/git_helper.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+def create_and_checkout_branch(name, branch_from='master')
+  save_stash
+
+  until system("git checkout -b #{name} origin/#{branch_from} #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git push origin #{name} #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+end
+
+def pop_stash
+  system("git stash pop #{Toolshed::Client.git_quiet}")
+end
+
+def save_stash
+  system("git stash save #{Toolshed::Client.git_quiet}")
+end
+
+def delete_branch(branch_name)
+  until system("git branch -D #{branch_name} --quiet")
+    sleep 1
+  end
+end
+
+def random_branch_name
+  "#{::Faker::Lorem.word.downcase}_#{Time.now.to_i}"
+end

data/test/git/git_test.rb

@@ -0,0 +1,115 @@
+require 'git/git_helper'
+
+class GitTest < Test::Unit::TestCase
+  def test_get_branch_name
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = random_branch_name
+    create_and_checkout_branch(new_branch_name)
+
+    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
+
+    Toolshed::Git::Base.checkout(current_branch)
+    pop_stash
+    delete_branch(new_branch_name)
+  end
+
+  def test_checkout_branch
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = random_branch_name
+    create_and_checkout_branch(new_branch_name)
+
+    Toolshed::Git::Base.checkout(current_branch)
+
+    assert_equal current_branch, Toolshed::Git::Base.branch_name
+
+    delete_branch(new_branch_name)
+  end
+
+  def test_checkout_branch_by_id
+    current_branch = Toolshed::Git::Base.branch_name
+
+    branch_id = "124233"
+
+    new_branch_name = random_branch_name
+    new_branch_name = "#{branch_id}_#{new_branch_name}"
+    create_and_checkout_branch(new_branch_name)
+
+    Toolshed::Git::Base.checkout(current_branch)
+    assert_equal current_branch, Toolshed::Git::Base.branch_name
+
+    Toolshed::Git::Base.checkout(branch_id)
+    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+
+  def test_branched_from
+    current_branch = Toolshed::Git::Base.branch_name
+    current_branch_branched_from = Toolshed::Git::Base.branched_from
+
+    new_branch_name = random_branch_name
+    create_and_checkout_branch(new_branch_name, 'development')
+
+    assert_equal 'development', Toolshed::Git::Base.branched_from
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+
+  def test_create_new_branch
+    current_branch = Toolshed::Git::Base.branch_name
+
+    new_branch_name = random_branch_name
+    git = Toolshed::Git::Base.new({
+      from_remote_branch_name: 'development',
+      to_remote_branch_name: new_branch_name,
+      from_remote_name: 'origin',
+      to_remote_name: 'origin',
+    })
+    git.create_branch
+
+    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
+    assert_equal 'development', Toolshed::Git::Base.branched_from
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+
+  def test_create_branch_from_remote_name_empty
+    new_branch_name = random_branch_name
+    git = Toolshed::Git::Base.new({
+      from_remote_branch_name: '',
+      to_remote_branch_name: new_branch_name,
+      from_remote_name: 'origin',
+      to_remote_name: 'origin',
+    })
+
+    exception = assert_raise(Veto::InvalidEntity) { git.create_branch }
+    assert_equal 'from_remote_branch_name is not present', exception.message.first
+  end
+
+  def test_delete_branch
+    current_branch = Toolshed::Git::Base.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)
+
+    Dir.chdir(File.join(TEST_ROOT, "local"))
+    Toolshed::Git::Base.checkout(current_branch)
+
+    Toolshed::Git::Base.delete(new_branch_name)
+
+    branch_found = `git branch | grep #{new_branch_name}`
+    assert_equal '', branch_found
+  end
+end

data/test/git/github_test.rb

@@ -0,0 +1,91 @@
+require 'git/git_helper'
+
+class GitHubTest < Test::Unit::TestCase
+  def test_list_branches
+    Toolshed::Client.github_username = 'sample'
+    Toolshed::Client.pull_from_repository_name = 'sample'
+
+    expected_result = [
+      {
+        "name" => "master",
+        "commit" => {
+          "sha" => "6dcb09b5b57875f334f61aebed695e2e4193db5e",
+          "url" => "https://api.github.com/repos/octocat/Hello-World/commits/c5b97d5ae6c19d5c5df71a34c7fbeeda2479ccbc"
+        }
+      },
+      {
+        "name" => "develop",
+        "commit" => {
+          "sha" => "6dcb09b5b57875f334f61aebed695e2e4193db5e",
+          "url" => "https://api.github.com/repos/octocat/Hello-World/commits/345lj5ae6c19d5c5df71a34c7fbeeda2479ccbc"
+        }
+      }
+    ].to_json
+    http_mock = mock('Net::HTTPResponse')
+    http_mock.stubs(:code => '200', :message => "OK", :content_type => "text/html", :body => expected_result)
+
+    http_party_mock = mock('HTTParty')
+    http_party_mock.stubs(:response => http_mock)
+
+    # create new github object
+    github = Toolshed::Git::Github.new
+
+    HTTParty.
+      expects(:get).
+      with("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.github_username}/#{Toolshed::Client.pull_from_repository_name}/branches", github.default_options).
+      returns(http_party_mock)
+
+    assert_equal JSON.parse(expected_result), github.list_branches
+  end
+
+  def test_create_pull_request
+    current_branch = Toolshed::Git::Base.branch_name
+    new_branch_name = '1234_testing'
+
+    Toolshed::Client.pull_from_repository_user = 'sample'
+    Toolshed::Client.pull_from_repository_name = 'sample_repo'
+    create_and_checkout_branch(new_branch_name)
+
+    expected_result = {
+      "html_url" => "github.com/pulls/1",
+    }.to_json
+    http_mock = mock('Net::HTTPResponse')
+    http_mock.stubs(:code => '200', :message => "OK", :content_type => "text/html", :body => expected_result)
+
+    http_party_mock = mock('HTTParty')
+    http_party_mock.stubs(:response => http_mock)
+
+    # create new github object
+    github = Toolshed::Git::Github.new
+
+    github_default_options = github.default_options
+    github_default_options.merge!({
+      body: {
+        title: 'Sample',
+         body: 'Sample Body',
+         head: "#{Toolshed::Client.github_username}:#{Toolshed::Git::Base.branch_name}",
+         base: Toolshed::Git::Base.branched_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).
+      returns(http_party_mock)
+
+    assert_equal JSON.parse(expected_result), github.create_pull_request('Sample', 'Sample Body')
+
+    Toolshed::Git::Base.checkout(current_branch)
+    delete_branch(new_branch_name)
+  end
+
+  def test_get_username
+    Toolshed::Client.github_username = 'tester'
+    assert_equal 'tester', Toolshed::Git::Github.username
+  end
+
+  def test_get_password
+    Toolshed::Client.github_password = 'tester1234'
+    assert_equal 'tester1234', Toolshed::Git::Github.password
+  end
+end

data/test/helper.rb

@@ -0,0 +1,98 @@
+require 'config'
+require 'simplecov'
+
+if (ENV["COVERAGE"])
+  SimpleCov.start do
+    add_filter 'test/'
+  end
+end
+
+require 'test/unit'
+require 'mocha/test_unit'
+require 'faker'
+require 'veto'
+require 'fileutils'
+require 'json'
+
+require 'toolshed'
+
+Test::Unit.at_start do
+  Toolshed::Client.use_git_submodules = false
+  #Toolshed::Client.git_quiet = '&> /dev/null' unless ENV['RUNNING_ON_CI']
+
+  I18n.config.enforce_available_locales = true
+
+  FileUtils.rm_rf(File.join(TEST_ROOT, "remote"))
+  FileUtils.rm_rf(File.join(TEST_ROOT, "local"))
+
+  # setup a fake remote directory so we can reference everything locally
+  if (Dir.exists? (File.join(TEST_ROOT, "remote")))
+    Dir.rmdir(File.join(TEST_ROOT, "remote"))
+  end
+
+  Dir.mkdir(File.join(TEST_ROOT, "remote"), 0777)
+  Dir.chdir(File.join(TEST_ROOT, "remote"))
+
+  # setup a couple of branches acting as the remote repository
+  until system("git init #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  FileUtils.touch('file.txt')
+
+  until system("git add file.txt #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git commit -m 'Add empty file as commit' #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git checkout -b development master #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git checkout master #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  if (Dir.exists? (File.join(TEST_ROOT, "local")))
+    Dir.rmdir(File.join(TEST_ROOT, "local"))
+  end
+
+  Dir.mkdir(File.join(TEST_ROOT, "local"), 0777)
+  Dir.chdir(File.join(TEST_ROOT, "local"))
+
+  # setup the new repository with an empty set this is configured in the config.rb file
+  until system("git init #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git remote add origin #{File.join(TEST_ROOT, "remote")} #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git remote update #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+
+  until system("git checkout -b master origin/master #{Toolshed::Client.git_quiet}")
+    sleep 1
+  end
+end
+
+Test::Unit.at_exit do
+  FileUtils.rm_rf(File.join(TEST_ROOT, "remote"))
+  FileUtils.rm_rf(File.join(TEST_ROOT, "local"))
+end
+
+def capture_stdout(&block)
+  original_stdout = $stdout
+  $stdout = fake = StringIO.new
+  begin
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+  fake.string
+end