rugged 0.17.0.b7 → 0.18.0.b1

data/test/note_test.rb

@@ -0,0 +1,158 @@
+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 +1,40 @@
 require "test_helper"
 require 'base64'
 
-context "Rugged::Object stuff" do
-  setup do
-    @path = File.dirname(__FILE__) + '/fixtures/testrepo.git/'
-    @repo = Rugged::Repository.new(@path)
-  end
+class ObjectTest < Rugged::TestCase
+  include Rugged::RepositoryAccess
 
-  test "cannot lookup a non-existant object" do
+  def test_fail_to_lookup_inexistant_object
     assert_raises Rugged::OdbError do
       @repo.lookup("a496071c1b46c854b31185ea97743be6a8774479")
     end
   end
 
-  test "can lookup an object" do
+  def test_lookup_object
     obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
     assert_equal :commit, obj.type
     assert_equal '8496071c1b46c854b31185ea97743be6a8774479', obj.oid
   end
 
-  test "same looked up objects are the same" do
+  def test_objects_are_the_same
     obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
     obj2 = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
     assert_equal obj, obj2
   end
 
-  test "can read raw data from an object" do
+  def test_read_raw_data
     obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
     assert obj.read_raw
   end
 
-  test "can lookup an object by revision string" do
+  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
 
-  test "can lookup just an object's oid by revision string" do
+  def test_lookup_oid_by_rev
     oid = @repo.rev_parse_oid("v1.0")
     assert "0c37a5391bbff43c37f0d0371823a5509eed5b1d", oid
     @repo.rev_parse_oid("v1.0^1")

data/test/reference_test.rb

@@ -1,63 +1,49 @@
 # encoding: UTF-8
 require File.expand_path "../test_helper", __FILE__
 
-context "Rugged::Reference stuff" do
-  UNICODE_REF_NAME = "A\314\212ngstro\314\210m"
-
-  setup do
-    @path = File.dirname(__FILE__) + '/fixtures/testrepo.git'
-    @repo = Rugged::Repository.new(@path)
-  end
+class ReferenceTest < Rugged::TestCase
+  include Rugged::RepositoryAccess
 
-  teardown do
-    FileUtils.remove_entry_secure(@path + '/refs/heads/unit_test', true)
-    FileUtils.remove_entry_secure(@path + "/refs/heads/#{UNICODE_REF_NAME}", true)
-  end
-
-  test "can list references" do
-    refs = @repo.refs.map { |r| r.name.gsub("refs/", '') }.sort.join(':')
-    assert_equal "heads/master:heads/packed:tags/v0.9:tags/v1.0", refs
-  end
+  UNICODE_REF_NAME = "A\314\212ngstro\314\210m"
 
-  test "can list references with non 7-bit ASCII characters" do
-    Rugged::Reference.create(@repo, "refs/heads/#{UNICODE_REF_NAME}", "refs/heads/master")
+  def test_list_references
     refs = @repo.refs.map { |r| r.name.gsub("refs/", '') }.sort.join(':')
-    assert_equal "heads/#{UNICODE_REF_NAME}:heads/master:heads/packed:tags/v0.9:tags/v1.0", refs
+    assert_equal "heads/master:heads/packed:notes/commits:tags/v0.9:tags/v1.0", refs
   end
 
-  test "can list filtered references from regex" do
+  def test_can_filter_refs_with_regex
     refs = @repo.refs(/tags/).map { |r| r.name.gsub("refs/", '') }.sort.join(':')
     assert_equal "tags/v0.9:tags/v1.0", refs
   end
 
-  test "can list filtered references from string" do
+  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
 
-  test "can open reference" do
+  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
   end
 
-  test "will return nil for an invalid reference" do
+  def test_looking_up_missing_ref_returns_nil
     ref = Rugged::Reference.lookup(@repo, "lol/wut")
     assert_equal nil, ref
   end
 
-  test "can get a reflog" do
+  def test_load_reflog
     ref = Rugged::Reference.lookup(@repo, "refs/heads/master")
     log = ref.log
     e =  log[1]
