rugged 0.19.0 → 0.28.0

data/test/reference_test.rb

@@ -1,207 +0,0 @@
-# encoding: UTF-8
-require "test_helper"
-
-class ReferenceTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  UNICODE_REF_NAME = "A\314\212ngstro\314\210m"
-
-  def test_reference_validity
-    valid = "refs/foobar"
-    invalid = "refs/~nope^*"
-
-    assert Rugged::Reference.valid_name?(valid)
-    assert !Rugged::Reference.valid_name?(invalid)
-  end
-
-  def test_each_can_handle_exceptions
-    assert_raises Exception do
-      Rugged::Reference.each(@repo) do
-        raise Exception.new("fail")
-      end
-    end
-  end
-
-  def test_list_references
-    refs = @repo.refs.map { |r| r.name.gsub("refs/", '') }.sort.join(':')
-    assert_equal "heads/master:heads/packed:notes/commits:tags/v0.9:tags/v1.0", refs
-  end
-
-  def test_can_filter_refs_with_regex
-    refs = @repo.refs('refs/tags/*').map { |r| r.name.gsub("refs/", '') }.sort.join(':')
-    assert_equal "tags/v0.9:tags/v1.0", refs
-  end
-
-  def test_can_filter_refs_with_string
-    refs = @repo.refs('*0.9*').map { |r| r.name.gsub("refs/", '') }.sort.join(':')
-    assert_equal "tags/v0.9", refs
-  end
-
-  def test_can_open_reference
-    ref = Rugged::Reference.lookup(@repo, "refs/heads/master")
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
-    assert_equal :direct, ref.type
-    assert_equal "refs/heads/master", ref.name
-    assert_nil ref.peel
-  end
-
-  def test_can_open_a_symbolic_reference
-    ref = Rugged::Reference.lookup(@repo, "HEAD")
-    assert_equal "refs/heads/master", ref.target
-    assert_equal :symbolic, ref.type
-
-    resolved = ref.resolve
-    assert_equal :direct, resolved.type
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", resolved.target
-    assert_equal resolved.target, ref.peel
-  end
-
-  def test_looking_up_missing_ref_returns_nil
-    ref = Rugged::Reference.lookup(@repo, "lol/wut")
-    assert_equal nil, ref
-  end
-
-  def test_load_reflog
-    ref = Rugged::Reference.lookup(@repo, "refs/heads/master")
-    log = ref.log
-    e =  log[1]
-    assert_equal e[:id_old], "8496071c1b46c854b31185ea97743be6a8774479"
-    assert_equal e[:id_new], "5b5b025afb0b4c913b4c338a42934a3863bf3644"
-    assert_equal e[:message], "commit: another commit"
-    assert_equal e[:committer][:email], "schacon@gmail.com"
-  end
-
-  def test_reference_exists
-    exists = Rugged::Reference.exist?(@repo, "refs/heads/master")
-    assert exists
-
-    exists = Rugged::Reference.exist?(@repo, "lol/wut")
-    assert !exists
-  end
-
-  def test_load_packed_ref
-    ref = Rugged::Reference.lookup(@repo, "refs/heads/packed")
-    assert_equal "41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9", ref.target
-    assert_equal :direct, ref.type
-    assert_equal "refs/heads/packed", ref.name
-  end
-
-  def test_resolve_head
-    ref = Rugged::Reference.lookup(@repo, "HEAD")
-    assert_equal "refs/heads/master", ref.target
-    assert_equal :symbolic, ref.type
-
-    head = ref.resolve
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", head.target
-    assert_equal :direct, head.type
-  end
-
-  def test_reference_to_tag
-    ref = Rugged::Reference.lookup(@repo, "refs/tags/v1.0")
-
-    assert_equal "0c37a5391bbff43c37f0d0371823a5509eed5b1d", ref.target
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", ref.peel
-  end
-end
-
-class ReferenceWriteTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def test_list_unicode_refs
-    Rugged::Reference.create(@repo,
-      "refs/heads/#{ReferenceTest::UNICODE_REF_NAME}",
-      "refs/heads/master")
-
-    refs = @repo.refs.map { |r| r.name.gsub("refs/", '') }
-    assert refs.include? "heads/#{ReferenceTest::UNICODE_REF_NAME}"
-  end
-
-  def test_create_symbolic_ref
-    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "refs/heads/master")
-    assert_equal "refs/heads/master", ref.target
-    assert_equal :symbolic, ref.type
-    assert_equal "refs/heads/unit_test", ref.name
-    ref.delete!
-  end
-
-  def test_create_ref_from_oid
-    ref = Rugged::Reference.create(@repo,
-      "refs/heads/unit_test",
-      "36060c58702ed4c2a40832c51758d5344201d89a")
-
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
-    assert_equal :direct, ref.type
-    assert_equal "refs/heads/unit_test", ref.name
-    ref.delete!
-  end
-
-  def test_rename_ref
-    ref = Rugged::Reference.create(@repo,
-      "refs/heads/unit_test",
-      "36060c58702ed4c2a40832c51758d5344201d89a")
-
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
-    assert_equal :direct, ref.type
-    assert_equal "refs/heads/unit_test", ref.name
-
-    new_ref = ref.rename "refs/heads/rug_new_name"
-    assert_equal "refs/heads/rug_new_name", new_ref.name
-    new_ref.delete!
-  end
-
-  def test_set_ref_target
-    ref = Rugged::Reference.create(@repo,
-      "refs/heads/unit_test",
-      "36060c58702ed4c2a40832c51758d5344201d89a")
-
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
-    assert_equal :direct, ref.type
-    assert_equal "refs/heads/unit_test", ref.name
-
-    new_ref = ref.set_target "5b5b025afb0b4c913b4c338a42934a3863bf3644"
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", new_ref.target
-    new_ref.delete!
-  end
-
-  def test_write_and_read_unicode_refs
-    ref1 = Rugged::Reference.create(@repo, "refs/heads/Ångström", "refs/heads/master")
-    ref2 = Rugged::Reference.create(@repo, "refs/heads/foobar", "refs/heads/Ångström")
-
-    assert_equal "refs/heads/Ångström", ref1.name
-    assert_equal "refs/heads/Ångström", ref2.target
-  end
-end
-
-class ReflogTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def setup
-    super
-    @ref = Rugged::Reference.create(@repo,
-      "refs/heads/test-reflog",
-      "36060c58702ed4c2a40832c51758d5344201d89a")
-  end
-
-  def test_create_reflog_entries
-    @ref.log!({ :name => "foo", :email => "foo@bar", :time => Time.now })
-    @ref.log!({ :name => "foo", :email => "foo@bar", :time => Time.now }, "commit: bla bla")
-
-    reflog = @ref.log
-    assert_equal reflog.size, 2
-
-    assert_equal reflog[0][:id_old], "0000000000000000000000000000000000000000"
-    assert_equal reflog[0][:id_new], "36060c58702ed4c2a40832c51758d5344201d89a"
-    assert_equal reflog[0][:message], nil
-    assert_equal reflog[0][:committer][:name], "foo"
-    assert_equal reflog[0][:committer][:email], "foo@bar"
-    assert_kind_of Time, reflog[0][:committer][:time]
-
-    assert_equal reflog[1][:id_old], "36060c58702ed4c2a40832c51758d5344201d89a"
-    assert_equal reflog[1][:id_new], "36060c58702ed4c2a40832c51758d5344201d89a"
-    assert_equal reflog[1][:message], "commit: bla bla"
-    assert_equal reflog[1][:committer][:name], "foo"
-    assert_equal reflog[1][:committer][:email], "foo@bar"
-    assert_kind_of Time, reflog[1][:committer][:time]
-  end
-end
-

