Enforce required today's fixing before overnight coupon projection

ql/cashflows/overnightindexedcouponpricer.cpp

@@ -141,6 +141,10 @@ namespace QuantLib {
 
         // today is a border case
         if (i < n && fixingDates[i] == today) {
+            QL_REQUIRE(!Settings::instance().enforcesTodaysHistoricFixings() ||
+                           pastFixings[fixingDates[i]] != Null<Real>(),
+                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
+
             // might have been fixed
             try {
                 Rate fixing = pastFixings[fixingDates[i]];

test-suite/overnightindexedcoupon.cpp

@@ -27,6 +27,7 @@
 #include <ql/cashflows/blackovernightindexedcouponpricer.hpp>
 #include <ql/indexes/ibor/sofr.hpp>
 #include <ql/settings.hpp>
+#include <ql/currencies/america.hpp>
 #include <ql/termstructures/yield/discountcurve.hpp>
 #include <ql/time/calendars/unitedstates.hpp>
 #include <ql/time/daycounters/actual360.hpp>
@@ -336,6 +337,82 @@ struct CommonVarsONLeg {
                     << "\n    error:      " << std::setprecision(12) << std::fabs((calculated)-(expected))); \
     }
 
+BOOST_AUTO_TEST_CASE(testRequiredTodaysFixing) {
+    BOOST_TEST_MESSAGE("Testing required today's fixing before overnight coupon projection...");
+
+    const Date today(10, November, 2026);
+    Settings::instance().evaluationDate() = today;
+    const Calendar calendar = WeekendsOnly();
+    const auto curve = ext::make_shared<FlatForward>(today, 0.025, Actual360());
+    const auto index = ext::make_shared<OvernightIndex>(
+        "RequiredToday", 0, USDCurrency(), calendar, Actual360(),
+        Handle<YieldTermStructure>(curve));
+
+    for (Natural lookback : {0, 2}) {
+        for (bool shift : {false, true}) {
+            // Unshifted lookback cannot use compressed value dates.
+            for (bool telescopic : {false, true}) {
+                if (telescopic && lookback != 0 && !shift)
+                    continue;
+                for (int historyState : {0, 1, 2}) {
+                    index->clearFixings();
+                    if (historyState != 0)
+                        index->addFixing(
+                            today, historyState == 1 ? Real(Null<Real>()) : Real(0.11));
+                    for (bool enforce : {false, true}) {
+                        Settings::instance().enforcesTodaysHistoricFixings() = enforce;
+                        const Date start = calendar.advance(today, lookback, Days);
+                        const Date end = calendar.advance(start, 25, Days);
+                        const OvernightIndexedCoupon coupon(
+                            end, 10000.0, start, end, index, 1.0, 0.0, Date(), Date(),
+                            Actual360(), telescopic, RateAveraging::Compound, lookback, 0, shift);
+                        BOOST_REQUIRE_EQUAL(coupon.fixingDates().front(), today);
+                        BOOST_TEST_CONTEXT("lookback=" << lookback << ", shift=" << shift
+                                           << ", telescopic=" << telescopic
+                                           << ", historyState=" << historyState
+                                           << ", enforce=" << enforce) {
+                            if (enforce && historyState != 2) {
+                                BOOST_CHECK_THROW(coupon.rate(), Error);
+                            } else {
+                                // Independent business-day enumeration and deposit products:
+                                // no coupon schedule or index/pricer forecasting is used.
+                                Real factor = 1.0;
+                                for (Integer i = 0; i < 25; ++i) {
+                                    const Date observation = calendar.advance(today, i, Days);
+                                    const Date nextObservation =
+                                        calendar.advance(today, i + 1, Days);
+                                    const Time depositSpan =
+                                        Actual360().yearFraction(observation, nextObservation);
+                                    const Rate forecast = (curve->discount(observation) /
+                                        curve->discount(nextObservation) - 1.0) / depositSpan;
+                                    const Rate fixing =
+                                        i == 0 && historyState == 2 ? Real(0.11) : forecast;
+                                    const Date accrual = calendar.advance(start, i, Days);
+                                    const Date nextAccrual = calendar.advance(start, i + 1, Days);
+                                    const Time span = shift ? depositSpan :
+                                        Actual360().yearFraction(accrual, nextAccrual);
+                                    factor *= 1.0 + fixing * span;
+                                }
+                                const Date rateStart = shift ? today : start;
+                                const Date rateEnd = calendar.advance(rateStart, 25, Days);
+                                const Time tau = Actual360().yearFraction(rateStart, rateEnd);
+                                QL_CHECK_SMALL(coupon.rate() - (factor - 1.0) / tau, 1.0e-11);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // A coupon whose first observation is tomorrow does not require today's fixing.
+    index->clearFixings();
+    Settings::instance().enforcesTodaysHistoricFixings() = true;
+    const Date tomorrow = calendar.advance(today, 1, Days);
+    const Date end = calendar.advance(tomorrow, 10, Days);
+    const OvernightIndexedCoupon future(end, 10000.0, tomorrow, end, index);
+    BOOST_CHECK_NO_THROW(future.rate());
+}
+
 BOOST_AUTO_TEST_CASE(testPastCouponRate) {
     BOOST_TEST_MESSAGE("Testing rate for past overnight-indexed coupon...");