grit 1.1.1 → 2.0.0

data/test/test_diff.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestDiff < Test::Unit::TestCase
+  def setup
+    @r = Repo.new(GRIT_REPO)
+  end
+
+  # list_from_string
+
+  def test_list_from_string_new_mode
+    output = fixture('diff_new_mode')
+
+    diffs = Grit::Diff.list_from_string(@r, output)
+    assert_equal 2, diffs.size
+    assert_equal 10, diffs.first.diff.split("\n").size
+    assert_equal nil, diffs.last.diff
+  end
+end

data/test/test_file_index.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestFileIndex < Test::Unit::TestCase
+
+  def setup_a
+    @findex = Grit::GitRuby::FileIndex.new(File.join(File.dirname(__FILE__), *%w[dot_git]))
+    @commit = 'c12f398c2f3c4068ca5e01d736b1c9ae994b2138'
+  end
+
+  def test_count_all
+    setup_a
+    assert_equal 107, @findex.count_all
+  end
+
+  def test_count
+    setup_a
+    assert_equal 20, @findex.count(@commit)
+  end
+
+  def test_files
+    setup_a
+    files = @findex.files(@commit)
+    assert_equal 4, files.size
+    assert_equal "lib/grit/blob.rb", files.first
+  end
+
+  def test_commits_for
+    setup_a
+    commits = @findex.commits_for('lib/grit/blob.rb')
+    assert commits.include?('3e0955045cb189a7112015c26132152a94f637bf')
+    assert_equal 8, commits.size
+  end
+
+  def test_last_commits_array
+    setup_a
+    arr = @findex.last_commits(@commit, ['lib/grit/git.rb', 'lib/grit/actor.rb', 'lib/grit/commit.rb'])
+    assert_equal '74fd66519e983a0f29e16a342a6059dbffe36020', arr['lib/grit/git.rb']
+    assert_equal @commit, arr['lib/grit/commit.rb']
+    assert_equal nil, arr['lib/grit/actor.rb']
+  end
+
+  def test_last_commits_pattern
+    setup_a
+    arr = @findex.last_commits(@commit, /lib\/grit\/[^\/]*$/)
+    assert_equal 10, arr.size
+    assert_equal @commit, arr['lib/grit/commit.rb']
+    assert_equal nil, arr['lib/grit/actor.rb']
+  end
+
+  def test_last_commits_array
+    setup_a
+    arr = @findex.last_commits(@commit, ['lib/grit.rb', 'lib/grit/'])
+    assert_equal @commit, arr['lib/grit/']
+  end
+
+end

