rugged 0.18.0.gh.de28323 → 0.19.0

data/test/fixtures/unsymlinked.git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

data/test/fixtures/unsymlinked.git/config

@@ -0,0 +1,6 @@
+[core]
+	bare = true
+	repositoryformatversion = 0
+	filemode = false
+	logallrefupdates = true
+	ignorecase = true

data/test/fixtures/unsymlinked.git/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

data/test/fixtures/unsymlinked.git/info/exclude

@@ -0,0 +1,2 @@
+# File patterns to ignore; see `git help ignore` for more information.
+# Lines that start with '#' are comments.

data/test/fixtures/unsymlinked.git/objects/a8/595ccca04f40818ae0155c8f9c77a230e597b6

@@ -0,0 +1,2 @@
+x
��[
+�0E��*�_��y��݀{�4ShZ))�|�����N[ks=�Kߙ��Ś�[���Q"4&&�M*�i/޴��!��1��S�*��A��Gt)��-'U����m��7O	cc�չ=z�崵;(�PY���+*Dq��^�E!��*�/�0�}Z�?<���P慥���Jp

data/test/fixtures/unsymlinked.git/refs/heads/exe-file

@@ -0,0 +1 @@
+a8595ccca04f40818ae0155c8f9c77a230e597b6

data/test/fixtures/unsymlinked.git/refs/heads/master

@@ -0,0 +1 @@
+7fccd75616ec188b8f1b23d67506a334cc34a49d

data/test/fixtures/unsymlinked.git/refs/heads/reg-file

@@ -0,0 +1 @@
+806999882bf91d24241e4077906b9017605eb1f3

data/test/index_test.rb

@@ -49,6 +49,17 @@ class IndexTest < Rugged::TestCase
     assert_equal 1, @index.count
   end
 
+  def test_remove_dir
+    @index.remove_dir 'does-not-exist'
+    assert_equal 2, @index.count
+
+    @index.remove_dir '', 2
+    assert_equal 2, @index.count
+
+    @index.remove_dir ''
+    assert_equal 0, @index.count
+  end
+
   def test_get_entry_data
     e = @index[0]
     assert_equal 'README', e[:path]
@@ -184,6 +195,18 @@ class IndexWorkdirTest < Rugged::TestCase
   end
 end
 
+class IndexConflictsTest < Rugged::SandboxedTestCase
+  def setup
+    super
+
+    @repo = sandbox_init("mergedrepo")
+  end
+
+  def test_conflicts
+    assert @repo.index.conflicts?
+  end
+end
+
 class IndexRepositoryTest < Rugged::TestCase
   include Rugged::TempRepositoryAccess
 
@@ -211,3 +234,100 @@ class IndexRepositoryTest < Rugged::TestCase
     assert_nil @repo.lookup(new_tree_sha)['second.txt']
   end
 end
+
+class IndexAddAllTest < Rugged::SandboxedTestCase
+  def setup
+    super
+
+    @repo = Rugged::Repository.init_at(File.join(@_sandbox_path, "add-all"))
+
+    Dir.chdir(@repo.workdir) do
+      File.open("file.foo", "w") { |f| f.write "a file" }
+      File.open("file.bar", "w") { |f| f.write "another file" }
+      File.open("file.zzz", "w") { |f| f.write "yet another one" }
+      File.open("other.zzz", "w") { |f| f.write "yet another one" }
+      File.open("more.zzz", "w") { |f| f.write "yet another one" }
+      File.open(".gitignore", "w") { |f| f.write "*.foo\n" }
+    end
+  end
+
+  def test_add_all_lifecycle
+    Dir.chdir(@repo.workdir) do
+      @repo.index.add_all("file.*")
+
+      assert @repo.index["file.bar"]
+      assert @repo.index["file.zzz"]
+      refute @repo.index["file.foo"]
+      refute @repo.index["other.zzz"]
+      refute @repo.index["more.zzz"]
+
+      @repo.index.add_all("*.zzz")
+
+      assert @repo.index["file.bar"]
+      assert @repo.index["file.zzz"]
+      assert @repo.index["other.zzz"]
+      assert @repo.index["more.zzz"]
+      refute @repo.index["file.foo"]
+    end
+  end
+
+  def test_add_all_dry_run
+    Dir.chdir(@repo.workdir) do
+      yielded = []
+      @repo.index.add_all do |path, pathspec|
+        yielded << path
+        false
+      end
+
+      assert_equal [".gitignore", "file.bar", "file.zzz", "more.zzz", "other.zzz"], yielded
+
+      yielded.each do |path|
+        refute @repo.index[path]
+      end
+
+      yielded = []
+      @repo.index.add_all(["file.*", "*.zzz"]) do |path, pathspec|
+        yielded << [path, pathspec]
+        false
+      end
+
+      assert_equal [
+        ["file.bar", "file.*"],
+        ["file.zzz", "file.*"],
+        ["more.zzz", "*.zzz"],
+        ["other.zzz", "*.zzz"]
+      ], yielded
+    end
+  end
+
+  def test_update_all
+    Dir.chdir(@repo.workdir) do
+      @repo.index.add_all("file.*")
+
+      File.open("file.bar", "w") { |f| f.write "new content for file" }
+      @repo.index.update_all("file.*")
+
+      assert @repo.index["file.bar"]
+      assert_equal "new content for file", @repo.lookup(@repo.index["file.bar"][:oid]).content
+
+      refute @repo.index["other.zzz"], "#update_all should only update files in the index"
+      refute @repo.index["more.zzz"], "#update_all should only update files in the index"
+
+      File.unlink("file.bar")
+      @repo.index.update_all
+
+      refute @repo.index["file.bar"], "#update_all should remove index entries that are removed from the workdir"
+    end
+  end
+
+  def test_remove_all
+    Dir.chdir(@repo.workdir) do
+      @repo.index.add_all("file.*")
+      @repo.index.remove_all("*.zzz")
+
+      assert @repo.index["file.bar"]
+      refute @repo.index["file.zzz"]
+    end
+  end
+
+end

data/test/reference_test.rb

@@ -1,23 +1,39 @@
 # encoding: UTF-8
-require File.expand_path "../test_helper", __FILE__
+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(/tags/).map { |r| r.name.gsub("refs/", '') }.sort.join(':')
+    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(':')
+    refs = @repo.refs('*0.9*').map { |r| r.name.gsub("refs/", '') }.sort.join(':')
     assert_equal "tags/v0.9", refs
   end
 
@@ -26,6 +42,18 @@ class ReferenceTest < Rugged::TestCase
     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
@@ -67,6 +95,13 @@ class ReferenceTest < Rugged::TestCase
     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

data/test/remote_test.rb

@@ -1,10 +1,10 @@
 require "test_helper"
 require 'net/http'
 
-class RemoteTest < Rugged::TestCase
+class RemoteNetworkTest < Rugged::TestCase
   include Rugged::RepositoryAccess
 
-  def test_remote_connect
+  def test_remote_network_connect
     begin
       Net::HTTP.new('github.com').head('/')
     rescue SocketError => msg
@@ -19,11 +19,31 @@ class RemoteTest < Rugged::TestCase
 
     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 [ "libgit2" ], remotes.to_a
+    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
@@ -38,6 +58,80 @@ class RemoteTest < Rugged::TestCase
     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
@@ -101,3 +195,130 @@ class RemotePushTest < Rugged::SandboxedTestCase
     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