ETM-Schurig/etm-powersync-energy-plugin-etm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
etm-powersync-energy-plugin.../tests/auto/loadmodel/testoptimizerprotocol.cpp
Patrick Schurig 13114a2695 feat(optimiseur): sérialiseur GetPlan, protocole 1.1 §5.1-§5.3 (brief 4 T1) 
OptimizerProtocol::getPlanParams(SurplusContext, ContexteFil) rend les params d'une requête
GetPlan. Fonction pure, compilée dans le plugin mais appelée par personne : sans endpoint,
rien ne change.

- La prévision voyage À CÔTÉ du contexte (§11) : ContexteFil::prevision porte la sortie de
  EnergyArbitrator::instantanePrevision(), l'assemblage partagé avec GetForecastSnapshot.
  forecastDepuisInstantane() la pose sur la grille §5.2 : Wh par pas → p50W moyens
  (Wh × 3600 / resolutionS), case sans point = null, pv null sans courbe, weather null.
- ContexteFil porte aussi trigger (sa source viendra en T3), meter.source, la PV
  instantanée, la limite de phase, la réserve, le domaine et la mesure par charge.
- Inconnu = null ou absent, jamais 0 : contractedPowerW, pv.currentW, capacité et
  puissances batterie, tarif → null ; learned, comfort, group, champs réservés, force,
  powerLevels → absents ; borne configurée sans appareil → ni déclaration ni verrous.
- meter.exportW brut (règle 8). Champs 1.0 conservés ; energyTargets dérivés par
  resolveDeadline (installer) et de la dérogation à cible (user-intent).

Tests (loadmodel, logique pure) : 4 goldens dans data/optimizer (site sans PV ; PV + ECS
relay-router + borne + SG-Ready ; prévision absente ; charge available=false figée),
régénérables sous ETM_REGENERER_GOLDEN=1, plus 3 tests d'assertion. Contre-épreuves :
contractedPowerW à 0, Wh non convertis, exportW net → chacune fait échouer au moins un test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 16:01:34 +02:00

413 lines
18 KiB
C++
Raw Blame History

