Example #1
0
 public static ValueTask <Commit?> ReadCommitAsync(this IChasmRepository chasmRepository, CommitId?commitId, CancellationToken cancellationToken)
 {
     if (chasmRepository == null)
     {
         throw new ArgumentNullException(nameof(chasmRepository));
     }
     return(commitId.HasValue
         ? chasmRepository.ReadCommitAsync(commitId.Value, cancellationToken)
         : default);
Example #2
0
        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);