public void UpdateRef()
{
string @ref = Path.Join("HEAD");
string refPath = Path.Join("foo", ".ugit", @ref);
byte[] data = "foobar".Encode();
this.mockFileOperator.Setup(f => f.TryRead(refPath, out data)).Returns(true);
this.mockFileOperator.Setup(f => f.Write(refPath, It.IsAny <byte[]>()));
this.dataProvider.UpdateRef(@ref, RefValue.Create(false, "foo123bar"));
this.mockFileOperator.VerifyAll();
}
public void CreateCommitExceptionTest()
{
this.treeOperation.Setup(t => t.WriteTree()).Returns("tree-oid");
this.dataProvider.Setup(d => d.GetRef("HEAD", true)).Returns(RefValue.Create(false, ""));
this.treeOperation.Setup(d => d.GetTree("", "")).Returns(new Tree()
{
});
this.treeOperation.Setup(d => d.GetIndexTree()).Returns(new Tree()
{
});
_ = commitOperation.CreateCommit("hello foo");
}
public void AllTest()
{
string prefix = Path.Join("refs", "tags");
dataProviderMock.Setup(d => d.GetAllRefs(prefix, false)).Returns(new[] {
ValueTuple.Create(Path.Join(prefix, "v1.0"), RefValue.Create(false, "oid1")),
ValueTuple.Create(Path.Join(prefix, "v1.1"), RefValue.Create(false, "oid1.1")),
});
var tags = tagOperation.All.ToArray();
CollectionAssert.AreEqual(new string[] { "v1.0", "v1.1" }, tags);
}
/// <inheritdoc/>
public void Checkout(string name)
{
string oid = this.dataProvider.GetOid(name);
Commit commit = this.commitOperation.GetCommit(oid);
this.treeOperation.ReadTree(commit.Tree, true);
RefValue HEAD = this.branchOperation.IsBranch(name)
? RefValue.Create(true, Path.Join(Constants.Refs, Constants.Heads, name))
: RefValue.Create(false, oid);
this.dataProvider.UpdateRef(Constants.HEAD, HEAD, false);
}
/// <inheritdoc/>
public void UpdateRef(string @ref, RefValue value, bool deref = true)
{
if (string.IsNullOrWhiteSpace(value.Value))
{
throw new UgitException("ref value could be null or empty");
}
@ref = this.GetRefInternal(@ref, deref).Item1;
var val = value.Symbolic ? $"ref: {value.Value}" : value.Value;
string filePath = Path.Join(this.GitDirFullPath, @ref);
this.fileOperator.Write(filePath, val.Encode());
}
public void UpdateRefDeref()
{
string @ref = Path.Join("HEAD");
string headRefPath = Path.Join("foo", ".ugit", @ref);
byte[] headData = $"ref: {Path.Join("refs", "heads", "master")}".Encode();
string masterRefPath = Path.Join("foo", ".ugit", "refs", "heads", "master");
byte[] masterData = "foobar123".Encode();
this.mockFileOperator.Setup(f => f.TryRead(headRefPath, out headData)).Returns(true);
this.mockFileOperator.Setup(f => f.TryRead(masterRefPath, out masterData)).Returns(true);
this.mockFileOperator.Setup(f => f.Write(masterRefPath, It.IsAny <byte[]>()));
this.dataProvider.UpdateRef(@ref, RefValue.Create(false, "foo123bar"));
this.mockFileOperator.VerifyAll();
}
/// <inheritdoc/>
public void Merge(string other)
{
string head = this.dataProvider.GetRef("HEAD").Value;
var headCommit = this.commitOperation.GetCommit(head);
string mergeBase = this.GetMergeBase(other, head);
var otherCommit = this.commitOperation.GetCommit(other);
if (mergeBase == head)
{
this.treeOperation.ReadTree(otherCommit.Tree, true);
this.dataProvider.UpdateRef("HEAD", RefValue.Create(false, other));
Console.WriteLine("Fast-forwad, no need to commit");
return;
}
this.dataProvider.UpdateRef("MERGE_HEAD", RefValue.Create(false, other));
this.ReadTreeMerged(headCommit.Tree, otherCommit.Tree, true);
Console.WriteLine("Merged in working tree\nPlease commit");
}
/// <inheritdoc/>
public void Fetch()
{
var refs = this.remoteDataProvider.GetRefsMapping(RemoteRefsBase);
foreach (var oid in this.remoteCommitOperation.GetObjectHistory(refs.Values))
{
this.FetchObjectIfMissing(oid);
}
foreach (var entry in refs)
{
string remoteName = entry.Key;
string value = entry.Value;
string refName = Path.GetRelativePath(RemoteRefsBase, remoteName);
this.localDataProvider.UpdateRef(
Path.Join(LocalRefsBase, refName),
RefValue.Create(false, value));
}
}
private (string, RefValue) GetRefInternal(string @ref, bool deref)
{
var refPath = Path.Join(this.GitDirFullPath, @ref);
string value = null;
if (this.fileOperator.TryRead(refPath, out var data))
{
value = data.Decode();
}
bool symbolic = !string.IsNullOrWhiteSpace(value) && value.StartsWith("ref:");
if (symbolic)
{
value = value.Split(":")[1].Trim();
if (deref)
{
return(this.GetRefInternal(value, true));
}
}
return(ValueTuple.Create(@ref, RefValue.Create(symbolic, value)));
}
/// <inheritdoc/>
public void Push(string refName)
{
var remoteRefs = this.remoteDataProvider.GetRefsMapping(string.Empty);
remoteRefs.TryGetValue(refName, out string remoteRef);
string localRef = this.localDataProvider.GetRef(refName).Value;
if (!string.IsNullOrEmpty(remoteRef) && !this.IsAncestorOf(localRef, remoteRef))
{
throw new UgitException("Could not push");
}
IEnumerable <string> knowRemoteRefs = remoteRefs.Values.Where(oid => this.localDataProvider.ObjectExist(oid));
HashSet <string> remoteObjects = new HashSet <string>(this.localCommitOperation.GetObjectHistory(knowRemoteRefs));
HashSet <string> localObjects = new HashSet <string>(this.localCommitOperation.GetObjectHistory(new[] { localRef }));
IEnumerable <string> objectsToPush = localObjects.Except(remoteObjects);
foreach (var oid in objectsToPush)
{
this.PushObject(oid);
}
this.remoteDataProvider.UpdateRef(refName, RefValue.Create(false, localRef));
}
public void MergeTest()
{
dataProvider.Setup(d => d.GetRef("HEAD", true)).Returns(RefValue.Create(false, "head-tree-oid"));
commitOperation.Setup(c => c.GetCommit("head-tree-oid")).Returns(new Commit
{
Tree = "head-tree-oid",
});
commitOperation.Setup(c => c.GetCommit("other-oid")).Returns(new Commit
{
Tree = "other-tree-oid",
});
commitOperation.Setup(c => c.GetCommitHistory(It.IsAny <IEnumerable <string> >())).Returns <IEnumerable <string> >((oids) =>
{
if (oids.ToArray()[0] == "other-oid")
{
return(new string[] { "other-oid", "parent-oid" });
}
if (oids.ToArray()[0] == "head-tree-oid")
{
return(new string[] { "head-tree-oid", "parent-oid" });
}
return(Array.Empty <string>());
});
this.dataProvider.Setup(d => d.UpdateRef("MERGE_HEAD", It.Is <RefValue>(r => !r.Symbolic && r.Value == "other-oid"), true));
this.dataProvider.Setup(d => d.Index).Returns(new Tree());
this.treeOperation.Setup(d => d.GetTree("head-tree-oid", "")).Returns(
new Tree()
{
{ "foo.txt", "foo-oid" },
{ "bar.txt", "bar-oid" }
});
this.treeOperation.Setup(d => d.GetTree("other-tree-oid", "")).Returns(
new Tree()
{
{ "foo.txt", "foo-oid" },
});
this.diff.Setup(d => d.MergeTree(It.IsAny <Tree>(),
It.IsAny <Tree>())).Returns <Tree, Tree>((tree1, tree2) =>
{
if (tree1.Count == 2 &&
tree1.ContainsKey("foo.txt") &&
tree1.ContainsKey("bar.txt") &&
tree2.Count == 1 &&
tree2.ContainsKey("foo.txt"))
{
return(new Tree()
{
{ "foo.txt", "foo-oid" },
{ "bar.txt", "bar-oid" }
});
}
throw new Exception();
});
mergeOperation.Merge("other-oid");
dataProvider.VerifyAll();
treeOperation.VerifyAll();
commitOperation.VerifyAll();
diff.VerifyAll();
}
/// <inheritdoc/>
public void Init()
{
this.dataProvider.Init();
this.dataProvider.UpdateRef(Constants.HEAD, RefValue.Create(true, Path.Join(Constants.Refs, Constants.Heads, Constants.Master)));
}
/// <inheritdoc/>
public void Create(string name, string oid)
{
string @ref = Path.Join(Constants.Refs, Constants.Heads, name);
this.dataProvider.UpdateRef(@ref, RefValue.Create(false, oid));
}
/// <inheritdoc/>
public void Reset(string oid)
{
this.dataProvider.UpdateRef(Constants.HEAD, RefValue.Create(false, oid));
}
