ored_commodityforward.cpp File Reference

#include <boost/test/unit_test.hpp>
#include <oret/toplevelfixture.hpp>
#include <boost/make_shared.hpp>
#include <ql/currencies/america.hpp>
#include <ql/math/interpolations/linearinterpolation.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <qle/termstructures/pricecurve.hpp>
#include <ored/marketdata/marketimpl.hpp>
#include <ored/portfolio/builders/commodityforward.hpp>
#include <ored/portfolio/commodityforward.hpp>
#include <ored/portfolio/portfolio.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testCommodityForwardTradeBuilding)
	BOOST_AUTO_TEST_CASE (testCommodityForwardFromXml)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/2]

BOOST_AUTO_TEST_CASE

(

testCommodityForwardTradeBuilding

)

Definition at line 73 of file ored_commodityforward.cpp.

                                                        {
 
    BOOST_TEST_MESSAGE("Testing commodity forward trade building");
 
    // Create market
    QuantLib::ext::shared_ptr<Market> market = QuantLib::ext::make_shared<TestMarket>();
    Settings::instance().evaluationDate() = market->asofDate();
 
    // Create engine factory
    QuantLib::ext::shared_ptr<EngineData> engineData = QuantLib::ext::make_shared<EngineData>();
    engineData->model("CommodityForward") = "DiscountedCashflows";
    engineData->engine("CommodityForward") = "DiscountingCommodityForwardEngine";
    QuantLib::ext::shared_ptr<EngineFactory> engineFactory = QuantLib::ext::make_shared<EngineFactory>(engineData, market);
 
    // Base commodity values
    string position = "Long";
    string commodityName = "GOLD_USD";
    string currency = "USD";
    Real quantity = 100.0;
    string maturity = "2019-02-19";
    Real strike = 1340.0;
 
    // Test the building of a commodity forward doesn't throw
    Envelope envelope;
    QuantLib::ext::shared_ptr<ore::data::CommodityForward> forward = QuantLib::ext::make_shared<ore::data::CommodityForward>(
        envelope, position, commodityName, currency, quantity, maturity, strike);
    BOOST_CHECK_NO_THROW(forward->build(engineFactory));
 
    // Check the instrument was built as expected
    QuantLib::ext::shared_ptr<Instrument> qlInstrument = forward->instrument()->qlInstrument();
    QuantLib::ext::shared_ptr<QuantExt::CommodityForward> commodityForward =
        QuantLib::ext::dynamic_pointer_cast<QuantExt::CommodityForward>(qlInstrument);
    BOOST_CHECK(commodityForward);
    BOOST_CHECK_EQUAL(commodityForward->position(), Position::Type::Long);
    BOOST_CHECK_EQUAL(commodityForward->index()->name(), "COMM-GOLD_USD");
    BOOST_CHECK_EQUAL(commodityForward->currency(), USDCurrency());
    BOOST_CHECK_CLOSE(commodityForward->quantity(), 100.0, testTolerance);
    BOOST_CHECK_EQUAL(commodityForward->maturityDate(), Date(19, Feb, 2019));
    BOOST_CHECK_CLOSE(commodityForward->strike(), 1340.0, testTolerance);
 
    // Check the price (simple because DF = 1.0, 100 * (1348 - 1340))
    BOOST_CHECK_CLOSE(commodityForward->NPV(), 800.0, testTolerance);
 
    // Check short
    forward = QuantLib::ext::make_shared<ore::data::CommodityForward>(envelope, "Short", commodityName, currency, quantity,
                                                              maturity, strike);
    BOOST_CHECK_NO_THROW(forward->build(engineFactory));
    qlInstrument = forward->instrument()->qlInstrument();
    commodityForward = QuantLib::ext::dynamic_pointer_cast<QuantExt::CommodityForward>(qlInstrument);
    BOOST_CHECK(commodityForward);
    BOOST_CHECK_EQUAL(commodityForward->position(), Position::Type::Short);
    BOOST_CHECK_CLOSE(commodityForward->NPV(), -800.0, testTolerance);
 
    // Check that negative quantity throws an error
    forward = QuantLib::ext::make_shared<ore::data::CommodityForward>(envelope, position, commodityName, currency, -quantity,
                                                              maturity, strike);
    BOOST_CHECK_THROW(forward->build(engineFactory), Error);
 
    // Check that negative strike throws an error
    forward = QuantLib::ext::make_shared<ore::data::CommodityForward>(envelope, position, commodityName, currency, quantity,
                                                              maturity, -strike);
    BOOST_CHECK_THROW(forward->build(engineFactory), Error);
 
    // Check that build fails when commodity name does not match that in the market
    forward = QuantLib::ext::make_shared<ore::data::CommodityForward>(envelope, position, "GOLD", currency, quantity, maturity,
                                                              strike);
    BOOST_CHECK_THROW(forward->build(engineFactory), Error);
}

