rugged 0.19.0 → 0.21.0

data/test/index_test.rb

@@ -1,333 +0,0 @@
-require "test_helper"
-require 'base64'
-require 'tempfile'
-require 'fileutils'
-
-class IndexTest < Rugged::TestCase
-  def self.new_index_entry
-      now = Time.now
-      {
-        :path => "new_path",
-        :oid => "d385f264afb75a56a5bec74243be9b367ba4ca08",
-        :mtime => now,
-        :ctime => now,
-        :file_size => 1000,
-        :dev => 234881027,
-        :ino => 88888,
-        :mode => 33199,
-        :uid => 502,
-        :gid => 502,
-        :stage => 3,
-      }
-  end
-
-  def setup 
-    path = File.dirname(__FILE__) + '/fixtures/testrepo.git/index'
-    @index = Rugged::Index.new(path)
-  end
-
-  def test_iteration
-    enum = @index.each
-    assert enum.kind_of? Enumerable
-
-    i = 0
-    @index.each { |e| i += 1 }
-    assert_equal @index.count, i
-  end
-
-  def test_index_size
-    assert_equal 2, @index.count
-  end
-
-  def test_empty_index
-    @index.clear
-    assert_equal 0, @index.count
-  end
-
-  def test_remove_entries
-    @index.remove 'new.txt'
-    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]
-    assert_equal '1385f264afb75a56a5bec74243be9b367ba4ca08', e[:oid]
-    assert_equal 1273360380, e[:mtime].to_i
-    assert_equal 1273360380, e[:ctime].to_i
-    assert_equal 4, e[:file_size]
-    assert_equal 234881026, e[:dev]
-    assert_equal 6674088, e[:ino]
-    assert_equal 33188, e[:mode]
-    assert_equal 501, e[:uid]
-    assert_equal 0, e[:gid]
-    assert_equal false, e[:valid]
-    assert_equal 0, e[:stage]
-
-    e = @index[1]
-    assert_equal 'new.txt', e[:path]
-    assert_equal 'fa49b077972391ad58037050f2a75f74e3671e92', e[:oid]
-  end
-
-  def test_iterate_entries
-    itr_test = @index.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:path] }.join(':')
-    assert_equal "README:new.txt", itr_test
-  end
-
-  def test_update_entries
-    now = Time.at Time.now.to_i
-    e = @index[0]
-
-    e[:oid] = "12ea3153a78002a988bb92f4123e7e831fd1138a"
-    e[:mtime] = now
-    e[:ctime] = now
-    e[:file_size] = 1000
-    e[:dev] = 234881027
-    e[:ino] = 88888
-    e[:mode] = 33199
-    e[:uid] = 502
-    e[:gid] = 502
-    e[:stage] = 3
-
-    @index.add(e)
-    new_e = @index.get e[:path], 3
-
-    assert_equal e, new_e
-  end
-
-  def test_add_new_entries
-    e = IndexTest.new_index_entry
-    @index << e
-    assert_equal 3, @index.count
-    itr_test = @index.sort { |a, b| a[:oid] <=> b[:oid] }.map { |x| x[:path] }.join(':')
-    assert_equal "README:new_path:new.txt", itr_test
-  end
-end
-
-class IndexWriteTest < Rugged::TestCase
-  def setup 
-    path = File.dirname(__FILE__) + '/fixtures/testrepo.git/index'
-    @tmppath = Tempfile.new('index').path
-    FileUtils.copy(path, @tmppath)
-    @index = Rugged::Index.new(@tmppath)
-  end
-
-  def teardown
-    File.delete(@tmppath)
-  end
-
-  def test_raises_when_writing_invalid_entries
-    assert_raises TypeError do
-      @index.add(21)
-    end
-  end
-
-  def test_can_write_index
-    e = IndexTest.new_index_entry
-    @index << e
-
-    e[:path] = "else.txt"
-    @index << e
-
-    @index.write
-
-    index2 = Rugged::Index.new(@tmppath)
-
-    itr_test = index2.sort { |a, b| a[:oid] <=> b[:oid] }.map { |x| x[:path] }.join(':')
-    assert_equal "README:else.txt:new_path:new.txt", itr_test
-    assert_equal 4, index2.count
-  end
-end
-
-class IndexWorkdirTest < Rugged::TestCase
-  def setup 
-    @tmppath = Dir.mktmpdir
-    @repo = Rugged::Repository.init_at(@tmppath, false)
-    @index = @repo.index
-  end
-
-  def teardown 
-    FileUtils.remove_entry_secure(@tmppath)
-  end
-
-  def test_adding_a_path
-    File.open(File.join(@tmppath, 'test.txt'), 'w') do |f|
-      f.puts "test content"
-    end
-    @index.add('test.txt')
-    @index.write
-
-    index2 = Rugged::Index.new(@tmppath + '/.git/index')
-    assert_equal index2[0][:path], 'test.txt'
-  end
-
-  def test_reloading_index
-    File.open(File.join(@tmppath, 'test.txt'), 'w') do |f|
-      f.puts "test content"
-    end
-    @index.add('test.txt')
-    @index.write
-
-    rindex = Rugged::Index.new(File.join(@tmppath, '/.git/index'))
-    e = rindex['test.txt']
-    assert_equal 0, e[:stage]
-
-    rindex << IndexTest.new_index_entry
-    rindex.write
-
-    assert_equal 1, @index.count
-    @index.reload
-    assert_equal 2, @index.count
-
-    e = @index.get 'new_path', 3
-    assert_equal e[:mode], 33199
-  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
-
-  def test_idempotent_read_write
-    head_sha = Rugged::Reference.lookup(@repo,'HEAD').resolve.target
-    tree = @repo.lookup(head_sha).tree
-    index = @repo.index
-    index.read_tree(tree)
-
-    index_tree_sha = index.write_tree
-    index_tree = @repo.lookup(index_tree_sha)
-    assert_equal tree.oid, index_tree.oid
-  end
-
-  def test_build_tree_from_index
-    head_sha = Rugged::Reference.lookup(@repo,'refs/remotes/origin/packed').resolve.target
-    tree = @repo.lookup(head_sha).tree
-
-    index = @repo.index
-    index.read_tree(tree)
-    index.remove('second.txt')
-
-    new_tree_sha = index.write_tree
-    assert head_sha != new_tree_sha
-    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/lib_test.rb

