public void testRefsCacheAfterUpdate()
{
// Do not use the defalt repo for this case.
IDictionary <string, Core.Ref> allRefs = db.getAllRefs();
ObjectId oldValue = db.Resolve("HEAD");
ObjectId newValue = db.Resolve("HEAD^");
// first make HEAD refer to loose ref
RefUpdate updateRef = db.UpdateRef(Constants.HEAD);
updateRef.IsForceUpdate = true;
updateRef.NewObjectId = newValue;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update);
// now update that ref
updateRef = db.UpdateRef(Constants.HEAD);
updateRef.IsForceUpdate = true;
updateRef.NewObjectId = oldValue;
update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, update);
allRefs = db.getAllRefs();
Ref master = allRefs.GetValue("refs/heads/master");
Ref head = allRefs.GetValue("HEAD");
Assert.AreEqual("refs/heads/master", master.Name);
Assert.AreEqual("HEAD", head.Name);
Assert.IsTrue(head.isSymbolic(), "is symbolic reference");
Assert.AreSame(master, head.getTarget());
}
public void testNoCacheObjectIdSubclass()
{
string newRef = "refs/heads/abc";
RefUpdate ru = updateRef(newRef);
RevCommit newid = new RevCommit(ru.getNewObjectId())
{
// empty
};
ru.setNewObjectId(newid);
RefUpdate.RefUpdateResult update = ru.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update);
Core.Ref r = db.getAllRefs()[newRef];
Assert.IsNotNull(r);
Assert.AreEqual(newRef, r.Name);
Assert.IsNotNull(r.ObjectId);
Assert.AreNotSame(newid, r.ObjectId);
Assert.AreSame(typeof(ObjectId), r.ObjectId.GetType());
Assert.AreEqual(newid.Copy(), r.ObjectId);
IList <ReflogReader.Entry> reverseEntries1 = db.ReflogReader("refs/heads/abc").getReverseEntries();
ReflogReader.Entry entry1 = reverseEntries1[0];
Assert.AreEqual(1, reverseEntries1.Count);
Assert.AreEqual(ObjectId.ZeroId, entry1.getOldId());
Assert.AreEqual(r.ObjectId, entry1.getNewId());
Assert.AreEqual(new PersonIdent(db).ToString(), entry1.getWho().ToString());
Assert.AreEqual("", entry1.getComment());
IList <ReflogReader.Entry> reverseEntries2 = db.ReflogReader("HEAD").getReverseEntries();
Assert.AreEqual(0, reverseEntries2.Count);
}
public void testRenameRefNameColission1avoided()
{
// setup
ObjectId rb = db.Resolve("refs/heads/b");
writeSymref(Constants.HEAD, "refs/heads/a");
RefUpdate updateRef = db.UpdateRef("refs/heads/a");
updateRef.NewObjectId = rb;
updateRef.setRefLogMessage("Setup", false);
Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, updateRef.update());
ObjectId oldHead = db.Resolve(Constants.HEAD);
Assert.IsTrue(rb.Equals(oldHead)); // assumption for this test
writeReflog(db, rb, rb, "Just a message", "refs/heads/a");
Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/a")).Exists, "internal check, we have a log");
// Now this is our test
RefRename renameRef = db.RenameRef("refs/heads/a", "refs/heads/a/b");
RefUpdate.RefUpdateResult result = renameRef.rename();
Assert.AreEqual(RefUpdate.RefUpdateResult.RENAMED, result);
Assert.IsNull(db.Resolve("refs/heads/a"));
Assert.AreEqual(rb, db.Resolve("refs/heads/a/b"));
Assert.AreEqual(3, db.ReflogReader("a/b").getReverseEntries().Count);
Assert.AreEqual("Branch: renamed a to a/b", db.ReflogReader("a/b")
.getReverseEntries()[0].getComment());
Assert.AreEqual("Just a message", db.ReflogReader("a/b")
.getReverseEntries()[1].getComment());
Assert.AreEqual("Setup", db.ReflogReader("a/b").getReverseEntries()
[2].getComment());
// same thing was logged to HEAD
Assert.AreEqual("Branch: renamed a to a/b", db.ReflogReader("HEAD")
.getReverseEntries()[0].getComment());
}
public void testNewNamespaceConflictWithLoosePrefixOfExisting()
{
string newRef = "refs/heads/z/a";
RefUpdate ru = updateRef(newRef);
RevCommit newid = new RevCommit(ru.NewObjectId)
{
// empty
};
ru.NewObjectId = newid;
RefUpdate.RefUpdateResult update = ru.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update);
// end setup
string newRef2 = "refs/heads/z";
RefUpdate ru2 = updateRef(newRef2);
RevCommit newid2 = new RevCommit(ru2.NewObjectId)
{
// empty
};
ru.NewObjectId = newid2;
RefUpdate.RefUpdateResult update2 = ru2.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update2);
Assert.AreEqual(1, db.ReflogReader("refs/heads/z/a").getReverseEntries().Count);
Assert.IsNull(db.ReflogReader("refs/heads/z"));
Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count);
}
public void testUpdateRefDetachedUnbornHead()
{
ObjectId ppid = db.Resolve("refs/heads/master^");
writeSymref("HEAD", "refs/heads/unborn");
RefUpdate updateRef = db.UpdateRef("HEAD", true);
updateRef.IsForceUpdate = true;
updateRef.NewObjectId = ppid;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update);
Assert.AreEqual(ppid, db.Resolve("HEAD"));
Ref @ref = db.getRef("HEAD");
Assert.AreEqual("HEAD", @ref.Name);
Assert.IsTrue([email protected](), "is detached");
// the branch HEAD referred to is left untouched
Assert.IsNull(db.Resolve("refs/heads/unborn"));
ReflogReader reflogReader = new ReflogReader(db, "HEAD");
ReflogReader.Entry e = reflogReader.getReverseEntries()[0];
Assert.AreEqual(ObjectId.ZeroId, e.getOldId());
Assert.AreEqual(ppid, e.getNewId());
Assert.AreEqual("GIT_COMMITTER_EMAIL", e.getWho().EmailAddress);
Assert.AreEqual("GIT_COMMITTER_NAME", e.getWho().Name);
Assert.AreEqual(1250379778000L, e.getWho().When);
}
public virtual void testReadAllIncludingSymrefs()
{
ObjectId masterId = db.Resolve("refs/heads/master");
RefUpdate updateRef = db.UpdateRef("refs/remotes/origin/master");
updateRef.setNewObjectId(masterId);
updateRef.setForceUpdate(true);
updateRef.update();
writeSymref("refs/remotes/origin/HEAD", "refs/remotes/origin/master");
ObjectId r = db.Resolve("refs/remotes/origin/HEAD");
Assert.AreEqual(masterId, r);
IDictionary <string, global::GitSharp.Core.Ref> allRefs = db.getAllRefs();
global::GitSharp.Core.Ref refHEAD = allRefs["refs/remotes/origin/HEAD"];
Assert.IsNotNull(refHEAD);
Assert.AreEqual(masterId, refHEAD.ObjectId);
Assert.IsFalse(refHEAD.IsPeeled);
Assert.IsNull(refHEAD.PeeledObjectId);
global::GitSharp.Core.Ref refmaster = allRefs["refs/remotes/origin/master"];
Assert.AreEqual(masterId, refmaster.ObjectId);
Assert.IsFalse(refmaster.IsPeeled);
Assert.IsNull(refmaster.PeeledObjectId);
}
public void testLooseDelete()
{
string newRef = "refs/heads/abc";
RefUpdate @ref = updateRef(newRef);
@ref.update(); // create loose ref
@ref = updateRef(newRef); // refresh
delete(@ref, RefUpdate.RefUpdateResult.NO_CHANGE);
Assert.IsNull(db.ReflogReader("refs/heads/abc"));
}
public void testUpdateRefNoChange()
{
ObjectId pid = db.Resolve("refs/heads/master");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.NewObjectId = pid;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NO_CHANGE, update);
Assert.AreEqual(pid, db.Resolve("refs/heads/master"));
}
public void testReadLooseRef()
{
RefUpdate updateRef = db.UpdateRef("ref/heads/new");
updateRef.setNewObjectId(db.Resolve("refs/heads/master"));
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update);
global::GitSharp.Core.Ref @ref = db.getRef("ref/heads/new");
Assert.AreEqual(Storage.Loose, @ref.StorageFormat);
}
public void testDeleteLoosePackedRejected()
{
ObjectId pid = db.Resolve("refs/heads/c^");
ObjectId oldpid = db.Resolve("refs/heads/c");
RefUpdate updateRef = db.UpdateRef("refs/heads/c");
updateRef.NewObjectId = pid;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.REJECTED, update);
Assert.AreEqual(oldpid, db.Resolve("refs/heads/c"));
}
public void testUpdateRefLockFailureWrongOldValue()
{
ObjectId pid = db.Resolve("refs/heads/master");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.NewObjectId = pid;
updateRef.ExpectedOldObjectId = db.Resolve("refs/heads/master^");
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update);
Assert.AreEqual(pid, db.Resolve("refs/heads/master"));
}
public void testNewNamespaceConflictWithPackedPrefixOfExisting()
{
string newRef = "refs/heads/prefix";
RefUpdate ru = updateRef(newRef);
RevCommit newid = new RevCommit(ru.NewObjectId)
{
// empty
};
ru.NewObjectId = newid;
RefUpdate.RefUpdateResult update = ru.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update);
Assert.IsNull(db.ReflogReader("refs/heads/prefix"));
Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count);
}
public void testReadSimplePackedRefSameRepo()
{
global::GitSharp.Core.Ref @ref = db.getRef("refs/heads/master");
ObjectId pid = db.Resolve("refs/heads/master^");
Assert.AreEqual(Storage.Packed, @ref.StorageFormat);
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.setNewObjectId(pid);
updateRef.setForceUpdate(true);
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update);
@ref = db.getRef("refs/heads/master");
Assert.AreEqual(Storage.Loose, @ref.StorageFormat);
}
public void testReadSymRefToLoosePacked()
{
ObjectId pid = db.Resolve("refs/heads/master^");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.setNewObjectId(pid);
updateRef.setForceUpdate(true);
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // internal
writeSymref("HEAD", "refs/heads/master");
global::GitSharp.Core.Ref @ref = db.getRef("HEAD");
Assert.AreEqual(Storage.Loose, @ref.StorageFormat);
@ref = @ref.getTarget();
Assert.AreEqual("refs/heads/master", @ref.Name);
Assert.AreEqual(Storage.Loose, @ref.StorageFormat);
}
public void testDeleteHEADreferencedRef()
{
ObjectId pid = db.Resolve("refs/heads/master^");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.NewObjectId = pid;
updateRef.IsForceUpdate = true;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // internal
RefUpdate updateRef2 = db.UpdateRef("refs/heads/master");
RefUpdate.RefUpdateResult delete = updateRef2.delete();
Assert.AreEqual(RefUpdate.RefUpdateResult.REJECTED_CURRENT_BRANCH, delete);
Assert.AreEqual(pid, db.Resolve("refs/heads/master"));
Assert.AreEqual(1, db.ReflogReader("refs/heads/master").getReverseEntries().Count);
Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count);
}
public void testDeleteLoosePacked()
{
ObjectId pid = db.Resolve("refs/heads/c^");
RefUpdate updateRef = db.UpdateRef("refs/heads/c");
updateRef.NewObjectId = pid;
updateRef.IsForceUpdate = true;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // internal
// The real test here
RefUpdate updateRef2 = db.UpdateRef("refs/heads/c");
updateRef2.IsForceUpdate = true;
RefUpdate.RefUpdateResult delete = updateRef2.delete();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, delete);
Assert.IsNull(db.Resolve("refs/heads/c"));
}
public void testUpdateRefForward()
{
ObjectId ppid = db.Resolve("refs/heads/master^");
ObjectId pid = db.Resolve("refs/heads/master");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.NewObjectId = ppid;
updateRef.IsForceUpdate = true;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update);
Assert.AreEqual(ppid, db.Resolve("refs/heads/master"));
// real test
RefUpdate updateRef2 = db.UpdateRef("refs/heads/master");
updateRef2.NewObjectId = pid;
RefUpdate.RefUpdateResult update2 = updateRef2.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, update2);
Assert.AreEqual(pid, db.Resolve("refs/heads/master"));
}
public void testRenameBranchAlsoInPack()
{
ObjectId rb = db.Resolve("refs/heads/b");
ObjectId rb2 = db.Resolve("refs/heads/b~1");
Assert.AreEqual(Storage.Packed, db.getRef("refs/heads/b").StorageFormat);
RefUpdate updateRef = db.UpdateRef("refs/heads/b");
updateRef.NewObjectId = rb2;
updateRef.IsForceUpdate = true;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update, "internal check new ref is loose");
Assert.AreEqual(Storage.Loose, db.getRef("refs/heads/b").StorageFormat);
writeReflog(db, rb, rb, "Just a message", "refs/heads/b");
Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists, "log on old branch");
RefRename renameRef = db.RenameRef("refs/heads/b",
"refs/heads/new/name");
RefUpdate.RefUpdateResult result = renameRef.rename();
Assert.AreEqual(RefUpdate.RefUpdateResult.RENAMED, result);
Assert.AreEqual(rb2, db.Resolve("refs/heads/new/name"));
Assert.IsNull(db.Resolve("refs/heads/b"));
Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader(
"new/name").getLastEntry().getComment());
Assert.AreEqual(3, db.ReflogReader("refs/heads/new/name").getReverseEntries().Count);
Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader("refs/heads/new/name").getReverseEntries()[0].getComment());
Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count);
// make sure b's log file is gone too.
Assert.IsFalse(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists);
// Create new Repository instance, to reread caches and make sure our
// assumptions are persistent.
using (Core.Repository ndb = new Core.Repository(db.Directory))
{
Assert.AreEqual(rb2, ndb.Resolve("refs/heads/new/name"));
Assert.IsNull(ndb.Resolve("refs/heads/b"));
}
}
public void testUpdateRefLockFailureLocked()
{
ObjectId opid = db.Resolve("refs/heads/master");
ObjectId pid = db.Resolve("refs/heads/master^");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.NewObjectId = pid;
var lockFile1 = new LockFile(new FileInfo(Path.Combine(db.Directory.FullName, "refs/heads/master")));
try
{
Assert.IsTrue(lockFile1.Lock()); // precondition to test
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update);
Assert.AreEqual(opid, db.Resolve("refs/heads/master"));
var lockFile2 = new LockFile(new FileInfo(Path.Combine(db.Directory.FullName, "refs/heads/master")));
Assert.IsFalse(lockFile2.Lock()); // was locked, still is
}
finally
{
lockFile1.Unlock();
}
}
public void testUpdateRefForwardWithCheck2()
{
ObjectId ppid = db.Resolve("refs/heads/master^");
ObjectId pid = db.Resolve("refs/heads/master");
RefUpdate updateRef = db.UpdateRef("refs/heads/master");
updateRef.NewObjectId = ppid;
updateRef.IsForceUpdate = true;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update);
Assert.AreEqual(ppid, db.Resolve("refs/heads/master"));
// real test
RevCommit old = new Core.RevWalk.RevWalk(db).parseCommit(ppid);
RefUpdate updateRef2 = db.UpdateRef("refs/heads/master");
updateRef2.ExpectedOldObjectId = old;
updateRef2.NewObjectId = pid;
RefUpdate.RefUpdateResult update2 = updateRef2.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, update2);
Assert.AreEqual(pid, db.Resolve("refs/heads/master"));
}
public void testDeleteLooseAndItsDirectory()
{
ObjectId pid = db.Resolve("refs/heads/c^");
RefUpdate updateRef = db.UpdateRef("refs/heads/z/c");
updateRef.NewObjectId = pid;
updateRef.IsForceUpdate = true;
updateRef.setRefLogMessage("new test ref", false);
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); // internal
Assert.IsTrue(new DirectoryInfo(Path.Combine(db.Directory.FullName, Constants.R_HEADS + "z")).Exists);
Assert.IsTrue(new DirectoryInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/z")).Exists);
// The real test here
RefUpdate updateRef2 = db.UpdateRef("refs/heads/z/c");
updateRef2.IsForceUpdate = true;
RefUpdate.RefUpdateResult delete = updateRef2.delete();
Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, delete);
Assert.IsNull(db.Resolve("refs/heads/z/c"));
Assert.IsFalse(new DirectoryInfo(Path.Combine(db.Directory.FullName, Constants.R_HEADS + "z")).Exists);
Assert.IsFalse(new DirectoryInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/z")).Exists);
}
public void testRefsCacheAfterUpdateLooseOnly()
{
// Do not use the defalt repo for this case.
IDictionary <string, Core.Ref> allRefs = db.getAllRefs();
ObjectId oldValue = db.Resolve("HEAD");
writeSymref(Constants.HEAD, "refs/heads/newref");
RefUpdate updateRef = db.UpdateRef(Constants.HEAD);
updateRef.IsForceUpdate = true;
updateRef.NewObjectId = oldValue;
RefUpdate.RefUpdateResult update = updateRef.update();
Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update);
allRefs = db.getAllRefs();
Ref head = allRefs.GetValue("HEAD");
Ref newref = allRefs.GetValue("refs/heads/newref");
Assert.AreEqual("refs/heads/newref", newref.Name);
Assert.AreEqual("HEAD", head.Name);
Assert.IsTrue(head.isSymbolic(), "is symbolic reference");
Assert.AreSame(newref, head.getTarget());
}
private void Execute(ReceiveCommand cmd)
{
try
{
RefUpdate ru = db.UpdateRef(cmd.getRefName());
ru.setRefLogIdent(getRefLogIdent());
switch (cmd.getType())
{
case ReceiveCommand.Type.DELETE:
if (!ObjectId.ZeroId.Equals(cmd.getOldId()))
{
// We can only do a CAS style delete if the client
// didn't bork its delete request by sending the
// wrong zero id rather than the advertised one.
//
ru.setExpectedOldObjectId(cmd.getOldId());
}
ru.setForceUpdate(true);
Status(cmd, ru.delete(walk));
break;
case ReceiveCommand.Type.CREATE:
case ReceiveCommand.Type.UPDATE:
case ReceiveCommand.Type.UPDATE_NONFASTFORWARD:
ru.setForceUpdate(isAllowNonFastForwards());
ru.setExpectedOldObjectId(cmd.getOldId());
ru.setNewObjectId(cmd.getNewId());
ru.setRefLogMessage("push", true);
Status(cmd, ru.update(walk));
break;
}
}
catch (IOException err)
{
cmd.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON, "lock error: " + err.Message);
}
}
public void Update(RevWalk.RevWalk walk)
{
update.update(walk);
}