data/test/test_git.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestGit < Test::Unit::TestCase
+  def setup
+    @git = Git.new(File.join(File.dirname(__FILE__), *%w[..]))
+  end
+
+  def teardown
+    Grit.debug = false
+  end
+
+  def test_method_missing
+    assert_match(/^git version [\w\.]*$/, @git.version)
+  end
+
+  def test_logs_stderr
+    Grit.debug = true
+    Grit.stubs(:log)
+    Grit.expects(:log).with(includes("git: 'bad' is not a git-command"))
+    @git.bad
+  end
+
+  def testl_logs_stderr_when_skipping_timeout
+    Grit.debug = true
+    Grit.stubs(:log)
+    Grit.expects(:log).with(includes("git: 'bad' is not a git-command"))
+    @git.bad :timeout => false
+  end
+
+  def test_transform_options
+    assert_equal ["-s"], @git.transform_options({:s => true})
+    assert_equal [], @git.transform_options({:s => false})
+    assert_equal ["-s '5'"], @git.transform_options({:s => 5})
+
+    assert_equal ["--max-count"], @git.transform_options({:max_count => true})
+    assert_equal ["--max-count='5'"], @git.transform_options({:max_count => 5})
+
+    assert_equal ["-s", "-t"], @git.transform_options({:s => true, :t => true}).sort
+  end
+
+  def test_uses_custom_sh_method
+    @git.expects(:sh)
+    @git.something
+  end
+
+  def test_can_skip_timeout
+    @git.expects(:wild_sh)
+    @git.something(:timeout => false)
+  end
+
+  def test_raises_if_too_many_bytes
+    @git.instance_variable_set(:@bytes_read, 6000000)
+    assert_raises Grit::Git::GitTimeout do
+      @git.version
+    end
+  end
+
+  def test_raises_on_slow_shell
+    Grit::Git.git_timeout = 0.0000001
+    assert_raises Grit::Git::GitTimeout do
+      @git.version
+    end
+    Grit::Git.git_timeout = 5.0
+  end
+
+  def test_it_really_shell_escapes_arguments_to_the_git_shell
+    @git.expects(:sh).with("#{Git.git_binary} --git-dir='#{@git.git_dir}' foo --bar='bazz\\'er'")
+    @git.foo(:bar => "bazz'er")
+    @git.expects(:sh).with("#{Git.git_binary} --git-dir='#{@git.git_dir}' bar -x 'quu\\'x'")
+    @git.bar(:x => "quu'x")
+  end
+
+  def test_it_shell_escapes_the_standalone_argument
+    @git.expects(:sh).with("#{Git.git_binary} --git-dir='#{@git.git_dir}' foo 'bar\\'s'")
+    @git.foo({}, "bar's")
+
+    @git.expects(:sh).with("#{Git.git_binary} --git-dir='#{@git.git_dir}' foo 'bar' '\\; echo \\'noooo\\''")
+    @git.foo({}, "bar", "; echo 'noooo'")
+  end
+
+  def test_piping_should_work_on_1_9
+    @git.expects(:sh).with("#{Git.git_binary} --git-dir='#{@git.git_dir}' archive 'master' | gzip")
+    @git.archive({}, "master", "| gzip")
+  end
+
+  def test_fs_read
+    f = stub
+    f.expects(:read).returns('bar')
+    File.expects(:open).with(File.join(@git.git_dir, 'foo')).returns(f)
+    assert_equal 'bar', @git.fs_read('foo')
+  end
+
+  def test_fs_write
+    f = stub
+    f.expects(:write).with('baz')
+    FileUtils.expects(:mkdir_p).with(File.join(@git.git_dir, 'foo'))
+    File.expects(:open).with(File.join(@git.git_dir, 'foo/bar'), 'w').yields(f)
+    @git.fs_write('foo/bar', 'baz')
+  end
+
+  def test_fs_delete
+    FileUtils.expects(:rm_rf).with(File.join(@git.git_dir, 'foo'))
+    @git.fs_delete('foo')
+  end
+end

data/test/test_grit.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestGrit < Test::Unit::TestCase
+  def setup
+    @old_debug  = Grit.debug
+    @old_logger = Grit.logger
+    Grit.debug  = true
+  end
+
+  def teardown
+    Grit.debug  = @old_debug
+    Grit.logger = @old_logger
+  end
+
+  def test_uses_stdout_logger_by_default
+    assert_equal STDOUT, Grit.logger.instance_variable_get(:@logdev).dev
+  end
+
+  def test_can_override_logger
+    my_logger = Logger.new(io = StringIO.new)
+    Grit.logger = my_logger
+    assert_equal my_logger, Grit.logger
+  end
+
+  def test_logs_to_specified_logger
+    Grit.logger = Logger.new(io = StringIO.new)
+    Grit.log 'hi mom'
+    io.rewind
+    assert io.read.include?('hi mom')
+  end
+
+end

