toolshed 1.0.2 → 1.0.3

data/test/commands/get_daily_time_update_test.rb

@@ -3,16 +3,16 @@ require 'toolshed/commands/get_daily_time_update'
 
 class GetDailyTimeUpdateTest < Test::Unit::TestCase
   def self.startup
-    Toolshed::Client.time_tracking_tool               = 'harvest'
-    Toolshed::Client.time_tracking_default_project_id = '1234'
-    Toolshed::Client.time_tracking_username           = 'sample_username'
-    Toolshed::Client.time_tracking_password           = 'sample1234'
-    Toolshed::Client.time_tracking_owner              = 'me'
+    Toolshed::Client.instance.time_tracking_tool               = 'harvest'
+    Toolshed::Client.instance.time_tracking_default_project_id = '1234'
+    Toolshed::Client.instance.time_tracking_username           = 'sample_username'
+    Toolshed::Client.instance.time_tracking_password           = 'sample1234'
+    Toolshed::Client.instance.time_tracking_owner              = 'me'
   end
 
   def test_get_daily_time_update_with_defaults
     ::Harvest.expects(:client).
-    with(subdomain: Toolshed::Client.time_tracking_owner, username: Toolshed::Client.time_tracking_username, password: Toolshed::Client.time_tracking_password).
+    with(subdomain: Toolshed::Client.instance.time_tracking_owner, username: Toolshed::Client.instance.time_tracking_username, password: Toolshed::Client.instance.time_tracking_password).
     returns('')
 
     harvest_mock = mock('Harvest::TimeEntry')
@@ -33,10 +33,10 @@ class GetDailyTimeUpdateTest < Test::Unit::TestCase
   end
 
   def test_get_daily_time_update_with_use_defaults_on
-    Toolshed::Client.use_defaults                     = true
+    Toolshed::Client.instance.use_defaults                     = true
 
     ::Harvest.expects(:client).
-    with(subdomain: Toolshed::Client.time_tracking_owner, username: Toolshed::Client.time_tracking_username, password: Toolshed::Client.time_tracking_password).
+    with(subdomain: Toolshed::Client.instance.time_tracking_owner, username: Toolshed::Client.instance.time_tracking_username, password: Toolshed::Client.instance.time_tracking_password).
     returns('')
 
     harvest_mock = mock('Harvest::TimeEntry')

data/test/commands/push_branch_test.rb

@@ -2,48 +2,60 @@ require 'commands/commands_helper'
 require 'toolshed/commands/push_branch'
 
 class PushBranchTest < Test::Unit::TestCase
+  def setup
+    Toolshed.expects(:die).at_least(0).returns('Exiting')
+    @branch = Toolshed::Git::Branch.new
+  end
+
   def test_push_branch_current_working_branch
-    Toolshed::Client.push_to_remote_name = 'origin'
+    Toolshed::Client.instance.push_to_remote_name = 'origin'
 
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::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
+    push_branch_command = Toolshed::Commands::PushBranch.new
+    push_branch_command.execute({})
+
+    assert_equal new_branch_name, @branch.name
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     delete_branch(new_branch_name)
   end
 
   def test_push_branch_by_ticket_id
-    Toolshed::Client.push_to_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 = "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
+    push_branch_command = Toolshed::Commands::PushBranch.new
 
-    Toolshed::Git::Base.checkout(current_branch)
+    expected_git = Toolshed::Git::Branch.new(branch_name: '555558')
+    push_branch_command.execute({}, { branch_name: '555558' })
+    assert_equal new_branch_name, expected_git.name
+
+    Toolshed::Git::Branch.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'
+    Toolshed::Client.instance.push_to_remote_name = 'origin'
 
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::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
+    push_branch_command = Toolshed::Commands::PushBranch.new
+    push_branch_command.execute({}, { force: true })
+
+    assert_equal new_branch_name, @branch.name
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     delete_branch(new_branch_name)
   end
 end

data/test/commands/rename_branch_test.rb

