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(1);
                    res[i] = new PriceChange()
                    {
                        Figi = figi,
                        Ticker = figi + "_ticker",
                        Id = i,
                        Time = startDt,
                        Price = (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].Price, 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].Price, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }
        }

        [Test]
        public void Test4()
        {
            var count = PriceHistoryCacheUnit2.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].Price, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }
        }

        [Test]
        public void Test5()
        {
            var shift = 7;
            var count = PriceHistoryCacheUnit2.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].Price, Is.EqualTo(data.prices[i]));
                    Assert.That(hist[k].Time, Is.EqualTo(data.timestamps[i]));
                }
            }
        }

        [Test]
        public void Test6()
        {
            var shift = 10;
            var count = PriceHistoryCacheUnit2.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].Price, Is.EqualTo(data.prices[i]));
                    Assert.That(hist[k].Time, Is.EqualTo(data.timestamps[i]));
                }
            }
        }

        [Test]
        public void Test7()
        {
            var shift = 334;
            var count = PriceHistoryCacheUnit2.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].Price, Is.EqualTo(data.prices[i]));
                    Assert.That(hist[k].Time, Is.EqualTo(data.timestamps[i]));
                }
            }
        }


        [Test]
        public void Test8()
        {
            var count = PriceHistoryCacheUnit2.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].Price, Is.EqualTo(data.prices[i]));
                Assert.That(hist[i].Time, Is.EqualTo(data.timestamps[i]));
            }

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

            cacheUnit.AddData(newData1);

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

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

            cacheUnit.AddData(newData2);

            var data3 = cacheUnit.GetData().Result;
            Assert.IsTrue(data3.prices[data3.prices.Length - 1] == newData2.Price);
            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 = "", Price = i, Time = DateTime.UtcNow });
                if (i >= PriceHistoryCacheUnit2.CacheMaxLength)
                {
                    var data = cacheUnit.GetData().Result;
                    Assert.IsTrue(data.prices.Length == PriceHistoryCacheUnit2.CacheMaxLength);
                    Assert.IsTrue(data.prices.Last() == i);
                    var lastValues = cacheUnit.GetLastValues().Result;
                    Assert.IsTrue(data.prices.Last() == lastValues.price);
                    Assert.IsTrue(data.timestamps.Last() == lastValues.time);
                }
            }
        }

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

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

            Assert.That(data.prices.Last() == hist.Last().Price);
            Assert.That(data.timestamps.Last() == hist.Last().Time);
            for (var i = 1; i <= length; i++)
            {
                Assert.That(hist[hist.Length - i].Price, Is.EqualTo(data.prices[data.prices.Length - i]));
                Assert.That(hist[hist.Length - i].Time, Is.EqualTo(data.timestamps[data.prices.Length - i]));
            }
        }

        [Test]
        public void Test11()
        {
            var length = 77;
            var shift = 334;
            var count = PriceHistoryCacheUnit2.CacheMaxLength + shift;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData(length).Result;
            var span = TimeSpan.FromSeconds(100);
            var dataForPeriod = cacheUnit.GetData(span).Result;

            Assert.That(dataForPeriod.isFullIntervalExists);
            Assert.That(data.prices.Last() == dataForPeriod.prices.Last());
            Assert.That(data.timestamps.Last() == dataForPeriod.timestamps.Last());
            var dt = dataForPeriod.timestamps.Last() - dataForPeriod.timestamps.First();
            Assert.That(dt <= span);
            Assert.That(data.prices.Length == length);
            Assert.That(data.timestamps.Length == length);

            Assert.That(data.prices.Last() == hist.Last().Price);
            Assert.That(data.timestamps.Last() == hist.Last().Time);
        }

        [Test]
        public void Test12()
        {
            var count = 30;
            var figi = "figi";
            var hist = GetHistory(count, figi);
            var cacheUnit = new PriceHistoryCacheUnit2(figi, hist);
            var data = cacheUnit.GetData().Result;
            var span = TimeSpan.FromSeconds(100);
            var dataForPeriod = cacheUnit.GetData(span).Result;

            Assert.IsFalse(dataForPeriod.isFullIntervalExists);
            Assert.That(data.prices.Last() == dataForPeriod.prices.Last());
            Assert.That(data.timestamps.Last() == dataForPeriod.timestamps.Last());

            Assert.That(data.prices.First() == dataForPeriod.prices.First());
            Assert.That(data.timestamps.First() == dataForPeriod.timestamps.First());
        }
    }
}