@@ -1,127 +0,0 @@
-require "test_helper"
-require 'base64'
-
-class RuggedTest < Rugged::TestCase
-
-  @@oids = [
-    'd8786bfc974aaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-    'd8786bfc974bbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-    'd8786bfc974ccccccccccccccccccccccccccccc',
-    '68d041ee999cb07c6496fbdd4f384095de6ca9e1'
-  ]
-
-  def test_libgit2_version
-    version = Rugged::libgit2_version
-    assert_equal version.length, 3
-    version.each do |i|
-      assert i.is_a? Fixnum
-    end
-  end
-
-  def test_options
-    Rugged::Settings['mwindow_size'] = 8 * 1024 * 1024
-    Rugged::Settings['mwindow_mapped_limit'] = 8 * 1024 * 1024
-
-    assert_equal 8 * 1024 * 1024, Rugged::Settings['mwindow_size']
-
-    assert_raises(TypeError) { Rugged::Settings['mwindow_mapped_limit'] = 'asdf' }
-    assert_raises(TypeError) { Rugged::Settings['mwindow_size'] = nil }
-  end
-
-  def test_capabilities
-    capabilities = Rugged.capabilities
-    assert capabilities.is_a? Array
-  end
-
-  def test_hex_to_raw_oid
-    raw = Rugged::hex_to_raw("ce08fe4884650f067bd5703b6a59a8b3b3c99a09")
-    b64raw = Base64.encode64(raw).strip
-    assert_equal "zgj+SIRlDwZ71XA7almos7PJmgk=", b64raw
-
-    hex = "ce08fe4884650f067bd5703b6a59a8b3b3c99a09"
-    raw1 = Rugged::hex_to_raw(hex)
-    raw2 = [hex].pack("H*")
-    assert_equal raw1, raw2
-  end
-
-  def test_raw_to_hex
-    raw = Base64.decode64("FqASNFZ4mrze9Ld1ITwjqL109eA=")
-    hex = Rugged::raw_to_hex(raw)
-    assert_equal "16a0123456789abcdef4b775213c23a8bd74f5e0", hex
-
-    raw = Rugged::hex_to_raw("ce08fe4884650f067bd5703b6a59a8b3b3c99a09")
-    hex1 = Rugged::raw_to_hex(raw)
-    hex2 = raw.unpack("H*")[0]
-    assert_equal hex1, hex2
-  end
-
-  def test_raw_to_hex_with_nulls
-    raw = Rugged::hex_to_raw("702f00394564b24052511cb69961164828bf5494")
-    hex1 = Rugged::raw_to_hex(raw)
-    hex2 = raw.unpack("H*")[0]
-    assert_equal hex1, hex2
-  end
-
-  def test_hex_to_raw_with_invalid_character_raises_invalid_error
-    assert_raises Rugged::InvalidError do
-      Rugged::hex_to_raw("\x16\xA0\x124VWATx\x9A\xBC\xDE\xF4") # invalid bytes
-    end
-  end
-
-  def test_raw_to_hex_with_invalid_size_raises_type_error
-    assert_raises TypeError do
-      Rugged::raw_to_hex("702f00394564b24052511cb69961164828bf5") # invalid OID size
-    end
-  end
-
-  def test_minimize_oid_with_no_block
-    assert_equal 12, Rugged::minimize_oid(@@oids)
-  end
-
-  def test_minimize_oid_with_min_length
-    assert_equal 20, Rugged::minimize_oid(@@oids, 20)
-  end
-
-  def test_minimize_oid_with_block
-    minimized_oids = []
-    Rugged::minimize_oid(@@oids) { |oid| minimized_oids << oid }
-    expected_oids = [
-      "d8786bfc974a",
-      "d8786bfc974b",
-      "d8786bfc974c",
-      "68d041ee999c"
-    ]
-
-    assert_equal expected_oids, minimized_oids
-  end
-
-  def test_rugged_lib_constants
-    assert_equal 0, Rugged::SORT_NONE
-    assert_equal 1, Rugged::SORT_TOPO
-    assert_equal 2, Rugged::SORT_DATE
-    assert_equal 4, Rugged::SORT_REVERSE
-  end
-
-  def test_prettify_commit_messages
-    message = <<-MESSAGE
-Testing this whole prettify business    
-
-with newlines and stuff  
-# take out this line haha
-# and this one
-
-not this one    
-MESSAGE
-
-    clean_message = <<-MESSAGE
-Testing this whole prettify business
-
-with newlines and stuff
-
-not this one
-MESSAGE
-
-    assert_equal clean_message, Rugged::prettify_message(message, true)
-  end
-end
-