data/test/remote_test.rb

@@ -1,324 +0,0 @@
-require "test_helper"
-require 'net/http'
-
-class RemoteNetworkTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  def test_remote_network_connect
-    begin
-      Net::HTTP.new('github.com').head('/')
-    rescue SocketError => msg
-      skip "github is not reachable: #{msg}"
-    end
-
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-
-    remote.connect(:fetch) do |r|
-      assert r.connected?
-    end
-
-    assert !remote.connected?
-  end
-end
-
-class RemoteTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  class TestException < StandardError
-  end
-
-  def test_list_remote_names
-    remote_names = Rugged::Remote.names(@repo)
-    assert_equal [ "test_remote", "libgit2" ], remote_names
-  end
-
-  def test_list_remotes
-    remotes = @repo.remotes
-    assert remotes.kind_of? Enumerable
-    assert_equal [ "test_remote", "libgit2" ], remotes.map(&:name)
-  end
-
-  def test_remotes_each_protect
-    assert_raises TestException do
-      @repo.remotes.each do |remote|
-        raise TestException
-      end
-    end
-  end
-
-  def test_remote_new_name
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-    assert_nil remote.name
-    assert_equal 'git://github.com/libgit2/libgit2.git', remote.url
-  end
-
-  def test_remote_new_invalid_url
-    assert_raises ArgumentError do
-      Rugged::Remote.new(@repo, 'libgit2')
-    end
-  end
-
-  def test_url_set
-    new_url = 'git://github.com/libgit2/TestGitRepository.git'
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-    remote.url = new_url
-    assert_equal new_url, remote.url
-  end
-
-  def test_url_set_invalid
-    url = 'upstream'
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-    assert_raises ArgumentError do
-      remote.url = url
-    end
-  end
-
-  def test_push_url
-    assert_equal 'git://github.com/libgit2/TestEmptyRepository.git',
-      Rugged::Remote.lookup(@repo, 'test_remote').push_url
-
-    assert_nil Rugged::Remote.lookup(@repo, 'libgit2').push_url
-  end
-
-  def test_push_url_set
-    new_url = 'git://github.com/libgit2/TestGitRepository.git'
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-
-    assert_nil remote.push_url
-    remote.push_url = new_url
-    assert_equal new_url, remote.push_url
-  end
-
-  def test_push_url_set_invalid
-    new_url = 'upstream'
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-    assert_raises ArgumentError do
-      remote.push_url = new_url
-    end
-  end
-
-  def test_fetch_refspecs
-    remote = Rugged::Remote.lookup(@repo, 'test_remote')
-    assert_equal ['+refs/heads/*:refs/remotes/test_remote/*'], remote.fetch_refspecs
-
-    assert_empty Rugged::Remote.lookup(@repo, 'libgit2').fetch_refspecs
-  end
-
-  def test_push_refspecs
-    remote = Rugged::Remote.lookup(@repo, 'test_remote')
-    assert_equal ['refs/heads/*:refs/heads/testing/*'], remote.push_refspecs
-
-    assert_empty Rugged::Remote.lookup(@repo, 'libgit2').push_refspecs
-  end
-
-  def test_add_fetch
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-    assert_nil remote.add_fetch('+refs/heads/*:refs/remotes/test/*')
-    assert_equal ['+refs/heads/*:refs/remotes/test/*'], remote.fetch_refspecs
-  end
-
-  def test_add_push
-    remote = Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git')
-    assert_nil remote.add_push('refs/heads/*:refs/heads/test/*')
-    assert_equal ['refs/heads/*:refs/heads/test/*'], remote.push_refspecs
-  end
-
-  def test_clear_refspecs
-    remote = Rugged::Remote.lookup(@repo, 'test_remote')
-
-    remote.clear_refspecs
-
-    assert_empty remote.push_refspecs
-    assert_empty remote.fetch_refspecs
-  end
-
-  def test_remote_lookup
-    remote = Rugged::Remote.lookup(@repo, 'libgit2')
-    assert_equal 'git://github.com/libgit2/libgit2.git', remote.url
-    assert_equal 'libgit2', remote.name
-  end
-
-  def test_remote_lookup_missing
-    assert_nil Rugged::Remote.lookup(@repo, 'missing_remote')
-  end
-
-  def test_remote_lookup_invalid
-    assert_raises Rugged::ConfigError do
-      Rugged::Remote.lookup(@repo, "*\?")
-    end
-  end
-end
-
-class RemotePushTest < Rugged::SandboxedTestCase
-  def setup
-    super
-    @remote_repo = sandbox_init("testrepo.git")
-    # We can only push to bare repos
-    @remote_repo.config['core.bare'] = 'true'
-
-    @repo = sandbox_clone("testrepo.git", "testrepo")
-    Rugged::Reference.create(@repo,
-      "refs/heads/unit_test",
-      "8496071c1b46c854b31185ea97743be6a8774479")
-
-    @remote = Rugged::Remote.lookup(@repo, 'origin')
-  end
-
-  def test_push_single_ref
-    result = @remote.push(["refs/heads/master", "refs/heads/master:refs/heads/foobar", "refs/heads/unit_test"])
-    assert_equal({}, result)
-
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", @remote_repo.ref("refs/heads/foobar").target
-    assert_equal "8496071c1b46c854b31185ea97743be6a8774479", @remote_repo.ref("refs/heads/unit_test").target
-  end
-
-  def test_push_to_non_bare_raise_error
-    @remote_repo.config['core.bare'] = 'false'
-
-    assert_raises Rugged::Error do
-      @remote.push(["refs/heads/master"])
-    end
-  end
-
-  def test_push_non_forward_raise_error
-    assert_raises Rugged::Error do
-      @remote.push(["refs/heads/unit_test:refs/heads/master"])
-    end
-
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", @remote_repo.ref("refs/heads/master").target
-  end
-
-  def test_push_non_forward_forced_raise_no_error
-    result = @remote.push(["+refs/heads/unit_test:refs/heads/master"])
-    assert_equal({}, result)
-
-    assert_equal "8496071c1b46c854b31185ea97743be6a8774479", @remote_repo.ref("refs/heads/master").target
-  end
-end
-
-class RemoteWriteTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def test_remote_add
-    Rugged::Remote.add(@repo, 'upstream', 'git://github.com/libgit2/libgit2.git')
-    remote = Rugged::Remote.lookup(@repo, 'upstream')
-    assert_equal 'upstream', remote.name
-    assert_equal 'git://github.com/libgit2/libgit2.git', remote.url
-  end
-
-  def test_remote_add_with_invalid_url
-    assert_raises ArgumentError do
-      Rugged::Remote.add(@repo, 'upstream', 'libgit2')
-    end
-  end
-
-  def test_url_set
-    new_url = 'git://github.com/l?#!@#$ibgit2/TestGitRepository.git'
-    remote = Rugged::Remote.lookup(@repo, 'origin')
-    remote.url = new_url
-    assert remote.save
-    assert_equal new_url, Rugged::Remote.lookup(@repo, 'origin').url
-  end
-
-  def test_rename
-    remote = Rugged::Remote.lookup(@repo, 'origin')
-    assert_nil remote.rename!('new_remote_name')
-    assert Rugged::Remote.lookup(@repo, 'new_remote_name')
-  end
-
-  def test_rename_invalid_name
-    remote = Rugged::Remote.lookup(@repo, 'origin')
-    assert_raises Rugged::ConfigError do
-      remote.rename!('/?')
-    end
-  end
-
-  def test_rename_exists
-    remote = Rugged::Remote.lookup(@repo, 'origin')
-    assert_raises Rugged::ConfigError do
-      remote.rename!('origin')
-    end
-  end
-
-  def test_rename_error_callback
-    @repo.config['remote.origin.fetch']  = '+refs/*:refs/*'
-    remote = Rugged::Remote.lookup(@repo, 'origin')
-    assert_equal ["+refs/*:refs/*"], remote.rename!('test_remote')
-  end
-end
-
-class RemoteTransportTest < Rugged::TestCase
-  class TestException < StandardError
-  end
-
-  def setup
-    @path = Dir.mktmpdir 'dir'
-    @repo = Rugged::Repository.init_at(@path, false)
-    repo_dir = File.join(TEST_DIR, (File.join('fixtures', 'testrepo.git', '.')))
-    @remote = Rugged::Remote.add(@repo, 'origin', "file://#{repo_dir}")
-  end
-
-  def teardown
-    FileUtils.remove_entry_secure(@path)
-  end
-
-  def test_remote_disconnect
-    @remote.connect(:fetch)
-    assert @remote.connected?
-
-    @remote.disconnect
-    refute @remote.connected?
-  end
-
-  def test_remote_ls
-    @remote.connect(:fetch) do |r|
-      assert r.ls.kind_of? Enumerable
-      rheads = r.ls.to_a
-
-      assert_equal 7, rheads.count
-
-      rhead = rheads.first
-      assert_equal false, rhead[:local?]
-      assert rhead[:oid]
-      assert_nil rhead[:loid]
-    end
-  end
-
-  def test_update_tips_callback
-    @remote.connect(:fetch) do |r|
-      r.download
-      r.update_tips! do |ref, source, destination|
-        assert Rugged::Reference.lookup(@repo, ref)
-        assert_nil source
-        assert destination
-      end
-    end
-  end
-
-  # this is not as useless as it seems
-  # LocalJumpError is raised in the second call to
-  # update_tips! if libgit2 callback is not cleared
-  # Also the exception is explicitly raised after the
-  # callback is cleared
-  def test_update_tips_cleanup_callbacks
-    @remote.connect(:fetch) do |r|
-      r.download
-      assert_raises TestException do
-        r.update_tips! do
-          raise TestException
-        end
-      end
-      r.update_tips!
-    end
-  end
-
-  def test_remote_fetch
-    @remote.connect(:fetch) do |r|
-      r.download
-      r.update_tips!
-    end
-
-    assert_equal '36060c58702ed4c2a40832c51758d5344201d89a', @repo.rev_parse('origin/master').oid
-    assert @repo.lookup('36060c5')
-  end
-end

