Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using NUnit.Framework;

using Newtonsoft.Json;

using Pithos.Network;

namespace Pithos.Core.Test

{

    [TestFixture]

    public class SignatureTest

    {

        [Test]

        public void TestCreate()

        {

            var hasher = HashAlgorithm.Create("sha256");

            Assert.IsNotNull(hasher);

        }

        [Test]

        public void TestHashmapCreation()

        {

            var file = "e:\\pithos\\vlc-1.1.11-win32.exe";

            decimal blockSize = 4*1024*1024;

            var fileSize = new FileInfo(file).Length;

            var numBlocks = decimal.Ceiling(fileSize/blockSize);

            var md5 = Signature.CalculateMD5(file);            

            var hash1 = Signature.CalculateTreeHashAsync(file, (int) blockSize,"sha256").Result;

            Assert.IsNotNull(hash1.Hashes);

            Assert.AreEqual(numBlocks, hash1.Hashes.Count());

            var topHash = hash1.TopHash;

            var hashString = BytesToStr(topHash);

            var stringHashes = (from hash in hash1.Hashes

                               select BytesToStr(hash)).ToList();

            var hashes = JsonConvert.SerializeObject(stringHashes);

            Assert.IsNotNull(topHash);

        }

        [Test]

        public void TestHashmapStorage()

        {

            var file = "e:\\pithos\\vlc-1.1.11-win32.exe";

            decimal blockSize = 4*1024*1024;

            var fileSize = new FileInfo(file).Length;

            var numBlocks = decimal.Ceiling(fileSize/blockSize);

            var md5 = Signature.CalculateMD5(file);

            var hash1 = Signature.CalculateTreeHashAsync(file, (int) blockSize, "sha256").Result;

            hash1.FileId = Guid.NewGuid();

            var task = hash1.Save(@"e:\")

                .ContinueWith(_ => TreeHash.LoadTreeHash(@"e:\", hash1.FileId)).Unwrap();            

            task.ContinueWith(t =>

            {                

                var hash = t.Result;

                Assert.AreEqual(hash1.Hashes, hash.Hashes.ToArray());

                int i = 0;

            }).Wait();

        }

        public static string BytesToStr(byte[] bytes)

        {

            var str = new StringBuilder();

            foreach (byte t in bytes)

                str.AppendFormat("{0:X2}", t);

            return str.ToString();

        }

        [Test]

        public void TestTopHashEmpty()

        {

            using (var hasher = HashAlgorithm.Create("sha256"))

            {

                var hashEmpty = hasher.ComputeHash(new byte[] {});                

                var empty = new List<byte[]>();

                var hash = Signature.CalculateTopHash(empty,"sha256");

                Assert.IsNull(hash);

            }

        }

        [Test]

        public void TestHashMapsEqual()

        {

            var account = "890329@vho.grnet.gr";

            var apiKey = "24989dce4e0fcb072f8cb60c8922be19";

            var client = new CloudFilesClient(account, apiKey);

            client.AuthenticationUrl = @"https://pithos.dev.grnet.gr";

            client.UsePithos = true;            

            client.Authenticate();

            var fileName = @"vlc-1.1.11-win32.exe";

            var localHash= Signature.CalculateTreeHashAsync(Path.Combine(@"e:\pithos\", fileName), 4 * 1024 * 1024, "sha256").Result;

            var upHash= client.GetHashMap(fileName, account, "pithos").Result;

            Assert.AreEqual(upHash.TopHash, localHash.TopHash);

            Assert.AreEqual(upHash.Hashes,localHash.Hashes);

        }

        [Test]

        public void TestAsyncEquivalence()

        {

            var fileName = @"vlc-1.1.11-win32.exe";

            var syncHash= Signature.CalculateTreeHash(Path.Combine(@"e:\pithos\", fileName), 4 * 1024 * 1024, "sha256");

            var asyncHash = Signature.CalculateTreeHashAsync(Path.Combine(@"e:\pithos\", fileName), 4 * 1024 * 1024, "sha256")

                .Result;

            Assert.AreEqual(syncHash.TopHash, asyncHash.TopHash);

            Assert.AreEqual(syncHash.Hashes,asyncHash.Hashes);

        }

    }

}