public void AfterProcessing_ExtremumObjectHasProperlyAssignedLaterChange10()
        {
            //Arrange
            Mock <IProcessManager>    mockedManager   = new Mock <IProcessManager>();
            Mock <IExtremumProcessor> mockedProcessor = new Mock <IExtremumProcessor>();
            DataSet dataSet4 = utf.getDataSetWithQuotation(4, 1.0915, 1.0916, 1.09111, 1.09112, 1392);

            mockedManager.Setup(m => m.GetDataSet(4)).Returns(dataSet4);
            mockedProcessor.Setup(p => p.IsExtremum(dataSet4, ExtremumType.TroughByLow)).Returns(true);
            mockedProcessor.Setup(p => p.CalculateLaterChange(It.IsAny <Extremum>(), 10)).Returns(1.23);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.InjectExtremumProcessor(mockedProcessor.Object);
            processor.Process(dataSet4);

            //Assert
            double   expectedValue = 1.23;
            Price    price         = dataSet4.GetPrice();
            Extremum extremum      = price.GetExtremum(ExtremumType.TroughByLow);
            var      difference    = (extremum.LaterChange10 - expectedValue);

            Assert.IsTrue(Math.Abs(difference) < MAX_DOUBLE_COMPARISON_DIFFERENCE);
        }
        public void AfterProcessing_PriceObjectIsSet_IfQuotationIsNotNull()
        {
            //Arrange
            Mock <IProcessManager> mockedManager = new Mock <IProcessManager>();
            DataSet dataSet1 = utf.getDataSet(1);
            DataSet dataSet2 = utf.getDataSetWithQuotation(2, 1.09191, 1.09218, 1.09186, 1.09194, 1411);

            mockedManager.Setup(m => m.GetDataSet(1)).Returns(dataSet1);
            mockedManager.Setup(m => m.GetDataSet(2)).Returns(dataSet2);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.Process(dataSet2);

            //Assert
            Assert.IsNotNull(dataSet2.GetPrice());
        }
        public void AfterProcessing_DeltaCloseIsZero_IfThisIsItemIndexOne()
        {
            //Arrange
            Mock <IProcessManager> mockedManager = new Mock <IProcessManager>();
            DataSet dataSet1 = utf.getDataSetWithQuotation(1, 1.09191, 1.09218, 1.09186, 1.09194, 1411);
            DataSet dataSet2 = utf.getDataSetWithQuotation(2, 1.09193, 1.09256, 1.09165, 1.09177, 1819);

            mockedManager.Setup(m => m.GetDataSet(1)).Returns(dataSet1);
            mockedManager.Setup(m => m.GetDataSet(2)).Returns(dataSet2);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.Process(dataSet1);

            //Assert
            var expected = 0;
            var actual   = dataSet1.GetPrice().CloseDelta;

            Assert.AreEqual(expected, actual);
        }
        public void AfterProcessing_DeltaCloseIsZero_IfPreviousCloseWasTheSameAsCurrentOne()
        {
            //Arrange
            Mock <IProcessManager> mockedManager = new Mock <IProcessManager>();
            DataSet dataSet2 = utf.getDataSetWithQuotation(2, 1.09191, 1.09218, 1.09186, 1.09194, 1411);
            DataSet dataSet3 = utf.getDataSetWithQuotation(3, 1.09193, 1.09256, 1.09165, 1.09194, 1819);

            mockedManager.Setup(m => m.GetDataSet(2)).Returns(dataSet2);
            mockedManager.Setup(m => m.GetDataSet(3)).Returns(dataSet3);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.Process(dataSet3);

            //Assert
            var expected = 0;
            var actual   = dataSet3.GetPrice().CloseDelta;

            Assert.AreEqual(expected, actual);
        }
        public void AfterProcessing_PriceHasTroughByLow_IfExtremaProcessorReturnsTrueForIsExtrema()
        {
            //Arrange
            Mock <IProcessManager>    mockedManager   = new Mock <IProcessManager>();
            Mock <IExtremumProcessor> mockedProcessor = new Mock <IExtremumProcessor>();
            DataSet dataSet4 = utf.getDataSetWithQuotation(4, 1.0915, 1.0916, 1.09111, 1.09112, 1392);

            mockedManager.Setup(m => m.GetDataSet(4)).Returns(dataSet4);
            mockedProcessor.Setup(p => p.IsExtremum(dataSet4, ExtremumType.TroughByLow)).Returns(true);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.InjectExtremumProcessor(mockedProcessor.Object);
            processor.Process(dataSet4);

            //Assert
            Price price = dataSet4.GetPrice();

            Assert.IsNotNull(price.GetExtremum(ExtremumType.TroughByLow));
        }
        public void AfterProcessing_IfThereIsNewPeakByCloseExtremum_ItHasIsUpdatedFlagSetToTrue()
        {
            //Arrange
            Mock <IProcessManager>    mockedManager   = new Mock <IProcessManager>();
            Mock <IExtremumProcessor> mockedProcessor = new Mock <IExtremumProcessor>();
            DataSet dataSet4 = utf.getDataSetWithQuotation(4, 1.0915, 1.0916, 1.09111, 1.09112, 1392);

            mockedManager.Setup(m => m.GetDataSet(4)).Returns(dataSet4);
            mockedProcessor.Setup(p => p.IsExtremum(dataSet4, ExtremumType.PeakByClose)).Returns(true);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.InjectExtremumProcessor(mockedProcessor.Object);
            processor.Process(dataSet4);

            //Assert
            Price    price    = dataSet4.GetPrice();
            Extremum extremum = price.GetExtremum(ExtremumType.PeakByClose);

            Assert.IsTrue(extremum.Updated);
        }
        public void AfterProcessing_DeltaCloseIsProperlyCalculated_IfPreviousCloseWasHigher()
        {
            //Arrange
            Mock <IProcessManager> mockedManager = new Mock <IProcessManager>();
            DataSet dataSet2 = utf.getDataSetWithQuotation(2, 1.09191, 1.09218, 1.09186, 1.09194, 1411);
            DataSet dataSet3 = utf.getDataSetWithQuotation(3, 1.09193, 1.09256, 1.09165, 1.09213, 1819);

            mockedManager.Setup(m => m.GetDataSet(2)).Returns(dataSet2);
            mockedManager.Setup(m => m.GetDataSet(3)).Returns(dataSet3);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.Process(dataSet3);

            //Assert
            var expected   = 0.00019;
            var actual     = dataSet3.GetPrice().CloseDelta;
            var difference = Math.Abs(actual - expected);

            Assert.IsTrue(difference < MAX_DOUBLE_COMPARISON_DIFFERENCE);
        }
        public void AfterProcessing_ExtremumObjectHasProperlyAssignedLaterCounter()
        {
            //Arrange
            Mock <IProcessManager>    mockedManager   = new Mock <IProcessManager>();
            Mock <IExtremumProcessor> mockedProcessor = new Mock <IExtremumProcessor>();
            DataSet dataSet4 = utf.getDataSetWithQuotation(4, 1.0915, 1.0916, 1.09111, 1.09112, 1392);

            mockedManager.Setup(m => m.GetDataSet(4)).Returns(dataSet4);
            mockedProcessor.Setup(p => p.IsExtremum(dataSet4, ExtremumType.TroughByLow)).Returns(true);
            mockedProcessor.Setup(p => p.CalculateLaterCounter(It.IsAny <Extremum>())).Returns(4);

            //Act
            PriceProcessor processor = new PriceProcessor(mockedManager.Object);

            processor.InjectExtremumProcessor(mockedProcessor.Object);
            processor.Process(dataSet4);

            //Assert
            int      expectedValue = 4;
            Price    price         = dataSet4.GetPrice();
            Extremum extremum      = price.GetExtremum(ExtremumType.TroughByLow);

            Assert.AreEqual(expectedValue, extremum.LaterCounter);
        }