Synnefo » Pithos MS Client

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Diagnostics;

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", 2).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", 2).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());

            }).Wait();

        }

        [Test]

        public void TestLargeHashCalculation()

        {

            var file = "e:\\testFile.tmp";

            if (!File.Exists(file))

            {

                byte[] buffer= new byte[300 * 1048576];

                Random rnd=new Random();

                rnd.NextBytes(buffer);                

                //Create a 100MB buffer

                File.WriteAllBytes(file,buffer);                

            }

            decimal blockSize = 4 * 1048576;

            Trace.WriteLine("1");

            var stopwatch = Stopwatch.StartNew();            

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

            stopwatch.Stop();

            Trace.WriteLine(stopwatch.Elapsed);

            Trace.WriteLine("2");

            stopwatch.Restart();            

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

            stopwatch.Stop();

            Trace.WriteLine(stopwatch.Elapsed);

            Trace.WriteLine("3");

            stopwatch.Restart();

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

            stopwatch.Stop();

            Trace.WriteLine(stopwatch.Elapsed);

            Assert.That(hash3.TopHash,Is.EquivalentTo(hash2.TopHash));

        }

        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", 2).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", 2)

                .Result;

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

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

        }

    }

}