// SPDX-License-Identifier: GPL-3.0-or-later
//
// Brief 4 T1 — sérialiseur GetPlan (OPTIMIZER_PROTOCOL 1.1 §5).
// Logique pure, comme le reste de cette suite : aucun serveur, aucun arbitre.
#include "testloadmodel.h"
#include "etm/scheduler/optimizerprotocol.h"
#include <QDir>
#include <QFile>
#include <QJsonDocument>
#include <QSet>
#include <QTest>
#include <QTimeZone>
using namespace OptimizerProtocol;
namespace {
//! L'instant de l'exemple du §5.1 : 2026-10-12T13:42:00+02:00.
QDateTime instantExemple()
{
return QDateTime(QDate(2026, 10, 12), QTime(13, 42), QTimeZone(7200));
}
const QString kCompteur = QStringLiteral("{0d4c6a7e-1111-4c1a-9a01-000000000001}");
const QString kEcs = QStringLiteral("{0d4c6a7e-2222-4c1a-9a01-000000000002}");
const QString kBorne = QStringLiteral("{0d4c6a7e-3333-4c1a-9a01-000000000003}");
const QString kPac = QStringLiteral("{0d4c6a7e-4444-4c1a-9a01-000000000004}");
const QString kRouteur = QStringLiteral("{0d4c6a7e-5555-4c1a-9a01-000000000005}");
const QString kPlanSud = QStringLiteral("{0d4c6a7e-6666-4c1a-9a01-000000000006}");
//! Chauffe-eau sur routeur de relais : 2 400 W, plus petit palier 800 W, obligation de 4 kWh à 18 h.
LoadContext chauffeEau(const QString &id = kEcs)
{
LoadContext lc;
lc.id = id;
lc.adapter = QStringLiteral("relay-router");
lc.label = QStringLiteral("Chauffe-eau");
lc.priority = 2;
lc.declared.powerLevels = {0, 800, 1600, 2400}; // non émis (écart E9)
lc.declared.minPowerW = 800;
lc.declared.maxPowerW = 2400;
lc.telemetry.currentPowerW = 1600;
lc.telemetry.lockMinPowerW = 1600;
lc.telemetry.lockMaxPowerW = -1;
lc.needs.dailyDeadline = QStringLiteral("18:00");
lc.needs.minEnergyWhPerDay = 4000;
lc.limits.minOnS = 300;
lc.limits.minOffS = 300;
return lc;
}
LoadContext borne()
{
LoadContext lc;
lc.id = kBorne;
lc.adapter = QStringLiteral("evcharger");
lc.label = QStringLiteral("Borne garage");
lc.priority = 1;
lc.declared.minA = 6;
lc.declared.maxA = 16;
lc.declared.phases = 3;
lc.declared.minPowerW = 4140;
lc.declared.maxPowerW = 11040;
lc.telemetry.currentPowerW = 4100;
lc.telemetry.pluggedIn = true;
lc.telemetry.charging = true;
lc.telemetry.sessionMeasurable = true;
lc.telemetry.sessionWh = 5200;
lc.telemetry.lockMaxPowerW = -1;
lc.needs.targetSocPercent = 80;
lc.needs.deadline = QDateTime(QDate(2026, 10, 13), QTime(7, 0), QTimeZone(7200));
lc.limits.chargingEnabledLockS = 300;
lc.limits.currentChangeLockS = 60;
return lc;
}
LoadContext pac()
{
LoadContext lc;
lc.id = kPac;
lc.adapter = QStringLiteral("sg-ready");
lc.label = QStringLiteral("PAC");
lc.priority = 3;
lc.declared.states = {1, 2, 3, 4};
lc.declared.estimatedPowerW = {{3, 1800}, {4, 2600}};
lc.declared.minPowerW = 1800;
lc.telemetry.state = 2;
lc.telemetry.minState = 2;
lc.telemetry.maxState = 4;
lc.limits.minStateHoldS = 900;
return lc;
}
//! Grille sans courbe de \c instantanePrevision() : minuit local → minuit du surlendemain.
QVariantMap instantaneSansCourbe(const QVariant &price)
{
QVariantList nuls;
for (int i = 0; i < 48; ++i)
nuls << QVariant();
return {{"start", "2026-10-11T22:00:00Z"}, {"resolutionS", 3600}, {"steps", 48},
{"baseload", QVariantMap{{"model", "none"}, {"p50W", nuls}}},
{"price", price}};
}
//! Prix d'un tarif saisi à deux zones, tel que \c seriesConsoEtPrix() le pose sur la grille.
QVariantMap prixTou()
{
QVariantList import, revente;
for (int i = 0; i < 48; ++i) {
const int heureLocale = i % 24;
import << (heureLocale < 6 || heureLocale >= 22 ? 16.96 : 21.46);
revente << 0.0;
}
return {{"currency", "EUR"}, {"importCtkWh", import}, {"exportCtkWh", revente},
{"includes", QStringList{"energy", "grid", "taxes"}}, {"source", "tou"},
{"knownUntil", "2026-10-13T22:00:00Z"}};
}
/*!
* Compare à un fichier de référence de \c data/optimizer. \c ETM_REGENERER_GOLDEN=1 le réécrit
* (et le dit) : une régénération se relit en diff, elle ne se fait jamais en silence.
*/
void comparerAuGolden(const QString &nom, const QVariantMap &params)
{
const QString chemin = QStringLiteral(ETM_GOLDEN_DIR "/%1.json").arg(nom);
const QByteArray obtenu = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented);
if (qEnvironmentVariableIsSet("ETM_REGENERER_GOLDEN")) {
QDir().mkpath(QStringLiteral(ETM_GOLDEN_DIR));
QFile f(chemin);
QVERIFY(f.open(QIODevice::WriteOnly | QIODevice::Truncate));
f.write(obtenu);
qWarning() << "golden RÉÉCRIT :" << chemin;
return;
}
QFile f(chemin);
QVERIFY2(f.open(QIODevice::ReadOnly), qUtf8Printable(QStringLiteral("golden absent : ") + chemin));
const QJsonDocument attendu = QJsonDocument::fromJson(f.readAll());
QVERIFY2(!attendu.isNull(), qUtf8Printable(chemin));
if (attendu != QJsonDocument::fromJson(obtenu)) {
const QString trace = QDir::temp().filePath(nom + QStringLiteral(".obtenu.json"));
QFile t(trace);
if (t.open(QIODevice::WriteOnly | QIODevice::Truncate))
t.write(obtenu);
QFAIL(qUtf8Printable(QStringLiteral("écart au golden %1 — obtenu écrit dans %2")
.arg(chemin, trace)));
}
}
//! Toutes les clés, à toute profondeur, d'une valeur JSON.
void cles(const QVariant &v, QSet<QString> &out)
{
if (v.typeId() == QMetaType::QVariantMap) {
const QVariantMap m = v.toMap();
for (auto it = m.constBegin(); it != m.constEnd(); ++it) {
out.insert(it.key());
cles(it.value(), out);
}
} else if (v.typeId() == QMetaType::QVariantList) {
for (const QVariant &e : v.toList())
cles(e, out);
}
}
} // namespace
void TestLoadModel::testGetPlanParamsGoldenSiteSansPv()
{
SurplusContext ctx;
ctx.timestamp = instantExemple();
ctx.meter.importW = 850;
ctx.meter.perPhaseA = {1.2, 2.3, 0.4};
LoadContext ecs = chauffeEau();
ecs.telemetry.currentPowerW = 0;
ecs.telemetry.lockMinPowerW = 0;
ctx.loads = {ecs};
ContexteFil fil;
fil.meterSource = kCompteur;
fil.phaseLimitA = {32, 32, 32};
fil.domaines.insert(kEcs, QStringLiteral("ecs"));
fil.mesures.insert(kEcs, MesureFil{QStringLiteral("meter"), 0});
// Aucun site de prévision désigné, aucun candidat : l'instantané se tait sur la courbe, mais
// la grille, la base (pas encore de profil) et le tarif saisi restent publiés.
fil.prevision = instantaneSansCourbe(prixTou());
comparerAuGolden(QStringLiteral("site-sans-pv"), getPlanParams(ctx, fil));
}
void TestLoadModel::testGetPlanParamsGoldenPvEcsBorneSgReady()
{
SurplusContext ctx;
ctx.timestamp = instantExemple();
ctx.meter.exportW = 2310;
ctx.meter.perPhaseA = {3.2, 4.1, 2.8};
ctx.battery.present = true;
ctx.battery.socPercent = 62;
ctx.battery.powerW = -800;
LoadContext ecs = chauffeEau();
// Dérogation avec cible : elle devient un besoin `user-intent`.
ecs.derogation = true;
ecs.derogationEndsAt = QDateTime(QDate(2026, 10, 12), QTime(13, 0), QTimeZone::UTC);
ecs.derogationTargetWh = 3000;
ctx.loads = {borne(), ecs, pac()};
ContexteFil fil;
fil.trigger = QStringLiteral("load-change");
fil.meterSource = kCompteur;
fil.pvCurrentW = 3400;
fil.phaseLimitA = {63, 63, 63};
fil.reserveSocPercent = 15;
fil.domaines = {{kBorne, "ev"}, {kEcs, "ecs"}, {kPac, "heating"}};
fil.mesures = {{kBorne, MesureFil{"device", 4100}}, {kEcs, MesureFil{"meter", 1580}},
{kPac, MesureFil{}}};
// Courbe de 6 pas, un trou à 15:00Z : la case reste null, les séries restent alignées.
QVariantList points;
const QList<QPair<QString, double>> pts = {{"2026-10-12T12:00:00Z", 5200}, {"2026-10-12T13:00:00Z", 4800},
{"2026-10-12T14:00:00Z", 3900}, {"2026-10-12T16:00:00Z", 1500},
{"2026-10-12T17:00:00Z", 300}};
for (const auto &p : pts)
points << QVariantMap{{"targetAt", p.first}, {"forecastWh", p.second}};
QVariantMap qualite{{"windowDays", 28}, {"minDays", 7}, {"resolutionS", 3600},
{"daysCovered", QVariantMap{{"workday", 14}, {"weekend", 6}}},
{"minutes", 28800}, {"commandedMinutes", 0}, {"negativeMinutes", 0},
{"incompleteMinutes", 12}, {"computedAt", "2026-10-12T03:00:00Z"},
{"loads", QVariantList{QVariantMap{{"loadId", kEcs}, {"source", "meter"},
{"minutesBySource", QVariantMap{{"meter", 28800}}},
{"constantMeasurement", false}}}}};
fil.prevision = QVariantMap{
{"start", "2026-10-12T12:00:00Z"}, {"resolutionS", 3600}, {"steps", 6},
{"baseload", QVariantMap{{"model", "profile"},
{"p50W", QVariantList{420.0, 380.0, 395.0, 450.0, 610.0, 720.0}},
{"quality", qualite}}},
{"price", QVariant()},
{"issuedAt", "2026-10-12T09:00:00Z"}, {"model", "meteofrance_seamless"},
{"contentChangedAt", "2026-10-12T10:07:00Z"}, {"forecastPoints", points},
{"corrections", QStringList{"temperature", "ac-limit"}},
{"perField", QVariantList{QVariantMap{{"id", kPlanSud},
{"corrections", QStringList{"temperature"}}}}},
{"conversion", "physics"}, {"acLimitW", 8000}};
comparerAuGolden(QStringLiteral("site-pv-ecs-borne-sgready"), getPlanParams(ctx, fil));
}
void TestLoadModel::testGetPlanParamsGoldenPrevisionAbsente()
{
SurplusContext ctx;
ctx.timestamp = instantExemple();
ctx.meter.exportW = 1200;
ctx.meter.perPhaseA = {1.0, 1.0, 1.0};
ctx.loads = {chauffeEau()};
ContexteFil fil;
fil.meterSource = kCompteur;
// Des plans existent mais aucun site n'est désigné : l'instantané porte le motif et AUCUNE
// courbe. Sur le fil, `pv` est null — pas une courbe de zéros — et le reste de la grille tient.
QVariantMap instantane = instantaneSansCourbe(QVariant());
instantane.insert("fault", "MISSING_FORECAST_SITE");
instantane.insert("faultParams", QVariantMap{{"candidates", 2}});
fil.prevision = instantane;
comparerAuGolden(QStringLiteral("prevision-absente"), getPlanParams(ctx, fil));
// Et sans instantané du tout : `forecast` est null (§5.2 « forecast peut être null »).
fil.prevision.reset();
const QVariantMap params = getPlanParams(ctx, fil);
QVERIFY(params.contains("forecast"));
QVERIFY(params.value("forecast").isNull());
}
void TestLoadModel::testGetPlanParamsGoldenChargeIndisponibleFigee()
{
SurplusContext ctx;
ctx.timestamp = instantExemple();
ctx.meter.importW = 1350;
ctx.meter.perPhaseA = {5.9, 0.3, 0.2};
// Routeur en défaut d'écriture : FIGÉ — indisponible, plancher = plafond = puissance crue
// engagée, et toujours compté pour ce qu'il consomme (§5.3, champs ETM).
LoadContext fige = chauffeEau(kRouteur);
fige.label = QStringLiteral("Routeur garage");
fige.needs = LoadNeeds();
fige.telemetry.available = false;
fige.telemetry.currentPowerW = 1200;
fige.telemetry.lockMinPowerW = 1200;
fige.telemetry.lockMaxPowerW = 1200;
fige.telemetry.commandRefused = true; // code seul (écart E7) : non émis
fige.telemetry.refusedSinceS = 340;
// Borne configurée dont l'appareil a disparu (buildContext, 3g-2) : indisponible, sans
// déclaration — ses zéros sont des inconnues et ne sont pas émis.
LoadContext sansAppareil;
sansAppareil.id = kBorne;
sansAppareil.adapter = QStringLiteral("evcharger");
sansAppareil.label = QStringLiteral("Borne garage");
sansAppareil.priority = 1;
sansAppareil.telemetry.available = false;
sansAppareil.telemetry.lockMaxPowerW = -1;
ctx.loads = {sansAppareil, fige};
ContexteFil fil;
fil.meterSource = kCompteur;
fil.mesures.insert(kRouteur, MesureFil{QStringLiteral("none"), 0});
fil.prevision = instantaneSansCourbe(QVariant());
comparerAuGolden(QStringLiteral("charge-indisponible-figee"), getPlanParams(ctx, fil));
}
void TestLoadModel::testGetPlanParamsNeverInventsAValue()
{
// Un contexte tel que buildContext() le rend aujourd'hui : rien ne remplit la puissance
// souscrite, la PV, la capacité batterie, ni le tarif. Leur 0 est une INCONNUE.
SurplusContext ctx;
ctx.timestamp = instantExemple();
ctx.battery.present = true;
ctx.battery.socPercent = 40;
ctx.loads = {chauffeEau(), borne(), pac()};
const QVariantMap p = getPlanParams(ctx, ContexteFil());
QCOMPARE(p.value("trigger").toString(), QStringLiteral("cycle"));
const QVariantMap site = p.value("site").toMap();
for (const char *k : {"contractedPowerW", "gridCapW", "phaseLimitA"}) {
QVERIFY2(site.contains(k) && site.value(k).isNull(), k);
}
QVERIFY(p.value("meter").toMap().value("source").isNull());
QVERIFY(p.value("pv").toMap().contains("currentW"));
QVERIFY(p.value("pv").toMap().value("currentW").isNull());
const QVariantMap bat = p.value("battery").toMap();
for (const char *k : {"capacityWh", "maxChargeW", "maxDischargeW", "reserveSocPercent"}) {
QVERIFY2(bat.contains(k) && bat.value(k).isNull(), k);
}
QVERIFY(p.contains("tariff") && p.value("tariff").isNull());
QVERIFY(p.contains("forecast") && p.value("forecast").isNull());
// Absents, pas null : group (non implémenté), learned (aucun profil reçu), comfort (aucun
// porteur), champs réservés de l'annexe F, et `force`, qui n'existe pas sur le fil.
QSet<QString> toutes;
cles(p, toutes);
for (const char *k : {"group", "learned", "comfort", "socTarget", "policies", "force",
"powerLevels", "drawMargin", "derogation", "commandRefused",
"nominalPowerW", "volumeL", "defaults", "vehicle", "minPowerWAlways"}) {
QVERIFY2(!toutes.contains(QString::fromLatin1(k)), k);
}
// Sans mesure fournie, `measurement` est absent — jamais un {source: none} inventé.
for (const QVariant &l : p.value("loads").toList())
QVERIFY(!l.toMap().value("telemetry").toMap().contains("measurement"));
// Et une réserve renseignée par le CONTEXTE, si un jour il la porte, est reprise.
ctx.battery.reserveSocPercent = 20;
QCOMPARE(getPlanParams(ctx, ContexteFil()).value("battery").toMap()
.value("reserveSocPercent").toInt(), 20);
// Le tarif 1.0 est sérialisé dès qu'une source le remplit (écart E3 : aucune aujourd'hui).
ctx.tariff.provider = QStringLiteral("tempo");
ctx.tariff.current = {QDateTime(), QStringLiteral("HP_BLEU"), 16.1};
ctx.tariff.next = {{QDateTime(QDate(2026, 10, 13), QTime(6, 0), QTimeZone(7200)),
QStringLiteral("ROUGE"), 75.6}};
const QVariantMap t = getPlanParams(ctx, ContexteFil()).value("tariff").toMap();
QCOMPARE(t.value("provider").toString(), QStringLiteral("tempo"));
QCOMPARE(t.value("current").toMap().value("priceCtkWh").toDouble(), 16.1);
QCOMPARE(t.value("next").toList().first().toMap().value("from").toString(),
QStringLiteral("2026-10-13T06:00:00+02:00"));
}
void TestLoadModel::testGetPlanParamsMeterIsRaw()
{
// Règle 8 : la mesure brute du compteur, quelles que soient les charges en marche. Une
// charge qui tire 1 600 W ne « rend » rien à l'export.
SurplusContext ctx;
ctx.timestamp = instantExemple();
ctx.meter.exportW = 700;
ctx.loads = {chauffeEau()};
const QVariantMap m = getPlanParams(ctx, ContexteFil()).value("meter").toMap();
QCOMPARE(m.value("exportW").toDouble(), 700.0);
QCOMPARE(m.value("importW").toDouble(), 0.0);
}
void TestLoadModel::testForecastWhPerStepBecomesMeanPower()
{
// Pas de 15 min : 250 Wh sur le pas = 1 000 W moyens. Le consommateur ne suppose jamais le
// pas (§5.2), le producteur non plus.
const QVariantMap instantane{
{"start", "2026-10-12T12:00:00Z"}, {"resolutionS", 900}, {"steps", 4},
{"forecastPoints", QVariantList{
QVariantMap{{"targetAt", "2026-10-12T12:00:00Z"}, {"forecastWh", 250.0}},
QVariantMap{{"targetAt", "2026-10-12T12:45:00Z"}, {"forecastWh", 100.0}},
// Hors grille ou mal alignés : ignorés, jamais posés dans la case voisine.
QVariantMap{{"targetAt", "2026-10-12T12:20:00Z"}, {"forecastWh", 999.0}},
QVariantMap{{"targetAt", "2026-10-12T13:00:00Z"}, {"forecastWh", 999.0}}}},
{"corrections", QStringList()}, {"conversion", "physics"}, {"perField", QVariantList()},
{"baseload", QVariantMap{{"model", "none"}, {"p50W", QVariantList{QVariant(), QVariant(), QVariant(), QVariant()}}}},
{"price", QVariant()}};
const QVariantMap f = forecastDepuisInstantane(instantane);
const QVariantList p50 = f.value("pv").toMap().value("p50W").toList();
QCOMPARE(p50.size(), 4);
QCOMPARE(p50.at(0).toDouble(), 1000.0);
QVERIFY(p50.at(1).isNull());
QVERIFY(p50.at(2).isNull());
QCOMPARE(p50.at(3).toDouble(), 400.0);
// Liste vide = conversion brute, une affirmation : elle reste une liste, pas une absence.
QVERIFY(f.value("pv").toMap().contains("corrections"));
QVERIFY(f.value("pv").toMap().value("corrections").toList().isEmpty());
// Inconnus du producteur : null, pas absents (§5.2).
QVERIFY(f.value("pv").toMap().value("issuedAt").isNull());
QVERIFY(f.value("pv").toMap().value("weatherModel").isNull());
QVERIFY(f.value("pv").toMap().value("contentChangedAt").isNull());
QVERIFY(!f.value("pv").toMap().contains("acLimitW"));
QVERIFY(f.value("weather").isNull());
// Le texte de faute de l'instantané ne passe jamais sur le fil.
QVERIFY(!f.contains("fault"));
}
Reference in New Issue View Git Blame Copy Permalink