public void TearDown()
{
myContext = null;
myProvider = null;
myLhsSeries = null;
myRhsSeries = null;
}
public void TearDown()
{
myContext = null;
myProvider = null;
myCurrentPrice = null;
myRhsSeries = null;
}
private static string GetHeader(Row dataRow, IFigureSeries series)
{
if (series.Any())
{
if (series.Currency == null)
{
return(dataRow.InMillions ? string.Format("{0} (in Mio.)", dataRow.Caption) : dataRow.Caption);
}
else
{
if (dataRow.InMillions)
{
return(string.Format("{0} (in Mio. {1})", dataRow.Caption, series.Currency.Name));
}
else
{
return(string.Format("{0} ({1})", dataRow.Caption, series.Currency.Name));
}
}
}
else
{
return(dataRow.InMillions ? string.Format("{0} (in Mio.)", dataRow.Caption) : dataRow.Caption);
}
}
public void ProvideValue_RhsHasNoDataForPeriod_ItemSkippedInJoin()
{
myLhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 5), FigureFactory.New(2014, 7), FigureFactory.New(2013, 87));
myRhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 23), FigureFactory.New(2014, 37));
var result = ( IFigureSeries )myProvider.ProvideValue(myContext.Object);
Assert.That(result.Count, Is.EqualTo(2));
}
public void ProvideValue_InconsistentCurrencies_Throws()
{
myLhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 5, Euro), FigureFactory.New(2014, 7, Euro));
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 23, Dollar), FigureFactory.New(2014, 37, Dollar));
var ex = Assert.Throws <ArgumentException>(() => myProvider.ProvideValue(myContext.Object));
Assert.That(ex.Message, Does.Contain("Currency inconsistencies"));
}
public void ProvideValue_WithPreserveCurrency_CurrencyTakenOverForResult()
{
myLhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 5, Euro), FigureFactory.New(2014, 7, Euro));
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 23, Euro), FigureFactory.New(2014, 37, Euro));
var result = ( IFigureSeries )myProvider.ProvideValue(myContext.Object);
Assert.That(result.Currency, Is.EqualTo(Euro));
}
public void ProvideValue_PriceWithoutCurrency_Throws()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, null);
myRhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 1));
var ex = Assert.Throws <ArgumentException>(() => myProvider.ProvideValue(myContext.Object));
Assert.That(ex.Message, Does.Contain("Currency missing"));
}
public void ProvideValue_WhenCalled_InputsReferenced()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, Euro);
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 23, Euro), FigureFactory.New(2014, 37, Euro));
var result = ( DerivedFigure )myProvider.ProvideValue(myContext.Object);
Assert.That(result.Inputs, Is.EquivalentTo(new[] { myCurrentPrice, myRhsSeries.ElementAt(1) }));
}
public void ProvideValue_RhsSeriesEmpty_ReturnsMissingData()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, Euro);
myRhsSeries = FigureSeries.Empty;
var result = myProvider.ProvideValue(myContext.Object);
Assert.That(result, Is.InstanceOf <MissingData>());
Assert.That((( MissingData )result).Figure, Is.EqualTo(RhsSeriesName));
}
public void ProvideValue_WhenCalled_InputsReferenced()
{
myLhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 5, Euro), FigureFactory.New(2014, 7, Euro));
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 23, Euro), FigureFactory.New(2014, 37, Euro));
var result = ( IFigureSeries )myProvider.ProvideValue(myContext.Object);
Assert.That((( DerivedFigure )result.ElementAt(0)).Inputs, Is.EquivalentTo(new[] { myLhsSeries.ElementAt(0), myRhsSeries.ElementAt(0) }));
Assert.That((( DerivedFigure )result.ElementAt(1)).Inputs, Is.EquivalentTo(new[] { myLhsSeries.ElementAt(1), myRhsSeries.ElementAt(1) }));
}
public void ProvideValue_RhsSeriesEmpty_ReturnsMissingData()
{
myLhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 1));
myRhsSeries = FigureSeries.Empty;
var result = myProvider.ProvideValue(myContext.Object);
Assert.That(result, Is.InstanceOf <MissingData>());
Assert.That((( MissingData )result).Figure, Is.EqualTo(RhsSeriesName));
}
public void ProvideValue_PriceMissing_ReturnsMissingData()
{
myCurrentPrice = null;
myRhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 1));
var result = myProvider.ProvideValue(myContext.Object);
Assert.That(result, Is.InstanceOf <MissingData>());
Assert.That((( MissingData )result).Figure, Is.EqualTo("Price"));
}
public void ProvideValue_RhsHasNoDataForPeriod_MissingDataForPeriodReturned()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, Euro);
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2001, 1, Euro));
var result = myProvider.ProvideValue(myContext.Object);
Assert.That(result, Is.InstanceOf <MissingDataForPeriod>());
Assert.That((( MissingDataForPeriod )result).Figure, Is.EqualTo(RhsSeriesName));
}
public void ProvideValue_SeriesWithoutCurrency_CurrencyOfPriceTaken()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, Euro);
myRhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 23), FigureFactory.New(2014, 37));
var result = ( DerivedFigure )myProvider.ProvideValue(myContext.Object);
Assert.That(result.Currency, Is.EqualTo(myCurrentPrice.Currency));
Assert.That(result.Value, Is.EqualTo(17.21 + 23));
}
public static IFigure Current(this IFigureSeries self)
{
if (self == null)
{
return(null);
}
return(self
.OrderByDescending(v => v.Period)
.FirstOrDefault());
}
public void ProvideValue_WithValidInputData_RatioReturned()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, Euro);
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 23, Euro), FigureFactory.New(2014, 37, Euro));
var result = ( ICurrencyFigure )myProvider.ProvideValue(myContext.Object);
Assert.That(result.Period, Is.EqualTo(myCurrentPrice.Period));
Assert.That(result.Value, Is.EqualTo(17.21 + 23));
Assert.That(result.Currency, Is.EqualTo(myCurrentPrice.Currency));
}
public void ProvideValue_InconsistentCurrencies_PriceCurrencyTranslated()
{
myCurrentPrice = FigureFactory.NewPrice("2015-01-01", 17.21, Euro);
myRhsSeries = new FigureSeries(typeof(FakeCurrencyFigure), FigureFactory.New(2015, 23, Dollar), FigureFactory.New(2014, 37, Dollar));
myContext.Setup(x => x.TranslateCurrency(It.IsAny <double>(), It.IsAny <Currency>(), It.IsAny <Currency>()))
.Returns <double, Currency, Currency>((value, source, target) => value * 2);
var result = ( DerivedFigure )myProvider.ProvideValue(myContext.Object);
Assert.That(result.Currency, Is.EqualTo(myRhsSeries.Currency));
Assert.That(result.Value, Is.EqualTo(17.21 * 2 + 23));
}
public void ProvideValue_WithValidInputData_JoinReturned()
{
myLhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 5), FigureFactory.New(2014, 7));
myRhsSeries = new FigureSeries(typeof(FakeFigure), FigureFactory.New(2015, 23), FigureFactory.New(2014, 37));
var result = ( IFigureSeries )myProvider.ProvideValue(myContext.Object);
var r2015 = result.Single(i => i.Period.Equals(new YearPeriod(2015)));
Assert.That(r2015.Value, Is.EqualTo(28));
var r2014 = result.Single(i => i.Period.Equals(new YearPeriod(2014)));
Assert.That(r2014.Value, Is.EqualTo(44));
}
public static TFigureType Current <TFigureType>(this IFigureSeries self)
{
return(( TFigureType )self.Current());
}
protected void EnsureCurrencyConsistancy(IFigureSeries lhs, IFigureSeries rhs)
{
Contract.Requires(lhs.Currency == null || rhs.Currency == null || lhs.Currency == rhs.Currency,
"Currency inconsistencies detected: {0}.Currency={1} vs {2}.Currency={3}",
lhs.Name, lhs.Currency, rhs.Name, rhs.Currency);
}
