klhztrader/KLHZ.Trader.Core.Tests/HistoryCacheUnit2Tests.cs

using KLHZ.Trader.Core.DataLayer.Entities.Prices;
using KLHZ.Trader.Core.Math.Declisions.Services.Cache;

namespace KLHZ.Trader.Core.Tests
{
    public class HistoryCacheUnit2Tests
    {
        private static PriceChange[] GetHistory(int count, string figi)
        {
            var res = new PriceChange[count];
            if (count != 0)
            {
                var startDt = DateTime.UtcNow.AddSeconds(-count);
                for (int i = 0; i < count; i++)
                {
                    startDt = startDt.AddSeconds(i);
                    res[i] = new PriceChange()
                    {
                        Figi = figi,
                        Ticker = figi + "_ticker",
                        Id = i,
                        Time = startDt,
                        Value = (decimal)(i + 0.5)
                    };
                }
            }
            return res;
        }

        [Test]
        public void Test1()
        {
            var count = 0;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2("", hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count);
            Assert.That(data.timestamps.Length == count);
        }

        [Test]
        public void Test2()
        {
            var count = 1;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count);
            Assert.That(data.timestamps.Length == count);
            for (var i = 0; i < count; i++)
            {
                Assert.That((float)hist[i].Value, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }
        }

        [Test]
        public void Test3()
        {
            var count = 20;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count);
            Assert.That(data.timestamps.Length == count);

            for (var i = 0; i < count; i++)
            {
                Assert.That((float)hist[i].Value, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }
        }

        [Test]
        public void Test4()
        {
            var count = PriceHistoryCacheUnit.CacheMaxLength;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count);
            Assert.That(data.timestamps.Length == count);

            for (var i = 0; i < count; i++)
            {
                Assert.That((float)hist[i].Value, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }
        }

        [Test]
        public void Test5()
        {
            var shift = 7;
            var count = PriceHistoryCacheUnit.CacheMaxLength + shift;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count - shift);
            Assert.That(data.timestamps.Length == count - shift);

            for (var i = 0; i < count; i++)
            {
                var k = i + shift;
                if (k < hist.Length)
                {
                    Assert.That((float)hist[k].Value, Is.EqualTo(data.prices[i]));
                    Assert.That(hist[k].Time, Is.EqualTo(data.timestamps[i]));
                }
            }
        }

        [Test]
        public void Test6()
        {
            var shift = 10;
            var count = PriceHistoryCacheUnit.CacheMaxLength + shift;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count - shift);
            Assert.That(data.timestamps.Length == count - shift);

            for (var i = 0; i < count; i++)
            {
                var k = i + shift;
                if (k < hist.Length)
                {
                    Assert.That((float)hist[k].Value, Is.EqualTo(data.prices[i]));
                    Assert.That(hist[k].Time, Is.EqualTo(data.timestamps[i]));
                }
            }
        }

        [Test]
        public void Test7()
        {
            var shift = 334;
            var count = PriceHistoryCacheUnit.CacheMaxLength + shift;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count - shift);
            Assert.That(data.timestamps.Length == count - shift);

            for (var i = 0; i < count; i++)
            {
                var k = i + shift;
                if (k < hist.Length)
                {
                    Assert.That((float)hist[k].Value, Is.EqualTo(data.prices[i]));
                    Assert.That(hist[k].Time, Is.EqualTo(data.timestamps[i]));
                }
            }
        }


        [Test]
        public void Test8()
        {
            var count = PriceHistoryCacheUnit.CacheMaxLength;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;

            Assert.That(data.prices.Length == count);
            Assert.That(data.timestamps.Length == count);

            for (var i = 0; i < count; i++)
            {
                Assert.That((float)hist[i].Value, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }

            var newData1 = new PriceChange() { Figi = figi, Ticker = figi, Value = 100500, Time = DateTime.UtcNow };

            cacheUnit.AddData(newData1);

            var data2 = cacheUnit.GetData().Result;
            Assert.IsTrue(data2.prices[data2.prices.Length - 1] == newData1.Value);
            Assert.IsTrue(data2.timestamps[data2.timestamps.Length - 1] == newData1.Time);

            var newData2 = new PriceChange() { Figi = figi, Ticker = figi, Value = 100501, Time = DateTime.UtcNow };

            cacheUnit.AddData(newData2);

            var data3 = cacheUnit.GetData().Result;
            Assert.IsTrue(data3.prices[data3.prices.Length - 1] == newData2.Value);
            Assert.IsTrue(data3.timestamps[data3.timestamps.Length - 1] == newData2.Time);
        }

        [Test]
        public void Test9()
        {
            var cacheUnit = new PriceHistoryCacheUnit2("");
            for (int i = 0; i < 5 * PriceHistoryCacheUnit2.CacheMaxLength; i++)
            {
                cacheUnit.AddData(new PriceChange() { Figi = "", Ticker = "", Value = i, Time = DateTime.UtcNow });
                if (i >= 500)
                {
                    var data = cacheUnit.GetData().Result;
                    Assert.IsTrue(data.prices.Length == PriceHistoryCacheUnit2.CacheMaxLength);
                    Assert.IsTrue(data.prices.Last() == i);
                }
            }
        }
    }
}