/**
* Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.strata.measure.fx;
import static com.opengamma.strata.basics.currency.Currency.GBP;
import static com.opengamma.strata.basics.currency.Currency.USD;
import static com.opengamma.strata.basics.date.DayCounts.ACT_360;
import static com.opengamma.strata.basics.index.FxIndices.GBP_USD_WM;
import static com.opengamma.strata.collect.TestHelper.date;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.LocalDate;
import java.util.Set;
import org.testng.annotations.Test;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.opengamma.strata.basics.ReferenceData;
import com.opengamma.strata.basics.currency.CurrencyAmount;
import com.opengamma.strata.basics.currency.FxRate;
import com.opengamma.strata.basics.currency.MultiCurrencyAmount;
import com.opengamma.strata.calc.Measure;
import com.opengamma.strata.calc.runner.CalculationParameters;
import com.opengamma.strata.calc.runner.FunctionRequirements;
import com.opengamma.strata.collect.result.Result;
import com.opengamma.strata.data.FxRateId;
import com.opengamma.strata.data.scenario.CurrencyScenarioArray;
import com.opengamma.strata.data.scenario.MultiCurrencyScenarioArray;
import com.opengamma.strata.data.scenario.ScenarioArray;
import com.opengamma.strata.data.scenario.ScenarioMarketData;
import com.opengamma.strata.market.curve.ConstantCurve;
import com.opengamma.strata.market.curve.Curve;
import com.opengamma.strata.market.curve.CurveId;
import com.opengamma.strata.market.curve.Curves;
import com.opengamma.strata.market.param.CurrencyParameterSensitivities;
import com.opengamma.strata.market.sensitivity.PointSensitivities;
import com.opengamma.strata.measure.Measures;
import com.opengamma.strata.measure.curve.TestMarketDataMap;
import com.opengamma.strata.measure.rate.RatesMarketDataLookup;
import com.opengamma.strata.pricer.fx.DiscountingFxNdfTradePricer;
import com.opengamma.strata.pricer.rate.RatesProvider;
import com.opengamma.strata.product.TradeInfo;
import com.opengamma.strata.product.fx.FxNdf;
import com.opengamma.strata.product.fx.FxNdfTrade;
import com.opengamma.strata.product.fx.ResolvedFxNdfTrade;
/**
* Test {@link FxNdfTradeCalculationFunction}.
*/
@Test
public class FxNdfTradeCalculationFunctionTest {
private static final ReferenceData REF_DATA = ReferenceData.standard();
private static final FxRate FX_RATE = FxRate.of(GBP, USD, 1.5d);
private static final CurrencyAmount NOTIONAL = CurrencyAmount.of(GBP, (double) 100_000_000);
private static final FxNdf PRODUCT = FxNdf.builder()
.agreedFxRate(FX_RATE)
.settlementCurrencyNotional(NOTIONAL)
.index(GBP_USD_WM)
.paymentDate(date(2015, 3, 19))
.build();
public static final FxNdfTrade TRADE = FxNdfTrade.builder()
.info(TradeInfo.builder()
.tradeDate(date(2015, 6, 1))
.build())
.product(PRODUCT)
.build();
public static final ResolvedFxNdfTrade RTRADE = TRADE.resolve(REF_DATA);
private static final CurveId DISCOUNT_CURVE_GBP_ID = CurveId.of("Default", "Discount-GBP");
private static final CurveId DISCOUNT_CURVE_USD_ID = CurveId.of("Default", "Discount-USD");
static final RatesMarketDataLookup RATES_LOOKUP = RatesMarketDataLookup.of(
ImmutableMap.of(GBP, DISCOUNT_CURVE_GBP_ID, USD, DISCOUNT_CURVE_USD_ID),
ImmutableMap.of());
private static final CalculationParameters PARAMS = CalculationParameters.of(RATES_LOOKUP);
private static final LocalDate VAL_DATE = TRADE.getProduct().getPaymentDate().minusDays(7);
//-------------------------------------------------------------------------
public void test_requirementsAndCurrency() {
FxNdfTradeCalculationFunction function = new FxNdfTradeCalculationFunction();
Set<Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.getOutputCurrencies()).containsExactly(GBP, USD);
assertThat(reqs.getValueRequirements()).isEqualTo(
ImmutableSet.of(DISCOUNT_CURVE_GBP_ID, DISCOUNT_CURVE_USD_ID));
assertThat(reqs.getTimeSeriesRequirements()).isEmpty();
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(GBP);
}
public void test_simpleMeasures() {
FxNdfTradeCalculationFunction function = new FxNdfTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
DiscountingFxNdfTradePricer pricer = DiscountingFxNdfTradePricer.DEFAULT;
CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider);
MultiCurrencyAmount expectedCurrencyExp = pricer.currencyExposure(RTRADE, provider);
CurrencyAmount expectedCash = pricer.currentCash(RTRADE, provider);
FxRate expectedForwardFx = pricer.forwardFxRate(RTRADE, provider);
Set<Measure> measures = ImmutableSet.of(
Measures.PRESENT_VALUE,
Measures.CURRENCY_EXPOSURE,
Measures.CURRENT_CASH,
Measures.FORWARD_FX_RATE,
Measures.RESOLVED_TARGET);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA))
.containsEntry(
Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv))))
.containsEntry(
Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExp))))
.containsEntry(
Measures.CURRENT_CASH, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedCash))))
.containsEntry(
Measures.FORWARD_FX_RATE, Result.success(ScenarioArray.of(ImmutableList.of(expectedForwardFx))))
.containsEntry(
Measures.RESOLVED_TARGET, Result.success(RTRADE));
}
public void test_pv01() {
FxNdfTradeCalculationFunction function = new FxNdfTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
DiscountingFxNdfTradePricer pricer = DiscountingFxNdfTradePricer.DEFAULT;
PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, provider);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01 = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedBucketedPv01 = pvParamSens.multipliedBy(1e-4);
Set<Measure> measures = ImmutableSet.of(
Measures.PV01_CALIBRATED_SUM,
Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA))
.containsEntry(
Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01))))
.containsEntry(
Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedBucketedPv01))));
}
//-------------------------------------------------------------------------
static ScenarioMarketData marketData() {
Curve curve1 = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.992);
Curve curve2 = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.991);
TestMarketDataMap md = new TestMarketDataMap(
VAL_DATE,
ImmutableMap.of(
DISCOUNT_CURVE_GBP_ID, curve1,
DISCOUNT_CURVE_USD_ID, curve2,
FxRateId.of(GBP, USD), FxRate.of(GBP, USD, 1.62)),
ImmutableMap.of());
return md;
}
}