rugged 0.19.0 → 0.21.0

data/test/repo_test.rb

@@ -1,402 +0,0 @@
-require 'test_helper'
-require 'base64'
-
-class RepositoryTest < Rugged::SandboxedTestCase
-  def setup
-    super
-
-    @repo = sandbox_init "testrepo.git"
-  end
-
-  def test_last_commit
-    assert @repo.respond_to? :last_commit
-    assert "36060c58702ed4c2a40832c51758d5344201d89a", @repo.last_commit.oid
-  end
-
-  def test_fails_to_open_unexisting_repos
-    assert_raises IOError, Rugged::OSError do
-      Rugged::Repository.new("fakepath/123/")
-    end
-
-    assert_raises Rugged::RepositoryError do
-      Rugged::Repository.new("/home/")
-    end
-  end
-
-  def test_can_check_if_objects_exist
-    assert @repo.exists?("8496071c1b46c854b31185ea97743be6a8774479")
-    assert @repo.exists?("1385f264afb75a56a5bec74243be9b367ba4ca08")
-    assert !@repo.exists?("ce08fe4884650f067bd5703b6a59a8b3b3c99a09")
-    assert !@repo.exists?("8496071c1c46c854b31185ea97743be6a8774479")
-  end
-
-  def test_can_read_a_raw_object
-    rawobj = @repo.read("8496071c1b46c854b31185ea97743be6a8774479")
-    assert_match 'tree 181037049a54a1eb5fab404658a3a250b44335d7', rawobj.data
-    assert_equal 172, rawobj.len
-    assert_equal :commit, rawobj.type
-  end
-
-  def test_can_read_object_headers
-    hash = @repo.read_header("8496071c1b46c854b31185ea97743be6a8774479")
-    assert_equal 172, hash[:len]
-    assert_equal :commit, hash[:type]
-  end
-
-  def test_check_reads_fail_on_missing_objects
-    assert_raises Rugged::OdbError do
-      @repo.read("a496071c1b46c854b31185ea97743be6a8774471")
-    end
-  end
-
-  def test_check_read_headers_fail_on_missing_objects
-    assert_raises Rugged::OdbError do
-      @repo.read_header("a496071c1b46c854b31185ea97743be6a8774471")
-    end
-  end
-
-  def test_walking_with_block
-    oid = "a4a7dce85cf63874e984719f4fdd239f5145052f"
-    list = []
-    @repo.walk(oid) { |c| list << c }
-    assert list.map {|c| c.oid[0,5] }.join('.'), "a4a7d.c4780.9fd73.4a202.5b5b0.84960"
-  end
-
-  def test_walking_without_block
-    commits = @repo.walk('a4a7dce85cf63874e984719f4fdd239f5145052f')
-
-    assert commits.kind_of?(Enumerable)
-    assert commits.count > 0
-  end
-
-  def test_lookup_object
-    object = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
-    assert object.kind_of?(Rugged::Commit)
-  end
-
-  def test_find_reference
-    ref = @repo.ref('refs/heads/master')
-
-    assert ref.kind_of?(Rugged::Reference)
-    assert_equal 'refs/heads/master', ref.name
-  end
-
-  def test_match_all_refs
-    refs = @repo.refs 'refs/heads/*'
-    assert_equal 2, refs.count
-  end
-
-  def test_return_all_ref_names
-    refs = @repo.ref_names
-    refs.each {|name| assert name.kind_of?(String)}
-    assert_equal 5, refs.count
-  end
-
-  def test_return_all_tags
-    tags = @repo.tags
-    assert_equal 2, tags.count
-  end
-
-  def test_return_matching_tags
-    tags = @repo.tags 'v0.9'
-    assert_equal 1, tags.count
-  end
-
-  def test_return_all_remotes
-    remotes = @repo.remotes
-    assert_equal 2, remotes.count
-  end
-
-  def test_lookup_head
-    head = @repo.head
-    assert_equal "refs/heads/master", head.name
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", head.target
-    assert_equal :direct, head.type
-  end
-
-  def test_set_head_ref
-    @repo.head = "refs/heads/packed"
-    assert_equal "refs/heads/packed", @repo.head.name
-  end
-
-  def test_set_head_invalid
-    assert_raises Rugged::ReferenceError do
-      @repo.head = "36060c58702ed4c2a40832c51758d5344201d89a"
-    end
-  end
-
-  def test_access_a_file
-    sha = '36060c58702ed4c2a40832c51758d5344201d89a'
-    blob = @repo.blob_at(sha, 'new.txt')
-    assert_equal "new file\n", blob.content
-  end
-
-  def test_access_a_missing_file
-    sha = '36060c58702ed4c2a40832c51758d5344201d89a'
-    blob = @repo.blob_at(sha, 'file-not-found.txt')
-    assert_nil blob
-  end
-
-  def test_garbage_collection
-    Rugged::Repository.new(@repo.path)
-    ObjectSpace.garbage_collect
-  end
-
-  def test_enumerate_all_objects
-    assert_equal 37, @repo.each_id.to_a.length
-  end
-
-  def test_loading_alternates
-    alt_path = File.dirname(__FILE__) + '/fixtures/alternate/objects'
-    repo = Rugged::Repository.new(@repo.path, :alternates => [alt_path])
-    assert_equal 40, repo.each_id.to_a.length
-    assert repo.read('146ae76773c91e3b1d00cf7a338ec55ae58297e2')
-  end
-
-  def test_alternates_with_invalid_path_type
-    assert_raises TypeError do
-      Rugged::Repository.new(@repo.path, :alternates => [:invalid_input])
-    end
-  end
-
-  def test_find_merge_base_between_oids
-    commit1 = 'a4a7dce85cf63874e984719f4fdd239f5145052f'
-    commit2 = '36060c58702ed4c2a40832c51758d5344201d89a'
-    base    = '5b5b025afb0b4c913b4c338a42934a3863bf3644'
-    assert_equal base, @repo.merge_base(commit1, commit2)
-  end
-
-  def test_find_merge_base_between_commits
-    commit1 = @repo.lookup('a4a7dce85cf63874e984719f4fdd239f5145052f')
-    commit2 = @repo.lookup('36060c58702ed4c2a40832c51758d5344201d89a')
-    base    = '5b5b025afb0b4c913b4c338a42934a3863bf3644'
-    assert_equal base, @repo.merge_base(commit1, commit2)
-  end
-
-  def test_find_merge_base_between_ref_and_oid
-    commit1 = 'a4a7dce85cf63874e984719f4fdd239f5145052f'
-    commit2 = "refs/heads/master"
-    base    = '5b5b025afb0b4c913b4c338a42934a3863bf3644'
-    assert_equal base, @repo.merge_base(commit1, commit2)
-  end
-
-  def test_find_merge_base_between_many
-    commit1 = 'a4a7dce85cf63874e984719f4fdd239f5145052f'
-    commit2 = "refs/heads/packed"
-    commit3 = @repo.lookup('36060c58702ed4c2a40832c51758d5344201d89a')
-
-    base    = '5b5b025afb0b4c913b4c338a42934a3863bf3644'
-    assert_equal base, @repo.merge_base(commit1, commit2, commit3)
-  end
-
-  def test_ahead_behind_with_oids
-    ahead, behind = @repo.ahead_behind(
-      'a4a7dce85cf63874e984719f4fdd239f5145052f',
-      '36060c58702ed4c2a40832c51758d5344201d89a'
-    )
-    assert_equal 1, ahead
-    assert_equal 4, behind
-  end
-
-  def test_ahead_behind_with_commits
-    ahead, behind = @repo.ahead_behind(
-      @repo.lookup('a4a7dce85cf63874e984719f4fdd239f5145052f'),
-      @repo.lookup('36060c58702ed4c2a40832c51758d5344201d89a')
-    )
-    assert_equal 1, ahead
-    assert_equal 4, behind
-  end
-end
-
-class RepositoryWriteTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  TEST_CONTENT = "my test data\n"
-  TEST_CONTENT_TYPE = 'blob'
-
-  def test_can_hash_data
-    oid = Rugged::Repository::hash(TEST_CONTENT, TEST_CONTENT_TYPE)
-    assert_equal "76b1b55ab653581d6f2c7230d34098e837197674", oid
-  end
-
-  def test_write_to_odb
-    oid = @repo.write(TEST_CONTENT, TEST_CONTENT_TYPE)
-    assert_equal "76b1b55ab653581d6f2c7230d34098e837197674", oid
-    assert @repo.exists?("76b1b55ab653581d6f2c7230d34098e837197674")
-  end
-
-  def test_no_merge_base_between_unrelated_branches
-    info = @repo.rev_parse('HEAD').to_hash
-    baseless = Rugged::Commit.create(@repo, info.merge(:parents => []))
-    assert_nil @repo.merge_base('HEAD', baseless)
-  end
-end
-
-class RepositoryInitTest < Rugged::TestCase
-  def setup
-    @tmppath = Dir.mktmpdir
-  end
-
-  def teardown
-    FileUtils.remove_entry_secure(@tmppath)
-  end
-
-  def test_init_bare_false
-    repo = Rugged::Repository.init_at(@tmppath, false)
-    refute repo.bare?
-  end
-
-  def test_init_bare_true
-    repo = Rugged::Repository.init_at(@tmppath, true)
-    assert repo.bare?
-  end
-
-  def test_init_bare_truthy
-    repo = Rugged::Repository.init_at(@tmppath, :bare)
-    assert repo.bare?
-  end
-
-  def test_init_non_bare_default
-    repo = Rugged::Repository.init_at(@tmppath)
-    refute repo.bare?
-  end
-end
-
-class RepositoryCloneTest < Rugged::TestCase
-  def setup
-    @tmppath = Dir.mktmpdir
-    @source_path = File.join(Rugged::TestCase::TEST_DIR, 'fixtures', 'testrepo.git')
-  end
-
-  def teardown
-    FileUtils.remove_entry_secure(@tmppath)
-  end
-
-  def test_clone
-    repo = Rugged::Repository.clone_at(@source_path, @tmppath)
-    assert_equal "hey", File.read(File.join(@tmppath, "README")).chomp
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", repo.head.target
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", repo.ref("refs/heads/master").target
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", repo.ref("refs/remotes/origin/master").target
-    assert_equal "41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9", repo.ref("refs/remotes/origin/packed").target
-  end
-
-  def test_clone_bare
-    repo = Rugged::Repository.clone_at(@source_path, @tmppath, :bare => true)
-    assert repo.bare?
-  end
-
-  def test_clone_with_progress
-    total_objects = indexed_objects = received_objects = received_bytes = nil
-    callsback = 0
-    Rugged::Repository.clone_at(@source_path, @tmppath,
-      :progress => lambda { |*args| callsback += 1 ; total_objects, indexed_objects, received_objects, received_bytes = args })
-    assert_equal 22,   callsback
-    assert_equal 19,   total_objects
-    assert_equal 19,   indexed_objects
-    assert_equal 19,   received_objects
-    assert_equal 1563, received_bytes
-  end
-
-  def test_clone_quits_on_error
-    begin
-      Rugged::Repository.clone_at(@source_path, @tmppath, :progress => lambda { |*_| raise 'boom' })
-    rescue => e
-      assert_equal 'boom', e.message
-    end
-    assert_no_dotgit_dir(@tmppath)
-  end
-
-  def test_clone_with_bad_progress_callback
-    assert_raises ArgumentError do
-      Rugged::Repository.clone_at(@source_path, @tmppath, :progress => Object.new)
-    end
-    assert_no_dotgit_dir(@tmppath)
-  end
-
-  def assert_no_dotgit_dir(path)
-    assert_equal [], Dir[File.join(path, ".git/**")], "new repository's .git dir should not exist"
-  end
-end
-
-class RepositoryNamespaceTest < Rugged::SandboxedTestCase
-  def setup
-    super
-
-    @repo = sandbox_init("testrepo.git")
-  end
-
-  def test_no_namespace
-    assert_nil @repo.namespace
-  end
-
-  def test_changing_namespace
-    @repo.namespace = "foo"
-    assert_equal "foo", @repo.namespace
-
-    @repo.namespace = "bar"
-    assert_equal "bar", @repo.namespace
-
-    @repo.namespace = "foo/bar"
-    assert_equal "foo/bar", @repo.namespace
-
-    @repo.namespace = nil
-    assert_equal nil, @repo.namespace
-  end
-
-  def test_refs_in_namespaces
-    @repo.namespace = "foo"
-    assert_equal [], @repo.refs.to_a
-  end
-end
-
-class RepositoryPushTest < 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")
-  end
-
-  def test_push_single_ref
-    result = @repo.push("origin", ["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_remote_instance
-    origin = Rugged::Remote.lookup(@repo, "origin")
-    result = @repo.push(origin, ["refs/heads/master"])
-    assert_equal({}, result)
-  end
-
-  def test_push_to_non_bare_raise_error
-    @remote_repo.config['core.bare'] = 'false'
-
-    assert_raises Rugged::Error do
-      @repo.push("origin", ["refs/heads/master"])
-    end
-  end
-
-  def test_push_non_forward_raise_error
-    assert_raises Rugged::Error do
-      @repo.push("origin", ["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 = @repo.push("origin", ["+refs/heads/unit_test:refs/heads/master"])
-    assert_equal({}, result)
-
-    assert_equal "8496071c1b46c854b31185ea97743be6a8774479", @remote_repo.ref("refs/heads/master").target
-  end
-end

data/test/tag_test.rb

@@ -1,68 +0,0 @@
-require "test_helper"
-
-class TagTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  def test_reading_a_tag
-    oid = "0c37a5391bbff43c37f0d0371823a5509eed5b1d"
-    obj = @repo.lookup(oid)
-
-    assert_equal oid, obj.oid
-    assert_equal :tag, obj.type
-    assert_equal "test tag message\n", obj.message
-    assert_equal "v1.0", obj.name
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", obj.target.oid
-    assert_equal :commit, obj.target_type
-    c = obj.tagger
-    assert_equal "Scott Chacon", c[:name]
-    assert_equal 1288114383, c[:time].to_i
-    assert_equal "schacon@gmail.com", c[:email]
-  end
-
-  def test_reading_the_oid_of_a_tag
-    oid = "0c37a5391bbff43c37f0d0371823a5509eed5b1d"
-    obj = @repo.lookup(oid)
-
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", obj.target_oid
-  end
-end
-
-class TagWriteTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def test_writing_a_tag
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-    tag_oid = Rugged::Tag.create(@repo,
-      :name    => 'tag',
-      :message => "test tag message\n",
-      :target  => "5b5b025afb0b4c913b4c338a42934a3863bf3644",
-      :tagger => person)
-
-    tag = @repo.lookup(tag_oid)
-    assert_equal :tag, tag.type
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", tag.target.oid
-    assert_equal "test tag message\n", tag.message
-    assert_equal "Scott", tag.tagger[:name]
-    assert_equal "schacon@gmail.com", tag.tagger[:email]
-  end
-
-  def test_tag_invalid_message_type
-    person = {:name => 'Scott', :email => 'schacon@gmail.com', :time => Time.now }
-    assert_raises TypeError do
-      Rugged::Tag.create(@repo,
-        :name    => 'tag',
-        :message => :invalid_message,
-        :target  => "5b5b025afb0b4c913b4c338a42934a3863bf3644",
-        :tagger => person)
-    end
-  end
-
-  def test_writing_light_tags
-    Rugged::Tag.create(@repo,
-      :name    => 'tag',
-      :target  => "5b5b025afb0b4c913b4c338a42934a3863bf3644")
-
-    tag = Rugged::Reference.lookup(@repo, "refs/tags/tag")
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", tag.target
-  end
-end

data/test/test_helper.rb

@@ -1,92 +0,0 @@
-require 'rubygems'
-
-require 'tempfile'
-require 'tmpdir'
-require 'minitest/autorun'
-require 'rugged'
-require 'pp'
-
-module Rugged
-  class TestCase < MiniTest::Unit::TestCase
-    # Ruby 1.8 / 1.9 Shim
-    Enumerator = defined?(::Enumerator) ? ::Enumerator : ::Enumerable::Enumerator
-
-    TEST_DIR = File.dirname(File.expand_path(__FILE__))
-
-    protected
-    def with_default_encoding(encoding, &block)
-      old_encoding = Encoding.default_internal
-
-      new_encoding = Encoding.find(encoding)
-      Encoding.default_internal = new_encoding
-
-      yield new_encoding
-
-      Encoding.default_internal = old_encoding
-    end
-  end
-
-  class SandboxedTestCase < TestCase
-    def setup
-      super
-      @_sandbox_path = Dir.mktmpdir("rugged_sandbox")
-    end
-
-    def teardown
-      FileUtils.remove_entry_secure @_sandbox_path
-      super
-    end
-
-    # Fills the current sandbox folder with the files
-    # found in the given repository
-    def sandbox_init(repository)
-      FileUtils.cp_r(File.join(TestCase::TEST_DIR, 'fixtures', repository), @_sandbox_path)
-
-      Dir.chdir(File.join(@_sandbox_path, repository)) do
-        File.rename(".gitted", ".git") if File.exists?(".gitted")
-        File.rename("gitattributes", ".gitattributes") if File.exists?("gitattributes")
-        File.rename("gitignore", ".gitignore") if File.exists?("gitignore")
-      end
-
-      Rugged::Repository.new(File.join(@_sandbox_path, repository))
-    end
-
-    def sandbox_clone(repository, name)
-      Dir.chdir(@_sandbox_path) do
-        `git clone #{repository} #{name}`
-      end
-
-      Rugged::Repository.new(File.join(@_sandbox_path, name))
-    end
-  end
-
-  module RepositoryAccess
-    def setup
-      @path = File.dirname(__FILE__) + '/fixtures/testrepo.git/'
-      @repo = Rugged::Repository.new(@path)
-    end
-  end
-
-  module TempRepositoryAccess
-    def setup
-      @path = temp_repo("testrepo.git")
-      @repo = Rugged::Repository.new(@path)
-    end
-
-    def teardown
-      destroy_temp_repo(@path)
-    end
-
-    protected
-    def temp_repo(repo)
-      dir = Dir.mktmpdir 'dir'
-      repo_dir = File.join(TestCase::TEST_DIR, (File.join('fixtures', repo, '.')))
-      `git clone #{repo_dir} #{dir}`
-      dir
-    end
-
-    def destroy_temp_repo(path)
-      FileUtils.remove_entry_secure(path)
-    end
-  end
-end

data/test/tree_test.rb

@@ -1,91 +0,0 @@
-require "test_helper"
-
-class TreeTest < Rugged::TestCase
-  include Rugged::RepositoryAccess
-
-  def setup
-    super
-    @oid = "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b"
-    @tree = @repo.lookup(@oid)
-  end
-
-  def test_read_tree_data
-    assert_equal @oid, @tree.oid
-    assert_equal :tree, @tree.type
-    assert_equal 3, @tree.count
-    assert_equal "1385f264afb75a56a5bec74243be9b367ba4ca08", @tree[0][:oid]
-    assert_equal "fa49b077972391ad58037050f2a75f74e3671e92", @tree[1][:oid]
-  end
-
-  def test_read_tree_entry_data
-    bent = @tree[0]
-    tent = @tree[2]
-
-    assert_equal "README", bent[:name]
-    assert_equal :blob, bent[:type]
-    # assert_equal 33188, bent.attributes
-
-    assert_equal "subdir", tent[:name]
-    assert_equal :tree, tent[:type]
-    assert_equal "619f9935957e010c419cb9d15621916ddfcc0b96", tent[:oid]
-    assert_equal :tree, @repo.lookup(tent[:oid]).type
-  end
-
-  def test_get_entry_by_oid
-    bent = @tree.get_entry_by_oid("1385f264afb75a56a5bec74243be9b367ba4ca08")
-    assert_equal "README", bent[:name]
-    assert_equal :blob, bent[:type]
-  end
-
-  def test_get_entry_by_oid_returns_nil_if_no_oid
-    nada = @tree.get_entry_by_oid("1385f264afb75a56a5bec74243be9b367ba4ca07")
-    assert_equal nil, nada
-  end
-
-  def test_get_entry_by_oid_throws_error_if_wrong_type
-    assert_raises TypeError do
-      @tree.get_entry_by_oid(:not_a_string)
-    end
-  end
-
-  def test_tree_iteration
-    enum_test = @tree.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:name] }.join(':')
-    assert_equal "README:subdir:new.txt", enum_test
-
-    enum = @tree.each
-    assert enum.kind_of? Enumerable
-  end
-
-  def test_tree_walk_only_trees
-    @tree.walk_trees {|root, entry| assert_equal :tree, entry[:type]}
-  end
-
-  def test_tree_walk_only_blobs
-    @tree.walk_blobs {|root, entry| assert_equal :blob, entry[:type]}
-  end
-
-  def test_iterate_subtrees
-    @tree.each_tree {|tree| assert_equal :tree, tree[:type]}
-  end
-
-  def test_iterate_subtree_blobs
-    @tree.each_blob {|tree| assert_equal :blob, tree[:type]}
-  end
-end
-
-class TreeWriteTest < Rugged::TestCase
-  include Rugged::TempRepositoryAccess
-
-  def test_write_tree_data
-    entry = {:type => :blob,
-             :name => "README.txt",
-             :oid  => "1385f264afb75a56a5bec74243be9b367ba4ca08",
-             :filemode => 33188}
-
-    builder = Rugged::Tree::Builder.new
-    builder << entry
-    sha = builder.write(@repo)
-    obj = @repo.lookup(sha)
-    assert_equal 38, obj.read_raw.len
-  end
-end