storageTests

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using Messages;
using NUnit.Framework;
using Services;
using Test.SampleNamespace;
using TransactionStorage;
using System.Linq;

namespace Test {
  [TestFixture]
  public class TestStorage {
    [Test]
    public void SerializeObjectToXML()
    {
      var testEvent = new SampleEvent { GUID = new IdentityGenerator().GetNewComb().ToString(), NewDescription = "example description" };
      var filename = GetFilename(testEvent.GUID);
      Assert.IsFalse(File.Exists(filename));
      Storage.Add(testEvent);
      Assert.IsTrue(File.Exists(filename));
      Assert.IsTrue(File.ReadAllText(filename).IndexOf("example") > 0);
    }
    [Test]
    public void SerializeACoupleOfEvents()
    {
      var testEvent = new SampleEvent { GUID = new IdentityGenerator().GetNewComb(), NewDescription = "example description" };
      var testEvent2 = new SampleEvent { GUID = testEvent.GUID, NewDescription = "description for the next one" };
      var filename = GetFilename(testEvent.GUID);
      Assert.IsFalse(File.Exists(filename));
      Storage.Add(testEvent);
      Storage.Add(testEvent2);
      Assert.IsTrue(File.Exists(filename));
      Assert.IsTrue(File.ReadAllText(filename).IndexOf("example") > 0);
      Assert.IsTrue(File.ReadAllText(filename).IndexOf("next") > 0);
    }
    [Test]
    public void EnsureXMLDoesNotHaveExcessJunkInIt() {
      var sampleEvent = new SampleEvent { GUID = new IdentityGenerator().GetNewComb(), NewDescription = "example description" };
      var testEvent = sampleEvent;
      var filename = GetFilename(sampleEvent.GUID);
      Assert.IsFalse(File.Exists(filename));
      Storage.Add(testEvent);
      Assert.IsTrue(File.Exists(filename));
      Assert.IsTrue(File.ReadAllText(filename).IndexOf("xmlns:") == -1);
      Assert.IsTrue(File.ReadAllText(filename).IndexOf("?") == -1);
    }
    [Test]
    public void EnsureTypeInformationIsProvided() {
      var id = new IdentityGenerator().GetNewComb();
      var testEvent = new SampleEvent { GUID = id, NewDescription = "example description" };
      var filename = GetFilename(id);
      Assert.IsFalse(File.Exists(filename));
      Storage.Add(testEvent);
      Assert.IsTrue(File.Exists(filename));
      Assert.IsTrue(File.ReadAllText(filename).IndexOf("SampleNamespace") > 0);
    }
    [Test]
    public void EnsureEventsCanBeRetrieved()
    {
      var testEvent = new SampleEvent { GUID = new IdentityGenerator().GetNewComb(), NewDescription = "example description" };
      var testEvent2 = new SampleEvent { GUID = testEvent.GUID, NewDescription = "description for the next one" };
      Storage.Add(testEvent);
      Storage.Add(testEvent2);
      var events = Storage.RetrieveFor(testEvent.GUID).ToArray();
      Assert.IsTrue(testEvent.NewDescription == ((SampleEvent)events[0]).NewDescription);
      Assert.IsTrue(testEvent2.NewDescription == ((SampleEvent)events[1]).NewDescription);
    }

    private static string GetFilename(string id)
    {
      var s = id.Aggregate("",(x,y)=>y+x);
      return "storage" + Path.DirectorySeparatorChar + s.Substring(0, 2) + Path.DirectorySeparatorChar + s.Substring(2, s.Length - 2) + ".history";
    }

    [Test]
    public void CheckGUIDOrder()
    {
      ShowByteSignificanceOrder(new Guid().ToByteArray().Length, list => new Guid(list.ToArray()));
      ShowByteSignificanceOrder(sizeof(int), list => BitConverter.ToInt32(list.ToArray(), 0));
      ShowByteSignificanceOrder(sizeof(long), list => BitConverter.ToInt64(list.ToArray(), 0));
    }

    private static void ShowByteSignificanceOrder<T>(int length, Func<List<byte>, T> keySelector)
    {
      var types = new List<List<byte>>();
      for (var i = 0; i < length; i++)
      {
        var list = new List<byte>();
        for (var j = 0; j < length; j++)
        {
          list.Add((byte)(i==j?1:0));
        }
        types.Add(list);
      }
      types.OrderByDescending(keySelector).ToList()
        .ForEach(list => { list.ForEach(x => Console.Write("{0} ", x==1?"1":".")); Console.WriteLine();});
      Console.Out.WriteLine();
    }