@@ -0,0 +1,59 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/rename_branch'
+
+class DeleteBranchTest < Test::Unit::TestCase
+  def setup
+    Toolshed.expects(:die).at_least(0).returns('Exiting')
+    @branch = Toolshed::Git::Branch.new
+  end
+
+  def test_with_options_passed_in
+    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 = @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::Branch.checkout(current_branch)
+
+    rename_branch_command = Toolshed::Commands::RenameBranch.new
+    result = rename_branch_command.execute({}, branch_name: new_branch_name, new_branch_name: 'testing_command')
+    assert_equal 'Exiting', result
+
+    branch_found = `git branch | grep #{new_branch_name}`
+    assert_equal '', branch_found
+  end
+
+  def test_without_passing_in_options
+    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 = @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::Branch.checkout(current_branch)
+
+    rename_branch_command = Toolshed::Commands::RenameBranch.new
+    rename_branch_command.expects(:read_user_input).with('Branch name?', required: true).returns(new_branch_name)
+    rename_branch_command.expects(:read_user_input).with('New Branch name?', required: true).returns('testing_command_no_options')
+    result = rename_branch_command.execute({})
+    assert_equal 'Exiting', result
+
+    branch_found = `git branch | grep #{new_branch_name}`
+    assert_equal '', branch_found
+  end
+end

data/test/git/git_helper.rb