data/test/note_test.rb

@@ -1,158 +0,0 @@
-require 'test_helper'
-
-class NoteTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  def test_read_note_for_object
-    oid = "36060c58702ed4c2a40832c51758d5344201d89a"
-    obj = @repo.lookup(oid)
-    notes = obj.notes
-    assert_equal "note text\n", notes[:message]
-    assert_equal "94eca2de348d5f672faf56b0decafa5937e3235e", notes[:oid]
-  end
-
-  def test_read_note_for_object_from_ref
-    oid = "36060c58702ed4c2a40832c51758d5344201d89a"
-    obj = @repo.lookup(oid)
-    notes = obj.notes('refs/notes/commits')
-    assert_equal "note text\n", notes[:message]
-    assert_equal "94eca2de348d5f672faf56b0decafa5937e3235e", notes[:oid]
-  end
-
-  def test_object_without_note
-    oid = "8496071c1b46c854b31185ea97743be6a8774479"
-    obj = @repo.lookup(oid)
-    assert_nil obj.notes
-  end
-
-  def test_nil_ref_lookup
-    oid = "36060c58702ed4c2a40832c51758d5344201d89a"
-    obj = @repo.lookup(oid)
-    assert_nil obj.notes('refs/notes/missing')
-  end
-
-  def test_iterate_over_notes
-    @repo.each_note('refs/notes/commits') do |note_blob, annotated_object|
-      assert_equal "note text\n", note_blob.content
-      assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", annotated_object.oid
-    end
-  end
-
-  def test_each_note_enumerable
-    enum = @repo.each_note('refs/notes/commits')
-    assert enum.kind_of? Enumerable
-  end
-
-  def test_default_ref
-    assert_equal 'refs/notes/commits', @repo.default_notes_ref
-  end
-end
-
-class NoteWriteTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def test_create_note
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-
-    oid = "8496071c1b46c854b31185ea97743be6a8774479"
-    message ="This is the note message\n\nThis note is created from Rugged"
-    obj = @repo.lookup(oid)
-
-    note_oid = obj.create_note(
-      :message => message,
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test'
-    )
-
-    assert_equal '38c3a690c474d8dcdb13088205a464a60312eec4', note_oid
-    # note is actually a blob
-    blob = @repo.lookup(note_oid)
-    assert_equal blob.oid, note_oid
-    assert_equal blob.content, message
-    assert_equal blob.type, :blob
-
-    note = obj.notes('refs/notes/test')
-    assert_equal note[:oid], note_oid
-    assert_equal note[:message], message
-  end
-
-  def test_create_note_on_object_with_notes_raises
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-    oid = "8496071c1b46c854b31185ea97743be6a8774479"
-    message ="This is the note message\n\nThis note is created from Rugged"
-    obj = @repo.lookup(oid)
-    obj.create_note(
-      :message => message,
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test'
-    )
-
-    assert_raises Rugged::RepositoryError do
-      obj.create_note(
-        :message => message,
-        :committer => person,
-        :author => person,
-        :ref => 'refs/notes/test'
-      )
-    end
-  end
-
-  def test_overwrite_object_note
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-    oid = "8496071c1b46c854b31185ea97743be6a8774479"
-    message ="This is the note message\n\nThis note is created from Rugged"
-    obj = @repo.lookup(oid)
-    obj.create_note(
-      :message => message,
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test'
-    )
-
-    obj.create_note(
-      :message => 'new message',
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test',
-      :force => true
-    )
-
-    note = obj.notes('refs/notes/test')
-    assert_equal note[:message], 'new message'
-  end
-
-  def test_remove_note
-    oid = "36060c58702ed4c2a40832c51758d5344201d89a"
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-    message ="This is the note message\n\nThis note is created from Rugged"
-    obj = @repo.lookup(oid)
-
-    obj.create_note(
-      :message => message,
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test'
-    )
-
-    assert obj.remove_note(
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test'
-    )
-
-    assert_nil obj.notes('refs/notes/test')
-  end
-
-  def test_remove_missing_note
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-    oid = "36060c58702ed4c2a40832c51758d5344201d89a"
-    obj = @repo.lookup(oid)
-    refute obj.remove_note(
-      :committer => person,
-      :author => person,
-      :ref => 'refs/notes/test'
-    )
-  end
-end

