diff --git a/energyplugin/etm/scheduler/optimizerprotocol.cpp b/energyplugin/etm/scheduler/optimizerprotocol.cpp index c78a770..10ba3d7 100644 --- a/energyplugin/etm/scheduler/optimizerprotocol.cpp +++ b/energyplugin/etm/scheduler/optimizerprotocol.cpp @@ -15,10 +15,20 @@ namespace OptimizerProtocol { namespace { -//! Instant absolu, décalage compris (§5.2 « Instants ») ; invalide → \c null. +/*! + * Instant absolu, décalage compris (§5.2 « Instants ») ; invalide → \c null. + * + * Le décalage est celui de l'instant reçu, rendu EXPLICITE : Qt n'en écrit aucun pour une heure + * locale (\c Qt::LocalTime, celle de \c currentDateTime()), et une heure murale nue est refusée + * par tout optimiseur conforme (-32602, constat du 2026-10-21 sous Europe/Berlin). Une heure + * locale garde l'heure du site (« 13:42:00+02:00 »), une heure UTC reste en « Z ». Le décalage + * est lu sur l'INSTANT, pas sur la date : la nuit du passage à l'heure d'hiver, 02:30 sort + * « +02:00 » puis « +01:00 », deux instants distincts. + */ QVariant instant(const QDateTime &dt) { - return dt.isValid() ? QVariant(dt.toString(Qt::ISODate)) : QVariant(); + return dt.isValid() ? QVariant(dt.toOffsetFromUtc(dt.offsetFromUtc()).toString(Qt::ISODate)) + : QVariant(); } QVariantList liste(const QList &v) diff --git a/tests/auto/conformance/README.md b/tests/auto/conformance/README.md index d135e75..58ee026 100644 --- a/tests/auto/conformance/README.md +++ b/tests/auto/conformance/README.md @@ -15,6 +15,7 @@ adaptateurs, sur les mocks de la suite `simulation` — et vérifie, une fonctio | `testARefusedHandshakeIsClosedByTheOptimizer` | protocole 1.2, §3 : handshake d'une autre majeure → `-32602`, puis l'optimiseur **ferme** ; si un token est attendu, token faux → `-32001`, fermé pareil | | `testABatchIsRefused` | protocole 1.2, §2 : un lot `[…]` → **une** erreur `-32600` à `id: null`, rien du lot traité, connexion gardée | | `testALineOverTheLimitIsRefused` | protocole 1.2, §2 : une ligne de `maxLineBytes` + 1 octets → `-32600` à `id: null`, connexion gardée ; une ligne d'exactement `maxLineBytes` est lue | +| `testTheSessionMatchesTheContractOffUtc` | la fonction 3, le moteur sous un fuseau **non UTC** (`Europe/Berlin`) et cadencé en heure locale comme en production, à travers le passage à l'heure d'hiver (02:58 CEST → 02:01 CET) : aucun échec de requête, session conforme au contrat embarqué (tout instant porte son décalage, §5.2) | Ces deux dernières lignes valent pour le mode `plan` (défaut). Voir **Optimiseur qui s'abstient**. @@ -23,7 +24,7 @@ que son client n'envoie jamais, et lisent la réponse brute (un lot renvoyé se utilisent des requêtes dont la réponse est normée sans contexte — `UpdateLearned` avec `id` → `-32601` (§8) — pour constater qu'un message a été, ou n'a pas été, traité. -Les fonctions 2 à 5 passent par un relais transparent (une ligne reçue = une ligne renvoyée) qui +Les fonctions 2 à 5 et 10 passent par un relais transparent (une ligne reçue = une ligne renvoyée) qui capture la session et mesure les délais ; la 5 est la seule où il réécrit une réponse. Banc : deux charges `etmvariableload` (0–2 000 W ; plancher 800, 3 000 W) et une PAC SG-Ready (P3 1 500 W, P4 3 000 W) ; surplus de −1 000 à 9 000 W. @@ -40,7 +41,8 @@ export NYMEA_PLUGINS_PATH=/tests/mocks/plugins/energymocks:/usr/lib/x86_6 export ETM_POWERSYNC_OPTIMIZER_CMD='exec /chemin/de/mon-optimiseur --listen {endpoint}' for fn in testHandshakeIsAccepted testGetPlanIsAnsweredInTime testTheSessionMatchesTheContract \ testEveryPlanIsAccepted testTheSafetyLoopStaysOnTop testGetPlanBeforeTheHandshakeIsRefused \ - testARefusedHandshakeIsClosedByTheOptimizer testABatchIsRefused testALineOverTheLimitIsRefused; do + testARefusedHandshakeIsClosedByTheOptimizer testABatchIsRefused testALineOverTheLimitIsRefused \ + testTheSessionMatchesTheContractOffUtc; do systemd-run --user --scope -q -p MemoryMax=2G \ bwrap --dev-bind / / --unshare-net --tmpfs /tmp --bind "$PWD/../../.." "$PWD/../../.." \ --bind --chdir "$PWD" ./target_wrapper.sh ./etm-powersync-optimizer-conformance "$fn" diff --git a/tests/auto/conformance/testconformance.cpp b/tests/auto/conformance/testconformance.cpp index 5b0f09f..92403de 100644 --- a/tests/auto/conformance/testconformance.cpp +++ b/tests/auto/conformance/testconformance.cpp @@ -20,7 +20,9 @@ // 6 à 9 (protocole 1.2). Ce que le moteur n'envoie JAMAIS, envoyé par une connexion de SONDE // (sans le moteur) : GetPlan avant le handshake (-32600, connexion gardée), handshake d'une // autre majeure (-32602 puis fermeture par l'optimiseur), lot (-32600 à id null, rien du lot -// traité), ligne de plus de 1 Mio (-32600 à id null, connexion gardée). +// traité), ligne de plus de 1 Mio (-32600 à id null, connexion gardée) ; +// 10. le point 3, le moteur réglé sur un fuseau NON UTC (Europe/Berlin) et cadencé en heure +// locale comme en production, à travers le passage à l'heure d'hiver. // // Mode attendu ($ETM_POWERSYNC_CONFORMANCE_EXPECT, défaut `plan`) : `abstain` juge un optimiseur // qui s'abstient toujours (§7, réponse permise) — le point 4 exige alors une abstention à chaque @@ -387,6 +389,15 @@ QString verifierErreur(const QByteArray &ligne, const QJsonValue &id, int code) return QString(); } +//! Le fuseau de la BOX, posé par le test et rendu en sortant (même garde que `simulation`). +struct FuseauDeTest { + QByteArray avant; + bool avait; + explicit FuseauDeTest(const QByteArray &tz) : avant(qgetenv("TZ")), avait(qEnvironmentVariableIsSet("TZ")) + { qputenv("TZ", tz); } + ~FuseauDeTest() { if (avait) qputenv("TZ", avant); else qunsetenv("TZ"); } +}; + QString cle(const QVariantMap &v) { return QString::fromUtf8(QJsonDocument::fromVariant(v).toJson(QJsonDocument::Compact)); @@ -408,6 +419,7 @@ private slots: void testARefusedHandshakeIsClosedByTheOptimizer(); void testABatchIsRefused(); void testALineOverTheLimitIsRefused(); + void testTheSessionMatchesTheContractOffUtc(); private: void monter(); @@ -424,6 +436,8 @@ private: //! Lance l'optimiseur et y branche le moteur (directement, ou par le relais). void brancher(bool parLeRelais); void cycle(const QDateTime &t); + //! La session capturée par le relais, jugée par le validateur publié (point 3 et point 10). + void jugerLaSession(); //! Une série de cycles qui parcourt le banc : import, demi-charge, PAC en 3, puis en 4. void parcours(const QDateTime &t0); QVariantMap etatApplique() const; @@ -707,6 +721,11 @@ void TestOptimizerConformance::testTheSessionMatchesTheContract() if (QTest::currentTestFailed()) return; parcours(utcDateTime(QDate(2026, 6, 8), QTime(9, 0, 0))); + jugerLaSession(); +} + +void TestOptimizerConformance::jugerLaSession() +{ QTemporaryDir dir; QVERIFY(dir.isValid()); const Contrat::Verdict v = Contrat::juger(m_relais->session, @@ -935,5 +954,34 @@ void TestOptimizerConformance::testALineOverTheLimitIsRefused() QVERIFY2(e.isEmpty(), qUtf8Printable(e)); } +// --- 10 -------------------------------------------------------------------------------------------- + +void TestOptimizerConformance::testTheSessionMatchesTheContractOffUtc() +{ + // Constat VM du 2026-10-21 : sous Europe/Berlin, l'optimiseur conforme refusait CHAQUE GetPlan + // (-32602, `params.timestamp` sans décalage), et les points 2 à 5 ne pouvaient pas le voir — ils + // cadencent le moteur en UTC. Ici, le fuseau de la box n'est pas UTC et les cycles sont en + // Qt::LocalTime, comme `QDateTime::currentDateTime()` en production. Le parcours démarre à + // 02:58 CEST le 2026-10-25 et traverse le retour à 02:00 CET : les deux décalages, et l'heure + // ambiguë, passent sur le fil. + FuseauDeTest fuseau("Europe/Berlin"); + monter(); + if (QTest::currentTestFailed()) + return; + brancher(true); + if (QTest::currentTestFailed()) + return; + const QDateTime t0 = utcDateTime(QDate(2026, 10, 25), QTime(0, 58, 0)).toLocalTime(); + QCOMPARE(t0.timeSpec(), Qt::LocalTime); + QCOMPARE(t0.offsetFromUtc(), 7200); + QCOMPARE(t0.addSecs(30 * 7).offsetFromUtc(), 3600); + parcours(t0); + if (QTest::currentTestFailed()) + return; + // Le jugement de l'optimiseur d'abord : un refus du contexte se lit ici, avec son code. + QVERIFY2(m_echecs.isEmpty(), qUtf8Printable("requêtes en échec : " + m_echecs.join(", "))); + jugerLaSession(); +} + QTEST_MAIN(TestOptimizerConformance) #include "testconformance.moc" diff --git a/tests/auto/loadmodel/testloadmodel.h b/tests/auto/loadmodel/testloadmodel.h index 6afbfce..eee8283 100644 --- a/tests/auto/loadmodel/testloadmodel.h +++ b/tests/auto/loadmodel/testloadmodel.h @@ -150,6 +150,12 @@ private slots: void testGetPlanParamsMeterIsRaw(); //! Wh par pas → puissance moyenne ; une case sans point reste null. void testForecastWhPerStepBecomesMeanPower(); + //! Un contexte en HEURE LOCALE (celle de currentDateTime()) émet des instants AVEC décalage, + //! sous plusieurs fuseaux, été comme hiver (constat VM du 2026-10-21 : -32602 à chaque cycle). + void testGetPlanParamsInstantsCarryTheirOffset_data(); + void testGetPlanParamsInstantsCarryTheirOffset(); + //! Nuit du changement d'heure : 02:30 ambiguë (hiver) et inexistante (été) → instants exacts. + void testGetPlanParamsInstantsAcrossTheDstChange(); // ── Brief 4 T5 — catalogue des motifs (corps dans testdecisioncatalogue.cpp) ── //! Anti-dérive : knownCodes() == les constantes de l'en-tête, chacune avec un rendu connu. diff --git a/tests/auto/loadmodel/testoptimizerprotocol.cpp b/tests/auto/loadmodel/testoptimizerprotocol.cpp index 52ed4a8..c2e04ab 100644 --- a/tests/auto/loadmodel/testoptimizerprotocol.cpp +++ b/tests/auto/loadmodel/testoptimizerprotocol.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -164,6 +165,38 @@ void cles(const QVariant &v, QSet &out) } } +//! Le fuseau de la BOX, posé par le test et rendu en sortant (même garde que `simulation`). +struct FuseauDeTest { + QByteArray avant; + bool avait; + explicit FuseauDeTest(const QByteArray &tz) : avant(qgetenv("TZ")), avait(qEnvironmentVariableIsSet("TZ")) + { qputenv("TZ", tz); } + ~FuseauDeTest() { if (avait) qputenv("TZ", avant); else qunsetenv("TZ"); } +}; + +//! Le motif `pattern` des instants du contrat OpenRPC (identique à `INSTANT` du validateur). +const QRegularExpression kMotifInstant( + QStringLiteral("^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}(:[0-9]{2}(\\.[0-9]+)?)?(Z|[+-][0-9]{2}:[0-9]{2})$")); + +//! Chaque instant émis (clés `timestamp`, `deadline`, `by`, `from`), avec son chemin. +void instantsEmis(const QVariant &v, const QString &chemin, QList> &out) +{ + if (v.typeId() == QMetaType::QVariantMap) { + const QVariantMap m = v.toMap(); + for (auto it = m.constBegin(); it != m.constEnd(); ++it) { + const QString ici = chemin + QLatin1Char('.') + it.key(); + if (QStringList{"timestamp", "deadline", "by", "from"}.contains(it.key()) && !it.value().isNull()) + out << qMakePair(ici, it.value().toString()); + else + instantsEmis(it.value(), ici, out); + } + } else if (v.typeId() == QMetaType::QVariantList) { + const QVariantList l = v.toList(); + for (int i = 0; i < l.size(); ++i) + instantsEmis(l.at(i), chemin + QStringLiteral("[%1]").arg(i), out); + } +} + } // namespace void TestLoadModel::testGetPlanParamsGoldenSiteSansPv() @@ -410,3 +443,112 @@ void TestLoadModel::testForecastWhPerStepBecomesMeanPower() // Le texte de faute de l'instantané ne passe jamais sur le fil. QVERIFY(!f.contains("fault")); } + +void TestLoadModel::testGetPlanParamsInstantsCarryTheirOffset_data() +{ + QTest::addColumn("fuseau"); + QTest::addColumn("jour"); + QTest::addColumn("attendu"); + QTest::newRow("Europe/Berlin, été") << QByteArray("Europe/Berlin") << QDate(2026, 7, 15) + << QStringLiteral("2026-07-15T13:42:00+02:00"); + QTest::newRow("Europe/Berlin, hiver") << QByteArray("Europe/Berlin") << QDate(2026, 1, 15) + << QStringLiteral("2026-01-15T13:42:00+01:00"); + QTest::newRow("America/New_York, hiver") << QByteArray("America/New_York") << QDate(2026, 1, 15) + << QStringLiteral("2026-01-15T13:42:00-05:00"); + QTest::newRow("Asia/Kolkata, demi-heure") << QByteArray("Asia/Kolkata") << QDate(2026, 7, 15) + << QStringLiteral("2026-07-15T13:42:00+05:30"); + QTest::newRow("UTC") << QByteArray("UTC") << QDate(2026, 7, 15) + << QStringLiteral("2026-07-15T13:42:00Z"); +} + +void TestLoadModel::testGetPlanParamsInstantsCarryTheirOffset() +{ + // Constat VM du 2026-10-21 (fuseau Europe/Berlin) : l'optimiseur conforme refusait CHAQUE + // GetPlan, `params.timestamp` sans décalage. En production `now` vient de + // QDateTime::currentDateTime(), donc en Qt::LocalTime — pour laquelle Qt n'écrit aucun + // décalage. Les goldens, construits en UTC ou à décalage fixe, ne pouvaient pas le voir. + QFETCH(QByteArray, fuseau); + QFETCH(QDate, jour); + QFETCH(QString, attendu); + FuseauDeTest garde(fuseau); + const QDateTime now(jour, QTime(13, 42)); + QCOMPARE(now.timeSpec(), Qt::LocalTime); + + // Tous les instants du contexte en heure locale : échéance quotidienne résolue sur `now` + // (energyTargets installer), fin de dérogation (user-intent), échéance VE, tarif suivant. + SurplusContext ctx; + ctx.timestamp = now; + LoadContext ecs = chauffeEau(); + ecs.derogation = true; + ecs.derogationEndsAt = now.addSecs(3600); + ecs.derogationTargetWh = 3000; + LoadContext ev = borne(); + ev.needs.deadline = QDateTime(jour.addDays(1), QTime(7, 0)); + ctx.loads = {ecs, ev, pac()}; + ctx.tariff.provider = QStringLiteral("tempo"); + ctx.tariff.current = {QDateTime(), QStringLiteral("HP_BLEU"), 16.1}; + ctx.tariff.next = {{QDateTime(jour.addDays(1), QTime(6, 0)), QStringLiteral("ROUGE"), 75.6}}; + const QVariantMap p = getPlanParams(ctx, ContexteFil()); + + QCOMPARE(p.value("timestamp").toString(), attendu); + QList> instants; + instantsEmis(p, QStringLiteral("params"), instants); + QCOMPARE(instants.size(), 5); // timestamp, deadline, by ×2, tariff.next[0].from + for (const auto &i : instants) { + QVERIFY2(kMotifInstant.match(i.second).hasMatch(), qUtf8Printable(i.first + " = " + i.second)); + // Relu, l'instant ne dépend plus du fuseau du lecteur : c'est un instant absolu. + QVERIFY2(QDateTime::fromString(i.second, Qt::ISODate).timeSpec() != Qt::LocalTime, + qUtf8Printable(i.first + " = " + i.second)); + } + QCOMPARE(QDateTime::fromString(p.value("timestamp").toString(), Qt::ISODate).toSecsSinceEpoch(), + now.toSecsSinceEpoch()); +} + +void TestLoadModel::testGetPlanParamsInstantsAcrossTheDstChange() +{ + FuseauDeTest garde("Europe/Berlin"); + auto emis = [](const QDateTime &t) { + SurplusContext ctx; + ctx.timestamp = t; + return getPlanParams(ctx, ContexteFil()).value("timestamp").toString(); + }; + + // HEURE D'HIVER, 2026-10-25 : à 03:00 CEST on revient à 02:00 CET. 02:30 murale a lieu DEUX + // fois ; sans décalage, deux cycles distants d'une heure émettaient la même chaîne. + const QDateTime premiere = QDateTime(QDate(2026, 10, 25), QTime(0, 30), QTimeZone::UTC).toLocalTime(); + const QDateTime seconde = QDateTime(QDate(2026, 10, 25), QTime(1, 30), QTimeZone::UTC).toLocalTime(); + QCOMPARE(premiere.time(), QTime(2, 30)); + QCOMPARE(seconde.time(), QTime(2, 30)); + QCOMPARE(emis(premiere), QStringLiteral("2026-10-25T02:30:00+02:00")); + QCOMPARE(emis(seconde), QStringLiteral("2026-10-25T02:30:00+01:00")); + + // HEURE D'ÉTÉ, 2026-03-29 : à 02:00 CET on passe à 03:00 CEST, 02:30 murale n'existe pas. + // Une horloge système ne la rend jamais ; un instant construit dessus est résolu par Qt, et + // l'émis désigne CET instant-là, sous une heure qui existe. + const QDateTime inexistante(QDate(2026, 3, 29), QTime(2, 30)); + QVERIFY(inexistante.isValid()); + const QString e = emis(inexistante); + QVERIFY2(kMotifInstant.match(e).hasMatch(), qUtf8Printable(e)); + QCOMPARE(QDateTime::fromString(e, Qt::ISODate).toSecsSinceEpoch(), inexistante.toSecsSinceEpoch()); + QCOMPARE(emis(QDateTime(QDate(2026, 3, 29), QTime(1, 30), QTimeZone::UTC).toLocalTime()), + QStringLiteral("2026-03-29T03:30:00+02:00")); + + // Un cycle par minute À TRAVERS chacune des deux nuits : chaînes toutes distinctes, conformes, + // et relues dans l'ordre strict des instants — aucune ambiguïté, aucun trou. + for (const QDate &nuit : {QDate(2026, 10, 25), QDate(2026, 3, 29)}) { + const QDateTime debut(nuit, QTime(0, 0), QTimeZone::UTC); + QSet vues; + qint64 precedent = -1; + for (int m = 0; m <= 180; ++m) { + const QDateTime t = debut.addSecs(60 * m).toLocalTime(); + const QString s = emis(t); + QVERIFY2(kMotifInstant.match(s).hasMatch(), qUtf8Printable(s)); + QVERIFY2(!vues.contains(s), qUtf8Printable(QStringLiteral("instant émis deux fois : ") + s)); + vues.insert(s); + const qint64 relu = QDateTime::fromString(s, Qt::ISODate).toSecsSinceEpoch(); + QCOMPARE(relu, t.toSecsSinceEpoch()); + QVERIFY(relu > precedent); + precedent = relu; + } + } +}