@@ -3,25 +3,25 @@ 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}")
+  until system("git checkout -b #{name} origin/#{branch_from} #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git push origin #{name} #{Toolshed::Client.git_quiet}")
+  until system("git push origin #{name} #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 end
 
 def pop_stash
-  system("git stash pop #{Toolshed::Client.git_quiet}")
+  system("git stash pop #{Toolshed::Client.instance.git_quiet}")
 end
 
 def save_stash
-  system("git stash save #{Toolshed::Client.git_quiet}")
+  system("git stash save #{Toolshed::Client.instance.git_quiet}")
 end
 
 def delete_branch(branch_name)
-  until system("git branch -D #{branch_name} #{Toolshed::Client.git_quiet}")
+  until system("git branch -D #{branch_name} #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 end

data/test/git/git_test.rb

@@ -1,34 +1,39 @@
 require 'git/git_helper'
 
 class GitTest < Test::Unit::TestCase
+  def setup
+    Toolshed.expects(:die).at_least(0).returns('Exiting')
+    @branch = Toolshed::Git::Branch.new
+  end
+
   def test_get_branch_name
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::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
+    assert_equal new_branch_name, Toolshed::Git::Branch.name
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     pop_stash
     delete_branch(new_branch_name)
   end
 
   def test_checkout_branch
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::Branch.name
 
     new_branch_name = random_branch_name
     create_and_checkout_branch(new_branch_name)
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
 
-    assert_equal current_branch, Toolshed::Git::Base.branch_name
+    assert_equal current_branch, Toolshed::Git::Branch.name
 
     delete_branch(new_branch_name)
   end
 
   def test_checkout_branch_by_id
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::Branch.name
 
     branch_id = "124233"
 
@@ -36,78 +41,78 @@ class GitTest < Test::Unit::TestCase
     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::Branch.checkout(current_branch)
+    assert_equal current_branch, Toolshed::Git::Branch.name
 
-    Toolshed::Git::Base.checkout(branch_id)
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
+    Toolshed::Git::Branch.checkout(branch_id)
+    assert_equal new_branch_name, Toolshed::Git::Branch.name
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.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
+    current_branch = Toolshed::Git::Branch.name
+    current_branch_branched_from = Toolshed::Git::Branch.from
 
     new_branch_name = random_branch_name
     create_and_checkout_branch(new_branch_name, 'development')
 
-    assert_equal 'development', Toolshed::Git::Base.branched_from
+    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
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::Branch.name
 
     new_branch_name = random_branch_name
-    git = Toolshed::Git::Base.new({
+    git_branch = Toolshed::Git::Branch.new({
       from_remote_branch_name: 'development',
       to_remote_branch_name: new_branch_name,
       from_remote_name: 'origin',
       to_remote_name: 'origin',
     })
-    git.create_branch
+    git_branch.create
 
-    assert_equal new_branch_name, Toolshed::Git::Base.branch_name
-    assert_equal 'development', Toolshed::Git::Base.branched_from
+    assert_equal new_branch_name, Toolshed::Git::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_branch_from_remote_name_empty
     new_branch_name = random_branch_name
-    git = Toolshed::Git::Base.new({
+    branch = Toolshed::Git::Branch.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 }
+    exception = assert_raise(Veto::InvalidEntity) { branch.create }
     assert_equal 'from_remote_branch_name is not present', exception.message.first
   end
 
   def test_delete_branch
-    current_branch = Toolshed::Git::Base.branch_name
+    current_branch = Toolshed::Git::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 = Toolshed::Git::Branch.name
+    Toolshed::Git::Branch.checkout(new_branch_name)
+    assert_equal new_branch_name, Toolshed::Git::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::Git::Base.delete(new_branch_name)
+    @branch.delete(new_branch_name)
 
     branch_found = `git branch | grep #{new_branch_name}`
     assert_equal '', branch_found

data/test/git/github_test.rb

@@ -1,49 +1,12 @@
 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
+    current_branch = Toolshed::Git::Branch.name
     new_branch_name = '1234_testing'
 
-    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'
     create_and_checkout_branch(new_branch_name)
 
     expected_result = {
@@ -63,29 +26,29 @@ class GitHubTest < 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}:#{Toolshed::Git::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)
 
     assert_equal JSON.parse(expected_result), github.create_pull_request('Sample', 'Sample Body')
 
-    Toolshed::Git::Base.checkout(current_branch)
+    Toolshed::Git::Branch.checkout(current_branch)
     delete_branch(new_branch_name)
   end
 
   def test_get_username
-    Toolshed::Client.github_username = 'tester'
+    Toolshed::Client.instance.github_username = 'tester'
     assert_equal 'tester', Toolshed::Git::Github.username
   end
 
   def test_get_password
-    Toolshed::Client.github_password = 'tester1234'
+    Toolshed::Client.instance.github_password = 'tester1234'
     assert_equal 'tester1234', Toolshed::Git::Github.password
   end
 end

data/test/helper.rb

@@ -20,9 +20,9 @@ require 'json'
 require 'toolshed'
 
 Test::Unit.at_start do
-  Toolshed::Client.use_git_submodules = false
+  Toolshed::Client.instance.use_git_submodules = false
   #Toolshed::Client.git_quiet = '&> /dev/null' unless ENV['RUNNING_ON_CI']
-  Toolshed::Client.git_quiet = ''
+  Toolshed::Client.instance.git_quiet = ''
 
   I18n.config.enforce_available_locales = true
 
@@ -38,25 +38,25 @@ Test::Unit.at_start do
   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}")
+  until system("git init #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
   FileUtils.touch('file.txt')
 
-  until system("git add file.txt #{Toolshed::Client.git_quiet}")
+  until system("git add file.txt #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git commit -m 'Add empty file as commit' #{Toolshed::Client.git_quiet}")
+  until system("git commit -m 'Add empty file as commit' #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git checkout -b development master #{Toolshed::Client.git_quiet}")
+  until system("git checkout -b development master #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git checkout master #{Toolshed::Client.git_quiet}")
+  until system("git checkout master #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
@@ -68,19 +68,19 @@ Test::Unit.at_start do
   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}")
+  until system("git init #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git remote add origin #{File.join(TEST_ROOT, "remote")} #{Toolshed::Client.git_quiet}")
+  until system("git remote add origin #{File.join(TEST_ROOT, "remote")} #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git remote update #{Toolshed::Client.git_quiet}")
+  until system("git remote update #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 
-  until system("git checkout -b master origin/master #{Toolshed::Client.git_quiet}")
+  until system("git checkout -b master origin/master #{Toolshed::Client.instance.git_quiet}")
     sleep 1
   end
 end