data/test/test_head.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestHead < Test::Unit::TestCase
+  def setup
+    @r = Repo.new(File.join(File.dirname(__FILE__), *%w[dot_git]), :is_bare => true)
+  end
+
+  # inspect
+
+  def test_inspect
+    head = @r.heads[1]
+    assert_equal %Q{#<Grit::Head "test/master">}, head.inspect
+  end
+
+  def test_master
+    head = @r.commit('master')
+    assert_equal 'ca8a30f5a7f0f163bbe3b6f0abf18a6c83b0687a', head.id
+  end
+
+  def test_submaster
+    head = @r.commit('test/master')
+    assert_equal '2d3acf90f35989df8f262dc50beadc4ee3ae1560', head.id
+  end
+
+  # heads with slashes
+
+  def test_heads_with_slashes
+    head = @r.heads[3]
+    assert_equal %Q{#<Grit::Head "test/chacon">}, head.inspect
+  end
+
+  def test_is_head
+    assert @r.is_head?('master')
+    assert @r.is_head?('test/chacon')
+    assert !@r.is_head?('masterblah')
+  end
+
+  def test_head_count
+    assert_equal 5, @r.heads.size
+  end
+
+
+  def test_nonpack
+    assert @r.heads.map { |h| h.name }.include?('nonpack')
+  end
+
+end

data/test/test_index_status.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestIndexStatus < Test::Unit::TestCase
+  def setup
+    @r = Repo.new(GRIT_REPO)
+  end
+
+  def test_add
+    Git.any_instance.expects(:add).with({}, 'file1', 'file2')
+    @r.add('file1', 'file2')
+  end
+
+  def test_add_array
+    Git.any_instance.expects(:add).with({}, 'file1', 'file2')
+    @r.add(['file1', 'file2'])
+  end
+
+  def test_remove
+    Git.any_instance.expects(:rm).with({}, 'file1', 'file2')
+    @r.remove('file1', 'file2')
+  end
+
+  def test_remove_array
+    Git.any_instance.expects(:rm).with({}, 'file1', 'file2')
+    @r.remove(['file1', 'file2'])
+  end
+
+  def test_status
+    Git.any_instance.expects(:diff_index).with({}, 'HEAD').returns(fixture('diff_index'))
+    Git.any_instance.expects(:diff_files).returns(fixture('diff_files'))
+    Git.any_instance.expects(:ls_files).with({:stage => true}).returns(fixture('ls_files'))
+    status = @r.status
+    stat = status['lib/grit/repo.rb']
+    assert_equal stat.sha_repo, "71e930d551c413a123f43e35c632ea6ba3e3705e"
+    assert_equal stat.mode_repo, "100644"
+    assert_equal stat.type, "M"
+  end
+
+
+end

data/test/test_merge.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/helper'
+require 'pp'
+
+class TestMerge < Test::Unit::TestCase
+
+  def setup
+    @r = Repo.new(File.join(File.dirname(__FILE__), *%w[dot_git]), :is_bare => true)
+    @merge = fixture('merge_result')
+  end
+
+  def test_from_string
+    m = Grit::Merge.new(@merge)
+    assert_equal m.sections, 3
+    assert_equal m.conflicts, 1
+  end
+
+end

data/test/test_raw.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/helper'
+require 'pp'
+
+class TestFileIndex < Test::Unit::TestCase
+
+  def setup
+    @r = Grit::Repo.new(File.join(File.dirname(__FILE__), *%w[dot_git]), :is_bare => true)
+    @tag = 'f0055fda16c18fd8b27986dbf038c735b82198d7'
+  end
+
+  def test_raw_tag
+    tag = @r.git.ruby_git.get_object_by_sha1(@tag)
+    assert_match Regexp.new('v0.7.0'),  tag.raw_content
+  end
+
+end

data/test/test_real.rb

@@ -0,0 +1,19 @@
+# require File.dirname(__FILE__) + '/helper'
+#
+# class TestReal < Test::Unit::TestCase
+#   def setup
+#     `rm -fr /Users/tom/dev/sandbox/grittest.git`
+#     `git --git-dir=/Users/tom/dev/sandbox/grittest.git init`
+#     @repo = Repo.new('/Users/tom/dev/sandbox/grittest.git')
+#   end
+#
+#   def test_real
+#     Grit.debug = true
+#
+#     index = @repo.index
+#     index.add('foo/bar/baz.txt', 'hello!')
+#     index.add('foo/qux/bam.txt', 'world!')
+#
+#     puts index.commit('first commit')
+#   end
+# end

data/test/test_reality.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/helper'
+
+# class TestTreeRecursion < Test::Unit::TestCase
+#   def test_
+#     r = Repo.new("/Users/tom/dev/god")
+#     t = r.tree("HEAD")
+#
+#     recurse(t)
+#   end
+#
+#   def recurse(tree, indent = "")
+#     tree.contents.each do |c|
+#       # puts "#{indent}#{c.name} (#{c.id})"
+#       recurse(c, indent + "  ") if c.kind_of?(Tree)
+#     end
+#   end
+# end

data/test/test_remote.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestRemote < Test::Unit::TestCase
+  def setup
+    @r = Repo.new(GRIT_REPO)
+  end
+
+  # inspect
+
+  def test_inspect
+    remote = @r.remotes.first
+    assert_equal %Q{#<Grit::Remote "#{remote.name}">}, remote.inspect
+  end
+end

data/test/test_repo.rb

@@ -0,0 +1,349 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestRepo < Test::Unit::TestCase
+  def setup
+    @r = Repo.new(GRIT_REPO)
+  end
+
+  def create_temp_repo(clone_path)
+    filename = 'git_test' + Time.now.to_i.to_s + rand(300).to_s.rjust(3, '0')
+    tmp_path = File.join("/tmp/", filename)
+    FileUtils.mkdir_p(tmp_path)
+    FileUtils.cp_r(clone_path, tmp_path)
+    File.join(tmp_path, 'dot_git')
+  end
+
+  def test_update_refs_packed
+    gpath = create_temp_repo(File.join(File.dirname(__FILE__), *%w[dot_git]))
+    @git = Grit::Repo.new(gpath, :is_bare => true)
+
+    # new and existing
+    test   = 'ac9a30f5a7f0f163bbe3b6f0abf18a6c83b06872'
+    master = 'ca8a30f5a7f0f163bbe3b6f0abf18a6c83b0687a'
+
+    @git.update_ref('testref', test)
+    new_t = @git.get_head('testref').commit.sha
+    assert new_t != master
+
+    @git.update_ref('master', test)
+    new_m = @git.get_head('master').commit.sha
+    assert new_m != master
+
+    old = @git.get_head('nonpack').commit.sha
+    @git.update_ref('nonpack', test)
+    newp = @git.get_head('nonpack').commit.sha
+    assert newp != old
+
+    FileUtils.rm_r(gpath)
+  end
+
+  # new
+
+  def test_new_should_raise_on_invalid_repo_location
+    assert_raise(InvalidGitRepositoryError) do
+      Repo.new("/tmp")
+    end
+  end
+
+  def test_new_should_raise_on_non_existant_path
+    assert_raise(NoSuchPathError) do
+      Repo.new("/foobar")
+    end
+  end
+
+  # descriptions
+
+  def test_description
+    assert_equal "Unnamed repository; edit this file to name it for gitweb.", @r.description
+  end
+
+  # refs
+
+  def test_refs_should_return_array_of_ref_objects
+    @r.refs.each do |ref|
+      assert ref.is_a?(Grit::Ref)
+    end
+  end
+
+  # heads
+
+  def test_current_head
+    @r = Repo.new(File.join(File.dirname(__FILE__), *%w[dot_git]), :is_bare => true)
+    head = @r.head
+    assert_equal Grit::Head, head.class
+    assert_equal 'master', head.name
+    assert_equal 'ca8a30f5a7f0f163bbe3b6f0abf18a6c83b0687a', @r.commits(head.name).first.id
+  end
+
+  def test_heads_should_return_array_of_head_objects
+    @r.heads.each do |head|
+      assert_equal Grit::Head, head.class
+    end
+  end
+
+  def test_heads_should_populate_head_data
+    @r = Repo.new(File.join(File.dirname(__FILE__), *%w[dot_git]), :is_bare => true)
+    head = @r.heads[1]
+
+    assert_equal 'test/master', head.name
+    assert_equal '2d3acf90f35989df8f262dc50beadc4ee3ae1560', head.commit.id
+  end
+
+  # branches
+
+  def test_branches
+    # same as heads
+  end
+
+  # commits
+
+  def test_commits
+    Git.any_instance.expects(:rev_list).returns(fixture('rev_list'))
+
+    commits = @r.commits('master', 10)
+
+    c = commits[0]
+    assert_equal '4c8124ffcf4039d292442eeccabdeca5af5c5017', c.id
+    assert_equal ["634396b2f541a9f2d58b00be1a07f0c358b999b3"], c.parents.map { |p| p.id }
+    assert_equal "672eca9b7f9e09c22dcb128c283e8c3c8d7697a4", c.tree.id
+    assert_equal "Tom Preston-Werner", c.author.name
+    assert_equal "tom@mojombo.com", c.author.email
+    assert_equal Time.at(1191999972), c.authored_date
+    assert_equal "Tom Preston-Werner", c.committer.name
+    assert_equal "tom@mojombo.com", c.committer.email
+    assert_equal Time.at(1191999972), c.committed_date
+    assert_equal "implement Grit#heads", c.message
+
+    c = commits[1]
+    assert_equal [], c.parents
+
+    c = commits[2]
+    assert_equal ["6e64c55896aabb9a7d8e9f8f296f426d21a78c2c", "7f874954efb9ba35210445be456c74e037ba6af2"], c.parents.map { |p| p.id }
+    assert_equal "Merge branch 'site'\n\n  * Some other stuff\n  * just one more", c.message
+    assert_equal "Merge branch 'site'", c.short_message
+  end
+
+  # commit_count
+
+  def test_commit_count
+    Git.any_instance.expects(:rev_list).with({}, 'master').returns(fixture('rev_list_count'))
+
+    assert_equal 655, @r.commit_count('master')
+  end
+
+  # commit
+
+  def test_commit
+    commit = @r.commit('634396b2f541a9f2d58b00be1a07f0c358b999b3')
+
+    assert_equal "634396b2f541a9f2d58b00be1a07f0c358b999b3", commit.id
+  end
+
+  # tree
+
+  def test_tree
+    Git.any_instance.expects(:ls_tree).returns(fixture('ls_tree_a'))
+    tree = @r.tree('master')
+
+    assert_equal 4, tree.contents.select { |c| c.instance_of?(Blob) }.size
+    assert_equal 3, tree.contents.select { |c| c.instance_of?(Tree) }.size
+  end
+
+  # blob
+
+  def test_blob
+    Git.any_instance.expects(:cat_file).returns(fixture('cat_file_blob'))
+    blob = @r.blob("abc")
+    assert_equal "Hello world", blob.data
+  end
+
+  # init_bare
+
+  def test_init_bare
+    Git.any_instance.expects(:init).returns(true)
+    Repo.expects(:new).with("/foo/bar.git", {})
+    Repo.init_bare("/foo/bar.git")
+  end
+
+  def test_init_bare_with_options
+    Git.any_instance.expects(:init).with(
+      :bare => true, :template => "/baz/sweet").returns(true)
+    Repo.expects(:new).with("/foo/bar.git", {})
+    Repo.init_bare("/foo/bar.git", :template => "/baz/sweet")
+  end
+
+  # fork_bare
+
+  def test_fork_bare
+    Git.any_instance.expects(:clone).with(
+      {:bare => true, :shared => true},
+      "#{absolute_project_path}/.git",
+      "/foo/bar.git").returns(nil)
+    Repo.expects(:new)
+
+    @r.fork_bare("/foo/bar.git")
+  end
+
+  def test_fork_bare_with_options
+    Git.any_instance.expects(:clone).with(
+      {:bare => true, :shared => true, :template => '/awesome'},
+      "#{absolute_project_path}/.git",
+      "/foo/bar.git").returns(nil)
+    Repo.expects(:new)
+
+    @r.fork_bare("/foo/bar.git", :template => '/awesome')
+  end
+
+  # diff
+
+  def test_diff
+    Git.any_instance.expects(:diff).with({}, 'master^', 'master', '--')
+    @r.diff('master^', 'master')
+
+    Git.any_instance.expects(:diff).with({}, 'master^', 'master', '--', 'foo/bar')
+    @r.diff('master^', 'master', 'foo/bar')
+
+    Git.any_instance.expects(:diff).with({}, 'master^', 'master', '--', 'foo/bar', 'foo/baz')
+    @r.diff('master^', 'master', 'foo/bar', 'foo/baz')
+  end
+
+  # commit_diff
+
+  def test_diff
+    Git.any_instance.expects(:diff).returns(fixture('diff_p'))
+    diffs = @r.commit_diff('master')
+
+    assert_equal 15, diffs.size
+  end
+
+  # init bare
+
+  # archive
+
+  def test_archive_tar
+    #@r.archive_tar  -- no assertion being done here
+  end
+
+  # archive_tar_gz
+
+  def test_archive_tar_gz
+    #@r.archive_tar_gz -- again, no assertion
+  end
+
+  # enable_daemon_serve
+
+  def test_enable_daemon_serve
+    f = stub
+    f.expects("write").with('')
+    File.expects(:open).with(File.join(@r.path, 'git-daemon-export-ok'), 'w').yields(f)
+    @r.enable_daemon_serve
+  end
+
+  # disable_daemon_serve
+
+  def test_disable_daemon_serve
+    FileUtils.expects(:rm_rf).with(File.join(@r.path, 'git-daemon-export-ok'))
+    @r.disable_daemon_serve
+  end
+
+  def test_gc_auto
+    Git.any_instance.expects(:gc).with({:auto => true})
+    @r.gc_auto
+  end
+
+  # alternates
+
+  def test_alternates_with_two_alternates
+    File.expects(:exist?).with("#{absolute_project_path}/.git/objects/info/alternates").returns(true)
+    File.any_instance.expects(:read).returns("/path/to/repo1/.git/objects\n/path/to/repo2.git/objects\n")
+
+    assert_equal ["/path/to/repo1/.git/objects", "/path/to/repo2.git/objects"], @r.alternates
+  end
+
+  def test_alternates_no_file
+    File.expects(:exist?).returns(false)
+
+    assert_equal [], @r.alternates
+  end
+
+  # alternates=
+
+  def test_alternates_setter_ok
+    alts = %w{/path/to/repo.git/objects /path/to/repo2.git/objects}
+
+    alts.each do |alt|
+      File.expects(:exist?).with(alt).returns(true)
+    end
+
+    File.any_instance.expects(:write).with(alts.join("\n"))
+
+    assert_nothing_raised do
+      @r.alternates = alts
+    end
+  end
+
+  def test_alternates_setter_bad
+    alts = %w{/path/to/repo.git/objects}
+
+    alts.each do |alt|
+      File.expects(:exist?).with(alt).returns(false)
+    end
+
+    File.any_instance.expects(:write).never
+
+    assert_raise RuntimeError do
+      @r.alternates = alts
+    end
+  end
+
+  def test_alternates_setter_empty
+    File.any_instance.expects(:write)
+    @r.alternates = []
+  end
+
+  # inspect
+
+  def test_inspect
+    assert_equal %Q{#<Grit::Repo "#{File.expand_path(GRIT_REPO)}/.git">}, @r.inspect
+  end
+
+  # log
+
+  def test_log
+    Git.any_instance.expects(:log).times(2).with({:pretty => 'raw'}, 'master').returns(fixture('rev_list'))
+
+    assert_equal '4c8124ffcf4039d292442eeccabdeca5af5c5017', @r.log.first.id
+    assert_equal 'ab25fd8483882c3bda8a458ad2965d2248654335', @r.log.last.id
+  end
+
+  def test_log_with_path_and_options
+    Git.any_instance.expects(:log).with({:pretty => 'raw', :max_count => 1}, 'master', '--', 'file.rb').returns(fixture('rev_list'))
+    @r.log('master', 'file.rb', :max_count => 1)
+  end
+
+  # commit_deltas_from
+
+  def test_commit_deltas_from_nothing_new
+    other_repo = Repo.new(GRIT_REPO)
+    @r.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_b"))
+    other_repo.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_a"))
+
+    delta_blobs = @r.commit_deltas_from(other_repo)
+    assert_equal 0, delta_blobs.size
+  end
+
+  def test_commit_deltas_from_when_other_has_new
+    other_repo = Repo.new(GRIT_REPO)
+    @r.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_a"))
+    other_repo.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_b"))
+    %w[
+      4c8124ffcf4039d292442eeccabdeca5af5c5017
+      634396b2f541a9f2d58b00be1a07f0c358b999b3
+      ab25fd8483882c3bda8a458ad2965d2248654335
+    ].each do |ref|
+      Commit.expects(:find_all).with(other_repo, ref, :max_count => 1).returns([stub()])
+    end
+    delta_blobs = @r.commit_deltas_from(other_repo)
+    assert_equal 3, delta_blobs.size
+  end
+end