-    assert_equal e[:oid_old], "8496071c1b46c854b31185ea97743be6a8774479"
-    assert_equal e[:oid_new], "5b5b025afb0b4c913b4c338a42934a3863bf3644"
+    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
 
-  test "can check for the existence of a reference" do
+  def test_reference_exists
     exists = Rugged::Reference.exist?(@repo, "refs/heads/master")
     assert exists
 
@@ -65,14 +51,37 @@ context "Rugged::Reference stuff" do
     assert !exists
   end
 
-  test "can open packed reference" do
+  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
 
-  test "can create reference from symbolic reference" do
+  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
+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
@@ -80,101 +89,84 @@ context "Rugged::Reference stuff" do
     ref.delete!
   end
 
-  test "can create reference from oid" do
-    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "36060c58702ed4c2a40832c51758d5344201d89a")
+  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
 
-  test "can rename ref" do
-    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "36060c58702ed4c2a40832c51758d5344201d89a")
+  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
 
-    ref.rename "refs/heads/rug_new_name"
-    assert_equal "refs/heads/rug_new_name", ref.name
-    ref.delete!
+    new_ref = ref.rename "refs/heads/rug_new_name"
+    assert_equal "refs/heads/rug_new_name", new_ref.name
+    new_ref.delete!
   end
 
-  test "can set target on reference" do
-    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "36060c58702ed4c2a40832c51758d5344201d89a")
+  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
 
-    ref.target = "5b5b025afb0b4c913b4c338a42934a3863bf3644"
-    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", ref.target
-    ref.delete!
+    new_ref = ref.set_target "5b5b025afb0b4c913b4c338a42934a3863bf3644"
+    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", new_ref.target
+    new_ref.delete!
   end
 
-  test "can resolve head" do
-    ref = Rugged::Reference.lookup(@repo, "HEAD")
-    assert_equal "refs/heads/master", ref.target
-    assert_equal :symbolic, ref.type
+  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")
 
-    head = ref.resolve
-    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", head.target
-    assert_equal :direct, head.type
+    assert_equal "refs/heads/Ångström", ref1.name
+    assert_equal "refs/heads/Ångström", ref2.target
   end
 end
 
-context "Rugged::Reference#name" do
-  setup do
-    @path = temp_repo 'testrepo.git'
-    @repo = Rugged::Repository.new(@path)
-  end
+class ReflogTest < Rugged::TestCase
+  include Rugged::TempRepositoryAccess
 
-  it "returns the reference name with UTF-8 encoding" do
-    ref = Rugged::Reference.create(@repo, "refs/heads/Ångström", "refs/heads/master")
-    assert_equal "refs/heads/Ångström", ref.name
+  def setup
+    super
+    @ref = Rugged::Reference.create(@repo,
+      "refs/heads/test-reflog",
+      "36060c58702ed4c2a40832c51758d5344201d89a")
   end
-end
 
-context "Rugged::Reference#target" do
-  setup do
-    @path = temp_repo 'testrepo.git'
-    @repo = Rugged::Repository.new(@path)
-  end
-
-  it "returns the reference target name with UTF-8 encoding" do
-    Rugged::Reference.create(@repo, "refs/heads/Ångström", "refs/heads/master")
-
-    ref = Rugged::Reference.create(@repo, "refs/heads/foobar", "refs/heads/Ångström")
-    assert_equal "refs/heads/Ångström", ref.target
-  end
-end
-
-context "Rugged::Reference#log!" do
-  setup do
-    @path = temp_repo 'testrepo.git'
-    @repo = Rugged::Repository.new(@path)
-
-    @ref = Rugged::Reference.create(@repo, "refs/heads/test-reflog", "36060c58702ed4c2a40832c51758d5344201d89a")
-  end
-
-  it "creates reflog entries" do
+  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][:oid_old], "0000000000000000000000000000000000000000"
-    assert_equal reflog[0][:oid_new], "36060c58702ed4c2a40832c51758d5344201d89a"
+    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][:oid_old], "36060c58702ed4c2a40832c51758d5344201d89a"
-    assert_equal reflog[1][:oid_new], "36060c58702ed4c2a40832c51758d5344201d89a"
+    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
+