data/test/repo_pack_test.rb

@@ -1,24 +0,0 @@
-require "test_helper"
-require 'base64'
-
-class PackfileTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  def test_packfile_object_exists
-    assert @repo.exists?("41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9")
-    assert @repo.exists?("f82a8eb4cb20e88d1030fd10d89286215a715396")
-  end
-
-  def test_read_packed_object
-    rawobj = @repo.read("41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9")
-    assert_match 'tree f82a8eb4cb20e88d1030fd10d89286215a715396', rawobj.data
-    assert_equal 230, rawobj.len
-    assert_equal :commit, rawobj.type
-  end
-
-  def test_read_packed_header
-    hash = @repo.read_header("41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9")
-    assert_equal 230, hash[:len]
-    assert_equal :commit, hash[:type]
-  end
-end

data/test/repo_reset_test.rb

@@ -1,82 +0,0 @@
-require "test_helper"
-
-class RepositoryResetTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def repo_file_path; File.join('subdir', 'README') end
-  def file_path;      File.join(@path, 'subdir', 'README') end
-
-  def test_reset_with_rugged_tag
-    tag = @repo.lookup('0c37a5391bbff43c37f0d0371823a5509eed5b1d')
-    @repo.reset(tag, :soft)
-    assert_equal tag.target.oid , @repo.head.target
-  end
-
-  def test_reset_with_invalid_mode
-    assert_raises ArgumentError do
-      @repo.reset('441034f860c1d5d90e4188d11ae0d325176869a8', :tender)
-    end
-  end
-
-  def test_reset_soft
-    original_content = File.open(file_path) { |f| f.read }
-
-    @repo.reset('441034f860c1d5d90e4188d11ae0d325176869a8', :soft)
-    assert_equal '441034f860c1d5d90e4188d11ae0d325176869a8', @repo.head.target
-    assert_equal [:index_modified], @repo.status(repo_file_path)
-
-    new_content = File.open(file_path) { |f| f.read }
-
-    assert_equal original_content, new_content
-  end
-
-  def test_reset_mixed
-    original_content = File.open(file_path) { |f| f.read }
-
-    @repo.reset('441034f860c1d5d90e4188d11ae0d325176869a8', :mixed)
-    assert_equal [:worktree_modified], @repo.status(repo_file_path)
-
-    new_content = File.open(file_path) { |f| f.read }
-
-    assert_equal original_content, new_content
-  end
-
-  def test_reset_hard
-    original_content = File.open(file_path) { |f| f.read }
-
-    @repo.reset('441034f860c1d5d90e4188d11ae0d325176869a8', :hard)
-    assert_empty @repo.status(repo_file_path)
-
-    new_content = File.open(file_path) { |f| f.read }
-
-    refute_equal original_content, new_content
-  end
-
-  def test_reset_path
-    File.open(file_path, 'w') do |f|
-      f.puts "test content"
-    end
-    @repo.index.add(repo_file_path)
-    @repo.index.write
-
-    @repo.reset_path(repo_file_path, '441034f860c1d5d90e4188d11ae0d325176869a8')
-    assert_equal [:index_modified, :worktree_modified], @repo.status(repo_file_path)
-  end
-
-  def test_reset_path_no_target
-    File.open(file_path, 'w') do |f|
-      f.puts "test content"
-    end
-    @repo.index.add(repo_file_path)
-    @repo.index.write
-
-    @repo.reset_path(repo_file_path)
-    assert_equal [:index_deleted, :worktree_new], @repo.status(repo_file_path)
-  end
-
-  def test_reset_path_invalid_pathspec
-    assert_raises TypeError do
-      @repo.reset_path([:invalid_reset_path], '441034f860c1d5d90e4188d11ae0d325176869a8')
-    end
-  end
-end