public static void ChasmSerializer_Roundtrip_TreeNodeMap_Default(IChasmSerializer ser)
{
TreeNodeMap expected = default;
using (var buf = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(buf.Result);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_Roundtrip_TreeNodeMap_2_Nodes(IChasmSerializer ser)
{
var expected = new TreeNodeMap(s_node1, s_node2);
using (IMemoryOwner <byte> owner = ser.Serialize(expected))
{
TreeNodeMap actual = ser.DeserializeTree(owner.Memory.Span);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_Roundtrip_TreeNodeMap_Default(IChasmSerializer ser)
{
TreeNodeMap expected = default;
using (IMemoryOwner <byte> owner = ser.Serialize(expected))
{
TreeNodeMap actual = ser.DeserializeTree(owner.Memory.Span);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_Roundtrip_TreeNodeMap_Null(IChasmSerializer ser)
{
var expected = new TreeNodeMap(null);
using (var buf = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(buf.Result);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_WriteRead_EmptyTreeNodeMap(IChasmSerializer ser)
{
var expected = new TreeNodeMap(new TreeNode[0]);
using (var seg = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(seg.Result);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_WriteRead_EmptyTreeNodeMap(IChasmSerializer ser)
{
var expected = new TreeNodeMap(new TreeNode[0]);
using (IMemoryOwner <byte> owner = ser.Serialize(expected))
{
TreeNodeMap actual = ser.DeserializeTree(owner.Memory.Span);
Assert.Equal(expected, actual);
}
}
public static TreeNodeMap ReadTreeNodeMap(this JsonReader jr)
{
if (jr == null)
{
throw new ArgumentNullException(nameof(jr));
}
var list = jr.ReadArray(() => jr.ReadTreeNode());
var tree = new TreeNodeMap(list);
return(tree);
}
public static void ChasmSerializer_WriteRead_TreeNodeMap(IChasmSerializer ser)
{
var node0 = new TreeNode("a", NodeKind.Blob, Sha1.Hash("abc"));
var node1 = new TreeNode("b", NodeKind.Tree, Sha1.Hash("def"));
var node2 = new TreeNode("c", NodeKind.Tree, Sha1.Hash("hij"));
var expected = new TreeNodeMap(node0, node1, node2);
using (var seg = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(seg.Result);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_WriteRead_TreeNodeMap(IChasmSerializer ser)
{
var node0 = new TreeNode("a", NodeKind.Blob, s_hasher.HashData("abc"));
var node1 = new TreeNode("b", NodeKind.Tree, s_hasher.HashData("def"));
var node2 = new TreeNode("c", NodeKind.Tree, s_hasher.HashData("hij"));
var expected = new TreeNodeMap(node0, node1, node2);
using (IMemoryOwner <byte> owner = ser.Serialize(expected))
{
TreeNodeMap actual = ser.DeserializeTree(owner.Memory.Span);
Assert.Equal(expected, actual);
}
}
public BufferSession Serialize(TreeNodeMap model)
{
var wire = model.Convert();
var maxLen = Encoding.UTF8.GetMaxByteCount(wire.Length); // Utf8 is 1-4 bpc
var rented = BufferSession.RentBuffer(maxLen);
var count = Encoding.UTF8.GetBytes(wire, 0, wire.Length, rented, 0);
var seg = new ArraySegment <byte>(rented, 0, count);
var session = new BufferSession(seg);
return(session);
}
private static void AssertEmpty(TreeNodeMap tree)
{
Assert.Empty(tree);
Assert.Equal(TreeNodeMap.Empty, tree); // By design
Assert.Equal(TreeNodeMap.Empty.GetHashCode(), tree.GetHashCode());
Assert.Empty(tree.Keys);
Assert.Throws <IndexOutOfRangeException>(() => tree[0]);
Assert.Throws <KeyNotFoundException>(() => tree["x"]);
Assert.False(tree.TryGetValue("x", out _));
Assert.False(tree.TryGetValue("x", NodeKind.Blob, out _));
Assert.False(tree.Equals(new object()));
Assert.Contains("Count: 0", tree.ToString());
Assert.Equal(-1, tree.IndexOf(Guid.NewGuid().ToString()));
}
public static TreeWire Convert(this TreeNodeMap model)
{
if (model.Count == 0)
{
return(new TreeWire());
}
var wire = new TreeWire();
for (var i = 0; i < model.Count; i++)
{
var node = model[i].Convert();
wire.Nodes.Add(node);
}
return(wire);
}
public BufferSession Serialize(TreeNodeMap model)
{
var wire = model.Convert();
var size = wire.CalculateSize();
var buffer = BufferSession.RentBuffer(size);
using (var cos = new CodedOutputStream(buffer))
{
wire.WriteTo(cos);
var segment = new ArraySegment <byte>(buffer, 0, (int)cos.Position);
var session = new BufferSession(buffer, segment);
return(session);
}
}
public static void TreeNodeMap_Empty()
{
var noData = new TreeNodeMap();
AssertEmpty(noData);
var nullData = new TreeNodeMap(null);
AssertEmpty(nullData);
var collData = new TreeNodeMap((IList <TreeNode>)null);
AssertEmpty(collData);
var emptyData = new TreeNodeMap(Array.Empty <TreeNode>());
AssertEmpty(emptyData);
Assert.Empty(TreeNodeMap.Empty);
Assert.Equal(default, TreeNodeMap.Empty);
public static string Convert(this TreeNodeMap model)
{
switch (model.Count)
{
case 0:
return(string.Empty);
case 1:
return(model[0].Convert());
default:
{
var sb = new StringBuilder();
for (int i = 0; i < model.Count; i++)
{
string text = model[i].Convert();
sb.AppendLine(text);
}
return(sb.ToString());
}
}
}
private static async Task TestRepository(IChasmRepository repository)
{
var g = Guid.NewGuid();
var data = g.ToByteArray();
var sha = Sha1.Hash(data);
// Unknown SHA
var usha = Sha1.Hash(Guid.NewGuid().ToByteArray());
var usha2 = Sha1.Hash(Guid.NewGuid().ToByteArray());
// Blob
await repository.WriteObjectAsync(sha, new ArraySegment <byte>(data), false, default);
var rdata = (await repository.ReadObjectAsync(sha, default));
Assert.True(rdata.HasValue);
Assert.Equal(16, rdata.Value.Length);
Assert.Equal(g, rdata.Value.Span.NonPortableCast <byte, Guid>()[0]);
var urdata = await repository.ReadObjectAsync(usha, default);
Assert.False(urdata.HasValue);
// Tree
var tree = new TreeNodeMap(
new TreeNode("firstItem", NodeKind.Blob, sha),
new TreeNode("secondItem", NodeKind.Blob, sha)
);
var treeId = await repository.WriteTreeAsync(tree, default);
var rtree = await repository.ReadTreeAsync(treeId, default);
Assert.True(rtree.HasValue);
Assert.Equal(tree, rtree.Value);
var urtree = await repository.ReadTreeAsync(new TreeId(usha), default);
Assert.False(urtree.HasValue);
// Commit
var commit = new Commit(
new CommitId?(),
treeId,
new Audit("User1", DateTimeOffset.UtcNow.AddDays(-1)),
new Audit("User2", DateTimeOffset.UtcNow),
"Initial commit"
);
var commitId = await repository.WriteCommitAsync(commit, default);
var rcommit = await repository.ReadCommitAsync(commitId, default);
Assert.True(rcommit.HasValue);
Assert.Equal(commit, rcommit);
var urcommit = await repository.ReadCommitAsync(new CommitId(usha), default);
Assert.False(urcommit.HasValue);
// CommitRef
var commitRefName = Guid.NewGuid().ToString("N");
var commitRef = new CommitRef("production", commitId);
await repository.WriteCommitRefAsync(null, commitRefName, commitRef, default);
var rcommitRef = await repository.ReadCommitRefAsync(commitRefName, commitRef.Branch, default);
Assert.True(rcommit.HasValue);
Assert.Equal(commitRef, rcommitRef);
var urcommitRef = await repository.ReadCommitRefAsync(commitRefName + "_", commitRef.Branch, default);
Assert.False(urcommit.HasValue);
await Assert.ThrowsAsync <ChasmConcurrencyException>(() =>
repository.WriteCommitRefAsync(null, commitRefName, new CommitRef("production", new CommitId(usha)), default));
await Assert.ThrowsAsync <ChasmConcurrencyException>(() =>
repository.WriteCommitRefAsync(new CommitId(usha2), commitRefName, new CommitRef("production", new CommitId(usha)), default));
await repository.WriteCommitRefAsync(null, commitRefName, new CommitRef("dev", commitId), default);
await repository.WriteCommitRefAsync(null, commitRefName, new CommitRef("staging", new CommitId(usha)), default);
await repository.WriteCommitRefAsync(null, commitRefName + "_1", new CommitRef("production", new CommitId(usha)), default);
var names = await repository.GetNamesAsync(default);
public IMemoryOwner <byte> Serialize(TreeNodeMap model)
{
string text = model.Convert();
return(GetBytes(text));
}
private static async Task TestRepository(IChasmRepository repository)
{
var g = Guid.NewGuid();
var cx = new ChasmRequestContext {
CorrelationId = Guid.NewGuid().ToString("D")
};
byte[] buffer = g.ToByteArray();
Sha1 sha = s_hasher.HashData(buffer);
// Unknown SHA
Sha1 usha1 = s_hasher.HashData(Guid.NewGuid().ToByteArray());
Sha1 usha2 = s_hasher.HashData(Guid.NewGuid().ToByteArray());
// Blob
var metadata = new ChasmMetadata("application/json", "file123.txt");
Sha1 sha2 = await repository.WriteObjectAsync(new ReadOnlyMemory <byte>(buffer), metadata, false, cx, default);
Assert.Equal(sha, sha2);
IChasmBlob rdata = await repository.ReadObjectAsync(sha, default);
Assert.True(rdata != null);
Assert.Equal(16, rdata.Content.Length);
Assert.Equal(g, new Guid(rdata.Content.ToArray()));
Assert.Equal("application/json", rdata.Metadata.ContentType);
Assert.Equal("file123.txt", rdata.Metadata.Filename);
IChasmBlob urdata = await repository.ReadObjectAsync(usha1, default);
Assert.False(urdata != null);
//
metadata = new ChasmMetadata("application/text", null);
sha2 = await repository.WriteObjectAsync(buffer, metadata, true, cx, default);
Assert.Equal(sha, sha2);
IChasmBlob cnt2 = await repository.ReadObjectAsync(sha2, default);
Assert.Equal(buffer, cnt2.Content.ToArray());
Assert.Equal("application/text", cnt2.Metadata.ContentType);
Assert.Null(cnt2.Metadata.Filename);
using (IChasmStream stream2 = await repository.ReadStreamAsync(sha2, cx, default))
using (var ms = new MemoryStream())
{
stream2.Content.CopyTo(ms);
Assert.Equal(buffer, ms.ToArray());
}
using (Stream stream2 = new MemoryStream(buffer))
{
sha2 = await repository.WriteObjectAsync(stream2, null, true, cx, default);
}
Assert.Equal(sha, sha2);
using (IChasmStream stream2 = await repository.ReadStreamAsync(sha2, cx, default))
using (var ms = new MemoryStream())
{
stream2.Content.CopyTo(ms);
Assert.Equal(buffer, ms.ToArray());
}
// Tree
var tree = new TreeNodeMap(
new TreeNode("firstItem", NodeKind.Blob, sha),
new TreeNode("secondItem", NodeKind.Blob, sha)
);
TreeId treeId = await repository.WriteTreeAsync(tree, cx, default);
TreeNodeMap?rtree = await repository.ReadTreeAsync(treeId, cx, default);
Assert.True(rtree.HasValue);
Assert.Equal(tree, rtree.Value);
TreeNodeMap?urtree = await repository.ReadTreeAsync(new TreeId(usha1), cx, default);
Assert.False(urtree.HasValue);
}
public IMemoryOwner <byte> Serialize(TreeNodeMap model)
{
string json = model.Write();
return(GetBytes(json));
}
public abstract BufferSession Serialize(TreeNodeMap model);
public IMemoryOwner <byte> Serialize(TreeNodeMap model) => s_pool.Rent(1);