data/test/object_test.rb

@@ -1,43 +0,0 @@
-require "test_helper"
-require 'base64'
-
-class ObjectTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  def test_fail_to_lookup_inexistant_object
-    assert_raises Rugged::OdbError do
-      @repo.lookup("a496071c1b46c854b31185ea97743be6a8774479")
-    end
-  end
-
-  def test_lookup_object
-    obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
-    assert_equal :commit, obj.type
-    assert_equal '8496071c1b46c854b31185ea97743be6a8774479', obj.oid
-  end
-
-  def test_objects_are_the_same
-    obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
-    obj2 = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
-    assert_equal obj, obj2
-  end
-
-  def test_read_raw_data
-    obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
-    assert obj.read_raw
-  end
-
-  def test_lookup_by_rev
-    obj = @repo.rev_parse("v1.0")
-    assert "0c37a5391bbff43c37f0d0371823a5509eed5b1d", obj.oid
-    obj = @repo.rev_parse("v1.0^1")
-    assert "8496071c1b46c854b31185ea97743be6a8774479", obj.oid
-  end
-
-  def test_lookup_oid_by_rev
-    oid = @repo.rev_parse_oid("v1.0")
-    assert "0c37a5391bbff43c37f0d0371823a5509eed5b1d", oid
-    @repo.rev_parse_oid("v1.0^1")
-    assert "8496071c1b46c854b31185ea97743be6a8774479", oid
-  end
-end