    [Test]
    public void CheckOrderOfComb()
    {
      var baseDate = new DateTime(1900, 1, 1);
      var now = DateTime.Now;

      // Get the days and milliseconds which will be used to build the byte string 
      var days = new TimeSpan(now.Ticks - baseDate.Ticks);
      var msecs = now.Date.Subtract(new TimeSpan(0,0,0,1)).TimeOfDay;
      
      var daysArray = BitConverter.GetBytes(days.Days - 1);
      var msecsArray = BitConverter.GetBytes((long)(msecs.TotalMilliseconds));

      Console.Out.Write("days: "); daysArray.ToList().ForEach(x => Console.Write("{0} ", x)); Console.WriteLine();
      Console.Out.Write("msec: "); msecsArray.ToList().ForEach(x => Console.Write("{0} ", x)); Console.WriteLine();

      Console.Out.WriteLine();

      for (int i = 0; i < 20; i++) {
        var comb1 = new IdentityGenerator().GetNewComb();
        Console.Out.WriteLine(comb1);
        Thread.Sleep(100);
        var comb2 = new IdentityGenerator().GetNewComb();
        Console.Out.WriteLine(comb2);
        Assert.IsTrue(comb1.CompareTo(comb2) < 0);
        Assert.Less(comb1, comb2);
      }
    }
    [Test]
    public void EventsCanBeReplayedInOrder()
    {
      var id = new IdentityGenerator().GetNewComb();
      var id2 = new IdentityGenerator().GetNewComb();
      var testEvent = new SampleEvent { GUID = id, NewDescription = "example description" };
      var testEvent2 = new SampleEvent { GUID = id2, NewDescription = "description for the next one" };
      var testEvent3 = new SampleEvent { GUID = id, NewDescription = "description for the last one" };
      Storage.Add(testEvent);
      Storage.Add(testEvent2);
      Storage.Add(testEvent3);
      var events = Storage.RetrieveAll().ToArray();
      Console.Out.WriteLine("events.Length = {0}", events.Length);
      Assert.AreEqual(testEvent.NewDescription, ((SampleEvent)events[0]).NewDescription);
      Assert.AreEqual(testEvent2.NewDescription, ((SampleEvent)events[1]).NewDescription);
      Assert.AreEqual(testEvent3.NewDescription, ((SampleEvent)events[2]).NewDescription);
    }
    [Test]
    public void EventsShouldBeStoredByReversedGUIDForDistribution()
    {
      var newComb = new IdentityGenerator().GetNewComb();
      var sampleEvent = new SampleEvent {GUID = newComb, NewDescription = "sample desc"};
      var reverse = newComb.ToString().Reverse().Aggregate("", (x,y) => x + y);
      Storage.Add(sampleEvent);
      Assert.IsTrue(File.Exists("storage" + Path.DirectorySeparatorChar + reverse.Insert(2, "\\") + ".history"));
    }
    [Test]
    public void SnapshotsShouldShortCircuitEventRetrieval()
    {
      var testEvent = new SampleEvent { GUID = new IdentityGenerator().GetNewComb(), NewDescription = "1" };
      var testEvent2 = new SampleEvent { GUID = testEvent.GUID, NewDescription = "2" };
      var testEvent3 = new SampleEvent { GUID = testEvent.GUID, NewDescription = "3" };
      var testEvent4 = new SampleSnapshot { GUID = testEvent.GUID, NewDescription = "4" };
      var testEvent5 = new SampleEvent { GUID = testEvent.GUID, NewDescription = "5" };
      Storage.Add(testEvent);
      Storage.Add(testEvent2);
      Storage.Add(testEvent3);
      Storage.Add(testEvent4);
      Storage.Add(testEvent5);
      var events = Storage.RetrieveFor(testEvent.GUID).ToArray();
      Assert.IsTrue(testEvent4.NewDescription == ((SampleSnapshot)events[0]).NewDescription);
      Assert.IsTrue(testEvent5.NewDescription == ((SampleEvent)events[1]).NewDescription);
    }
    [Test]
    public void EnsureDateTimeIsStoredWithEvent() {
      var testEvent = new SampleEvent { GUID = new IdentityGenerator().GetNewComb(), NewDescription = "example description" };
      Storage.Add(testEvent);
      var events = Storage.RetrieveFor(testEvent.GUID);
      Assert.AreEqual(testEvent.Created, events.ToArray()[0].Created);
    }

    [TearDown] public void TearDown() { if (Directory.Exists("storage")) Directory.Delete("storage",true); }
  }

  namespace SampleNamespace
  {
    public class SampleEvent: Event
    {
      public string NewDescription;
    }
    public class SampleSnapshot: Snapshot
    {
      public string NewDescription;
    }

  }
}