public virtual void TestRefsCacheAfterUpdate() { // Do not use the defalt repo for this case. IDictionary <string, 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.SetForceUpdate(true); updateRef.SetNewObjectId(newValue); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); // now update that ref updateRef = db.UpdateRef(Constants.HEAD); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(oldValue); update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update); allRefs = db.GetAllRefs(); Ref master = allRefs.Get("refs/heads/master"); Ref head = allRefs.Get("HEAD"); NUnit.Framework.Assert.AreEqual("refs/heads/master", master.GetName()); NUnit.Framework.Assert.AreEqual("HEAD", head.GetName()); NUnit.Framework.Assert.IsTrue(head.IsSymbolic(), "is symbolic reference"); NUnit.Framework.Assert.AreSame(master, head.GetTarget()); }
public virtual void Test028_LockPackedRef() { WriteTrashFile(".git/packed-refs", "7f822839a2fe9760f386cbbbcb3f92c5fe81def7 refs/heads/foobar" ); WriteTrashFile(".git/HEAD", "ref: refs/heads/foobar\n"); BUG_WorkAroundRacyGitIssues("packed-refs"); BUG_WorkAroundRacyGitIssues("HEAD"); ObjectId resolve = db.Resolve("HEAD"); NUnit.Framework.Assert.AreEqual("7f822839a2fe9760f386cbbbcb3f92c5fe81def7", resolve .Name); RefUpdate lockRef = db.UpdateRef("HEAD"); ObjectId newId = ObjectId.FromString("07f822839a2fe9760f386cbbbcb3f92c5fe81def"); lockRef.SetNewObjectId(newId); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, lockRef.ForceUpdate()); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "refs/heads/foobar").Exists ()); NUnit.Framework.Assert.AreEqual(newId, db.Resolve("refs/heads/foobar")); // Again. The ref already exists RefUpdate lockRef2 = db.UpdateRef("HEAD"); ObjectId newId2 = ObjectId.FromString("7f822839a2fe9760f386cbbbcb3f92c5fe81def7"); lockRef2.SetNewObjectId(newId2); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, lockRef2.ForceUpdate()); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "refs/heads/foobar").Exists ()); NUnit.Framework.Assert.AreEqual(newId2, db.Resolve("refs/heads/foobar")); }
public virtual void TestUpdateRefLockFailureLocked() { ObjectId opid = db.Resolve("refs/heads/master"); ObjectId pid = db.Resolve("refs/heads/master^"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); LockFile lockFile1 = new LockFile(new FilePath(db.Directory, "refs/heads/master") , db.FileSystem); try { NUnit.Framework.Assert.IsTrue(lockFile1.Lock()); // precondition to test RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.LOCK_FAILURE, update); NUnit.Framework.Assert.AreEqual(opid, db.Resolve("refs/heads/master")); LockFile lockFile2 = new LockFile(new FilePath(db.Directory, "refs/heads/master") , db.FileSystem); NUnit.Framework.Assert.IsFalse(lockFile2.Lock()); } finally { // was locked, still is lockFile1.Unlock(); } }
public virtual void DeleteMergedBranch_historyNotPruned() { RevCommit parent = tr.Commit().Create(); RevCommit b1Tip = tr.Branch("b1").Commit().Parent(parent).Add("x", "x").Create(); RevCommit b2Tip = tr.Branch("b2").Commit().Parent(parent).Add("y", "y").Create(); // merge b1Tip and b2Tip and update refs/heads/b1 to the merge commit Merger merger = ((ThreeWayMerger)MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.NewMerger(repo )); merger.Merge(b1Tip, b2Tip); NGit.Junit.CommitBuilder cb = tr.Commit(); cb.Parent(b1Tip).Parent(b2Tip); cb.SetTopLevelTree(merger.GetResultTreeId()); RevCommit mergeCommit = cb.Create(); RefUpdate u = repo.UpdateRef("refs/heads/b1"); u.SetNewObjectId(mergeCommit); u.Update(); RefUpdate update = repo.UpdateRef("refs/heads/b2"); update.SetForceUpdate(true); update.Delete(); gc.SetExpireAgeMillis(0); gc.Prune(Collections.EmptySet <ObjectId>()); NUnit.Framework.Assert.IsTrue(repo.HasObject(b2Tip)); }
public virtual void TestNoCacheObjectIdSubclass() { string newRef = "refs/heads/abc"; RefUpdate ru = UpdateRef(newRef); RefUpdateTest.SubclassedId newid = new RefUpdateTest.SubclassedId(ru.GetNewObjectId ()); ru.SetNewObjectId(newid); RefUpdate.Result update = ru.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); Ref r = db.GetAllRefs().Get(newRef); NUnit.Framework.Assert.IsNotNull(r); NUnit.Framework.Assert.AreEqual(newRef, r.GetName()); NUnit.Framework.Assert.IsNotNull(r.GetObjectId()); NUnit.Framework.Assert.AreNotSame(newid, r.GetObjectId()); NUnit.Framework.Assert.AreSame(typeof(ObjectId), r.GetObjectId().GetType()); NUnit.Framework.Assert.AreEqual(newid, r.GetObjectId()); IList <ReflogEntry> reverseEntries1 = db.GetReflogReader("refs/heads/abc").GetReverseEntries (); ReflogEntry entry1 = reverseEntries1[0]; NUnit.Framework.Assert.AreEqual(1, reverseEntries1.Count); NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, entry1.GetOldId()); NUnit.Framework.Assert.AreEqual(r.GetObjectId(), entry1.GetNewId()); NUnit.Framework.Assert.AreEqual(new PersonIdent(db).ToString(), entry1.GetWho().ToString ()); NUnit.Framework.Assert.AreEqual(string.Empty, entry1.GetComment()); IList <ReflogEntry> reverseEntries2 = db.GetReflogReader("HEAD").GetReverseEntries (); NUnit.Framework.Assert.AreEqual(0, reverseEntries2.Count); }
public virtual void TestDeleteLooseAndItsDirectory() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/z/c"); updateRef.SetNewObjectId(pid); updateRef.SetForceUpdate(true); updateRef.SetRefLogMessage("new test ref", false); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); // internal NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, Constants.R_HEADS + "z") .Exists()); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "logs/refs/heads/z").Exists ()); // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/z/c"); updateRef2.SetForceUpdate(true); RefUpdate.Result delete = updateRef2.Delete(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, delete); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/z/c")); NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, Constants.R_HEADS + "z" ).Exists()); NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, "logs/refs/heads/z").Exists ()); }
/// <exception cref="System.IO.IOException"></exception> private void CommitNoteMap(RevWalk walk, NoteMap map, RevCommit notesCommit, ObjectInserter inserter, string msg) { // commit the note NGit.CommitBuilder builder = new NGit.CommitBuilder(); builder.TreeId = map.WriteTree(inserter); builder.Author = new PersonIdent(repo); builder.Committer = builder.Author; builder.Message = msg; if (notesCommit != null) { builder.SetParentIds(notesCommit); } ObjectId commit = inserter.Insert(builder); inserter.Flush(); RefUpdate refUpdate = repo.UpdateRef(notesRef); if (notesCommit != null) { refUpdate.SetExpectedOldObjectId(notesCommit); } else { refUpdate.SetExpectedOldObjectId(ObjectId.ZeroId); } refUpdate.SetNewObjectId(commit); refUpdate.Update(walk); }
public virtual void TestMergeEmptyBranches() { Git git = new Git(db); git.Commit().SetMessage("initial commit").Call(); RefUpdate r = db.UpdateRef("refs/heads/side"); r.SetNewObjectId(db.Resolve(Constants.HEAD)); NUnit.Framework.Assert.AreEqual(r.ForceUpdate(), RefUpdate.Result.NEW); RevCommit second = git.Commit().SetMessage("second commit").SetCommitter(committer ).Call(); db.UpdateRef(Constants.HEAD).Link("refs/heads/side"); RevCommit firstSide = git.Commit().SetMessage("first side commit").SetAuthor(author ).Call(); Write(new FilePath(db.Directory, Constants.MERGE_HEAD), ObjectId.ToString(db.Resolve ("refs/heads/master"))); Write(new FilePath(db.Directory, Constants.MERGE_MSG), "merging"); RevCommit commit = git.Commit().Call(); RevCommit[] parents = commit.Parents; NUnit.Framework.Assert.AreEqual(parents[0], firstSide); NUnit.Framework.Assert.AreEqual(parents[1], second); NUnit.Framework.Assert.IsTrue(parents.Length == 2); }
/// <exception cref="System.IO.IOException"></exception> private RefUpdate UpdateRef(string name) { RefUpdate @ref = db.UpdateRef(name); @ref.SetNewObjectId(db.Resolve(Constants.HEAD)); return(@ref); }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.ConcurrentRefUpdateException"></exception> private void UpdateHead(StringBuilder refLogMessage, ObjectId newHeadId, ObjectId oldHeadID) { RefUpdate refUpdate = repo.UpdateRef(Constants.HEAD); refUpdate.SetNewObjectId(newHeadId); refUpdate.SetRefLogMessage(refLogMessage.ToString(), false); refUpdate.SetExpectedOldObjectId(oldHeadID); RefUpdate.Result rc = refUpdate.Update(); switch (rc) { case RefUpdate.Result.NEW: case RefUpdate.Result.FAST_FORWARD: { return; } case RefUpdate.Result.REJECTED: case RefUpdate.Result.LOCK_FAILURE: { throw new ConcurrentRefUpdateException(JGitText.Get().couldNotLockHEAD, refUpdate .GetRef(), rc); } default: { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().updatingRefFailed , Constants.HEAD, newHeadId.ToString(), rc)); } } }
/// <exception cref="System.IO.IOException"></exception> private void CreateBranch(ObjectId objectId, string branchName) { RefUpdate updateRef = db.UpdateRef(branchName); updateRef.SetNewObjectId(objectId); updateRef.Update(); }
private void UpdateRef(Ref stashRef, ObjectId newId) { try { RefUpdate update = CreateRefUpdate(stashRef); update.SetNewObjectId(newId); RefUpdate.Result result = update.Update(); switch (result) { case RefUpdate.Result.FORCED: case RefUpdate.Result.NEW: case RefUpdate.Result.NO_CHANGE: { return; } default: { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().updatingRefFailed , Constants.R_STASH, newId, result)); } } } catch (IOException e) { throw new JGitInternalException(JGitText.Get().stashDropFailed, e); } }
/// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> /// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="System.IO.IOException"></exception> private void Checkout(Repository repo, FetchResult result) { if (branch.StartsWith(Constants.R_HEADS)) { RefUpdate head = repo.UpdateRef(Constants.HEAD); head.DisableRefLog(); head.Link(branch); } Ref head_1 = result.GetAdvertisedRef(branch); if (head_1 == null || head_1.GetObjectId() == null) { return; } // throw exception? RevCommit commit = ParseCommit(repo, head_1); bool detached = !head_1.GetName().StartsWith(Constants.R_HEADS); RefUpdate u = repo.UpdateRef(Constants.HEAD, detached); u.SetNewObjectId(commit.Id); u.ForceUpdate(); if (!bare) { DirCache dc = repo.LockDirCache(); DirCacheCheckout co = new DirCacheCheckout(repo, dc, commit.Tree); co.Checkout(); } }
public virtual void MultipleStashedCommits() { Git git = Git.Wrap(db); WriteTrashFile("file.txt", "content"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit1 = git.Commit().SetMessage("create file").Call(); WriteTrashFile("file.txt", "content2"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit2 = git.Commit().SetMessage("edit file").Call(); RefUpdate create = db.UpdateRef(Constants.R_STASH); create.SetNewObjectId(commit1); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, create.Update()); RefUpdate update = db.UpdateRef(Constants.R_STASH); update.SetNewObjectId(commit2); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update.Update()); StashListCommand command = git.StashList(); ICollection <RevCommit> stashed = command.Call(); NUnit.Framework.Assert.IsNotNull(stashed); NUnit.Framework.Assert.AreEqual(2, stashed.Count); Iterator <RevCommit> iter = stashed.Iterator(); NUnit.Framework.Assert.AreEqual(commit2, iter.Next()); NUnit.Framework.Assert.AreEqual(commit1, iter.Next()); }
/// <exception cref="System.IO.IOException"></exception> private void CheckoutCommit(RevCommit commit) { try { RevCommit head = walk.ParseCommit(repo.Resolve(Constants.HEAD)); DirCacheCheckout dco = new DirCacheCheckout(repo, head.Tree, repo.LockDirCache(), commit.Tree); dco.SetFailOnConflict(true); dco.Checkout(); // update the HEAD RefUpdate refUpdate = repo.UpdateRef(Constants.HEAD, true); refUpdate.SetExpectedOldObjectId(head); refUpdate.SetNewObjectId(commit); RefUpdate.Result res = refUpdate.ForceUpdate(); switch (res) { case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.FORCED: { break; } default: { throw new IOException("Could not rewind to upstream commit"); } } } finally { walk.Release(); monitor.EndTask(); } }
public virtual void TestUpdateRefDetachedUnbornHead() { ObjectId ppid = db.Resolve("refs/heads/master^"); WriteSymref("HEAD", "refs/heads/unborn"); RefUpdate updateRef = db.UpdateRef("HEAD", true); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(ppid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); NUnit.Framework.Assert.AreEqual(ppid, db.Resolve("HEAD")); Ref @ref = db.GetRef("HEAD"); NUnit.Framework.Assert.AreEqual("HEAD", @ref.GetName()); NUnit.Framework.Assert.IsTrue([email protected](), "is detached"); // the branch HEAD referred to is left untouched NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/unborn")); ReflogReader reflogReader = new ReflogReader(db, "HEAD"); ReflogEntry e = reflogReader.GetReverseEntries()[0]; NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, e.GetOldId()); NUnit.Framework.Assert.AreEqual(ppid, e.GetNewId()); NUnit.Framework.Assert.AreEqual("GIT_COMMITTER_EMAIL", e.GetWho().GetEmailAddress ()); NUnit.Framework.Assert.AreEqual("GIT_COMMITTER_NAME", e.GetWho().GetName()); NUnit.Framework.Assert.AreEqual(1250379778000L, e.GetWho().GetWhen().GetTime()); }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> private RevCommit TryFastForward(string headName, RevCommit oldCommit, RevCommit newCommit) { bool tryRebase = false; foreach (RevCommit parentCommit in newCommit.Parents) { if (parentCommit.Equals(oldCommit)) { tryRebase = true; } } if (!tryRebase) { return(null); } CheckoutCommand co = new CheckoutCommand(repo); try { co.SetName(newCommit.Name).Call(); if (headName.StartsWith(Constants.R_HEADS)) { RefUpdate rup = repo.UpdateRef(headName); rup.SetExpectedOldObjectId(oldCommit); rup.SetNewObjectId(newCommit); rup.SetRefLogMessage("Fast-foward from " + oldCommit.Name + " to " + newCommit.Name , false); RefUpdate.Result res = rup.Update(walk); switch (res) { case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.FORCED: { break; } default: { throw new IOException("Could not fast-forward"); } } } return(newCommit); } catch (RefAlreadyExistsException e) { throw new JGitInternalException(e.Message, e); } catch (RefNotFoundException e) { throw new JGitInternalException(e.Message, e); } catch (InvalidRefNameException e) { throw new JGitInternalException(e.Message, e); } }
/// <exception cref="System.IO.IOException"></exception> internal TrackingRefUpdate(Repository db, string localName, string remoteName, bool forceUpdate, AnyObjectId nv, string msg) { this.remoteName = remoteName; update = db.UpdateRef(localName); update.SetForceUpdate(forceUpdate); update.SetNewObjectId(nv); update.SetRefLogMessage(msg, true); }
public virtual void TestDeleteForce() { RefUpdate @ref = db.UpdateRef("refs/heads/b"); @ref.SetNewObjectId(db.Resolve("refs/heads/a")); Delete(@ref, RefUpdate.Result.REJECTED, true, false); @ref.SetForceUpdate(true); Delete(@ref, RefUpdate.Result.FORCED); }
public virtual void TestUpdateRefNoChange() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NO_CHANGE, update); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
/// <summary>Construct remote ref update request by providing an update specification. /// </summary> /// <remarks> /// Construct remote ref update request by providing an update specification. /// Object is created with default /// <see cref="Status.NOT_ATTEMPTED">Status.NOT_ATTEMPTED</see> /// status and no /// message. /// </remarks> /// <param name="localDb">local repository to push from.</param> /// <param name="srcRef"> /// source revision to label srcId with. If null srcId.name() will /// be used instead. /// </param> /// <param name="srcId"> /// The new object that the caller wants remote ref to be after /// update. Use null or /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// for delete /// request. /// </param> /// <param name="remoteName"> /// full name of a remote ref to update, e.g. "refs/heads/master" /// (no wildcard, no short name). /// </param> /// <param name="forceUpdate"> /// true when caller want remote ref to be updated regardless /// whether it is fast-forward update (old object is ancestor of /// new object). /// </param> /// <param name="localName"> /// optional full name of a local stored tracking branch, to /// update after push, e.g. "refs/remotes/zawir/dirty" (no /// wildcard, no short name); null if no local tracking branch /// should be updated. /// </param> /// <param name="expectedOldObjectId"> /// optional object id that caller is expecting, requiring to be /// advertised by remote side before update; update will take /// place ONLY if remote side advertise exactly this expected id; /// null if caller doesn't care what object id remote side /// advertise. Use /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// when expecting no /// remote ref with this name. /// </param> /// <exception cref="System.IO.IOException"> /// when I/O error occurred during creating /// <see cref="TrackingRefUpdate">TrackingRefUpdate</see> /// for local tracking branch or srcRef /// can't be resolved to any object. /// </exception> /// <exception cref="System.ArgumentException">if some required parameter was null</exception> public RemoteRefUpdate(Repository localDb, string srcRef, ObjectId srcId, string remoteName, bool forceUpdate, string localName, ObjectId expectedOldObjectId) { if (remoteName == null) { throw new ArgumentException(JGitText.Get().remoteNameCantBeNull); } if (srcId == null && srcRef != null) { throw new IOException(MessageFormat.Format(JGitText.Get().sourceRefDoesntResolveToAnyObject , srcRef)); } if (srcRef != null) { this.srcRef = srcRef; } else { if (srcId != null && !srcId.Equals(ObjectId.ZeroId)) { this.srcRef = srcId.Name; } else { this.srcRef = null; } } if (srcId != null) { this.newObjectId = srcId; } else { this.newObjectId = ObjectId.ZeroId; } this.remoteName = remoteName; this.forceUpdate = forceUpdate; if (localName != null && localDb != null) { localUpdate = localDb.UpdateRef(localName); localUpdate.SetForceUpdate(true); localUpdate.SetRefLogMessage("push", true); localUpdate.SetNewObjectId(newObjectId); trackingRefUpdate = new TrackingRefUpdate(true, remoteName, localName, localUpdate .GetOldObjectId() != null ? localUpdate.GetOldObjectId() : ObjectId.ZeroId, newObjectId ); } else { trackingRefUpdate = null; } this.localDb = localDb; this.expectedOldObjectId = expectedOldObjectId; this.status = RemoteRefUpdate.Status.NOT_ATTEMPTED; }
public virtual void TestUpdateRefLockFailureWrongOldValue() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); updateRef.SetExpectedOldObjectId(db.Resolve("refs/heads/master^")); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.LOCK_FAILURE, update); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public virtual void TestDeleteLoosePackedRejected() { ObjectId pid = db.Resolve("refs/heads/c^"); ObjectId oldpid = db.Resolve("refs/heads/c"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.SetNewObjectId(pid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.REJECTED, update); NUnit.Framework.Assert.AreEqual(oldpid, db.Resolve("refs/heads/c")); }
public virtual void TestCreateFromLightweightTag() { RefUpdate rup = db.UpdateRef("refs/tags/V10"); rup.SetNewObjectId(initialCommit); rup.SetExpectedOldObjectId(ObjectId.ZeroId); rup.Update(); Ref branch = git.BranchCreate().SetName("FromLightweightTag").SetStartPoint("refs/tags/V10" ).Call(); NUnit.Framework.Assert.AreEqual(initialCommit.Id, branch.GetObjectId()); }
public override void SetUp() { base.SetUp(); RefUpdate createRemoteRefA = db.UpdateRef("refs/remotes/origin/remote-a"); createRemoteRefA.SetNewObjectId(db.Resolve("refs/heads/a")); createRemoteRefA.Update(); RefUpdate createRemoteRefB = db.UpdateRef("refs/remotes/origin/remote-b"); createRemoteRefB.SetNewObjectId(db.Resolve("refs/heads/b")); createRemoteRefB.Update(); formatter = new MergeMessageFormatter(); }
public virtual void RepositoryWithDifferentRevCheckedOutSubmodule() { ObjectId id = ObjectId.FromString("abcd1234abcd1234abcd1234abcd1234abcd1234"); string path = "sub"; DirCache cache = db.LockDirCache(); DirCacheEditor editor = cache.Editor(); editor.Add(new _PathEdit_317(id, path)); editor.Commit(); string url = "git://server/repo.git"; StoredConfig config = ((FileBasedConfig)db.GetConfig()); config.SetString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path, ConfigConstants. CONFIG_KEY_URL, url); config.Save(); FileBasedConfig modulesConfig = new FileBasedConfig(new FilePath(db.WorkTree, Constants .DOT_GIT_MODULES), db.FileSystem); modulesConfig.SetString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path, ConfigConstants .CONFIG_KEY_PATH, path); modulesConfig.SetString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path, ConfigConstants .CONFIG_KEY_URL, url); modulesConfig.Save(); Repository subRepo = Git.Init().SetBare(false).SetDirectory(new FilePath(db.WorkTree , path)).Call().GetRepository(); NUnit.Framework.Assert.IsNotNull(subRepo); RefUpdate update = subRepo.UpdateRef(Constants.HEAD, true); update.SetNewObjectId(ObjectId.FromString("aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000" )); update.ForceUpdate(); SubmoduleStatusCommand command = new SubmoduleStatusCommand(db); IDictionary <string, SubmoduleStatus> statuses = command.Call(); NUnit.Framework.Assert.IsNotNull(statuses); NUnit.Framework.Assert.AreEqual(1, statuses.Count); KeyValuePair <string, SubmoduleStatus> module = statuses.EntrySet().Iterator().Next (); NUnit.Framework.Assert.IsNotNull(module); NUnit.Framework.Assert.AreEqual(path, module.Key); SubmoduleStatus status = module.Value; NUnit.Framework.Assert.IsNotNull(status); NUnit.Framework.Assert.AreEqual(path, status.GetPath()); NUnit.Framework.Assert.AreEqual(id, status.GetIndexId()); NUnit.Framework.Assert.AreEqual(update.GetNewObjectId(), status.GetHeadId()); NUnit.Framework.Assert.AreEqual(SubmoduleStatusType.REV_CHECKED_OUT, status.GetType ()); }
/// <exception cref="System.Exception"></exception> private Git SetUpRepoWithRemote() { Repository remoteRepository = CreateWorkRepository(); Git remoteGit = new Git(remoteRepository); // commit something WriteTrashFile("Test.txt", "Hello world"); remoteGit.Add().AddFilepattern("Test.txt").Call(); initialCommit = remoteGit.Commit().SetMessage("Initial commit").Call(); WriteTrashFile("Test.txt", "Some change"); remoteGit.Add().AddFilepattern("Test.txt").Call(); secondCommit = remoteGit.Commit().SetMessage("Second commit").Call(); // create a master branch RefUpdate rup = remoteRepository.UpdateRef("refs/heads/master"); rup.SetNewObjectId(initialCommit.Id); rup.ForceUpdate(); Repository localRepository = CreateWorkRepository(); Git localGit = new Git(localRepository); StoredConfig config = localRepository.GetConfig(); RemoteConfig rc = new RemoteConfig(config, "origin"); rc.AddURI(new URIish(remoteRepository.Directory.GetPath())); rc.AddFetchRefSpec(new RefSpec("+refs/heads/*:refs/remotes/origin/*")); rc.Update(config); config.Save(); FetchResult res = localGit.Fetch().SetRemote("origin").Call(); NUnit.Framework.Assert.IsFalse(res.GetTrackingRefUpdates().IsEmpty()); rup = localRepository.UpdateRef("refs/heads/master"); rup.SetNewObjectId(initialCommit.Id); rup.ForceUpdate(); rup = localRepository.UpdateRef(Constants.HEAD); rup.Link("refs/heads/master"); rup.SetNewObjectId(initialCommit.Id); rup.Update(); return(localGit); }
/// <exception cref="System.InvalidOperationException"></exception> /// <exception cref="System.IO.IOException"></exception> private void CheckoutCommit(RevCommit commit) { RevWalk walk = new RevWalk(db); RevCommit head = walk.ParseCommit(db.Resolve(Constants.HEAD)); DirCacheCheckout dco = new DirCacheCheckout(db, head.Tree, db.LockDirCache(), commit .Tree); dco.SetFailOnConflict(true); dco.Checkout(); walk.Release(); // update the HEAD RefUpdate refUpdate = db.UpdateRef(Constants.HEAD, true); refUpdate.SetNewObjectId(commit); refUpdate.ForceUpdate(); }
public virtual void SingleStashedCommit() { Git git = Git.Wrap(db); WriteTrashFile("file.txt", "content"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit = git.Commit().SetMessage("create file").Call(); RefUpdate update = db.UpdateRef(Constants.R_STASH); update.SetNewObjectId(commit); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update.Update()); StashListCommand command = git.StashList(); ICollection <RevCommit> stashed = command.Call(); NUnit.Framework.Assert.IsNotNull(stashed); NUnit.Framework.Assert.AreEqual(1, stashed.Count); NUnit.Framework.Assert.AreEqual(commit, stashed.Iterator().Next()); }
public virtual void TestDeleteLoosePacked() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.SetNewObjectId(pid); updateRef.SetForceUpdate(true); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); // internal // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/c"); updateRef2.SetForceUpdate(true); RefUpdate.Result delete = updateRef2.Delete(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, delete); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/c")); }