BOOST_AUTO_TEST_CASE() [2/2]

BOOST_AUTO_TEST_CASE

(

testCommodityForwardFromXml

)

Definition at line 142 of file ored_commodityforward.cpp.

                                                  {
 
    BOOST_TEST_MESSAGE("Testing parsing of commodity forward trade from XML");
 
    // Create an XML string representation of the trade
    string tradeXml;
    tradeXml.append("<Portfolio>");
    tradeXml.append("  <Trade id=\"CommodityForward_WTI_Oct_21\">");
    tradeXml.append("  <TradeType>CommodityForward</TradeType>");
    tradeXml.append("  <Envelope>");
    tradeXml.append("    <CounterParty>CPTY_A</CounterParty>");
    tradeXml.append("    <NettingSetId>CPTY_A</NettingSetId>");
    tradeXml.append("    <AdditionalFields/>");
    tradeXml.append("  </Envelope>");
    tradeXml.append("  <CommodityForwardData>");
    tradeXml.append("    <Position>Short</Position>");
    tradeXml.append("    <Maturity>2021-10-31</Maturity>");
    tradeXml.append("    <Name>COMDTY_WTI_USD</Name>");
    tradeXml.append("    <Currency>USD</Currency>");
    tradeXml.append("    <Strike>49.75</Strike>");
    tradeXml.append("    <Quantity>500000</Quantity>");
    tradeXml.append("  </CommodityForwardData>");
    tradeXml.append("  </Trade>");
    tradeXml.append("</Portfolio>");
 
    // Load portfolio from XML string
    Portfolio portfolio;
    portfolio.fromXMLString(tradeXml);
 
    // Extract CommodityForward trade from portfolio
    QuantLib::ext::shared_ptr<Trade> trade = portfolio.trades().begin()->second;
    QuantLib::ext::shared_ptr<ore::data::CommodityForward> commodityForward =
        QuantLib::ext::dynamic_pointer_cast<ore::data::CommodityForward>(trade);
 
    // Check fields after checking that the cast was successful
    BOOST_CHECK(commodityForward);
    BOOST_CHECK_EQUAL(commodityForward->tradeType(), "CommodityForward");
    BOOST_CHECK_EQUAL(commodityForward->id(), "CommodityForward_WTI_Oct_21");
    BOOST_CHECK_EQUAL(commodityForward->position(), "Short");
    BOOST_CHECK_EQUAL(commodityForward->maturityDate(), "2021-10-31");
    BOOST_CHECK_EQUAL(commodityForward->commodityName(), "COMDTY_WTI_USD");
    BOOST_CHECK_EQUAL(commodityForward->currency(), "USD");
    BOOST_CHECK_CLOSE(commodityForward->strike(), 49.75, testTolerance);
    BOOST_CHECK_CLOSE(commodityForward->quantity(), 500000.0, testTolerance);
}

Here is the call graph for this function: