etm-powersync-energy-plugin-etm/tests/auto/loadmodel/testloadmodel.cpp

// SPDX-License-Identifier: GPL-3.0-or-later

#include "testloadmodel.h"

#include "etm/adapters/relayrouter.h"
#include "etm/energyarbitrator.h"
#include "etm/types/loadconfig.h"

#include <QTest>

namespace {

//! Une config relay-router minimale, valide, dont on ne fait varier que les relais.
LoadConfig relayLoad(const QList<QPair<QString, int>> &relays,
                     const QString &label = QStringLiteral("chauffe-eau"),
                     int priority = 1)
{
    QVariantList list;
    for (const auto &r : relays) {
        QVariantMap m;
        m.insert("thingId", r.first);
        m.insert("powerW", r.second);
        list.append(m);
    }
    QVariantMap map;
    map.insert("id", "chauffe-eau");
    map.insert("label", label);
    map.insert("adapter", "relay-router");
    map.insert("mode", "fixed");
    map.insert("priority", priority);
    map.insert("enabled", true);
    map.insert("minOnS", 60);
    map.insert("minOffS", 60);
    map.insert("relays", list);
    return LoadConfig::fromMap(map);
}

const QString K1 = QStringLiteral("{aaaaaaaa-0000-0000-0000-000000000001}");
const QString K2 = QStringLiteral("{bbbbbbbb-0000-0000-0000-000000000002}");
const QString K3 = QStringLiteral("{cccccccc-0000-0000-0000-000000000003}");

} // namespace

void TestLoadModel::testStageTableIsDerivedFromSubsetSums()
{
    // La configuration réelle du banc .75 : trois contacteurs 500 / 1 000 / 2 000 W.
    const RelayStageTable t = RelayRouter::deriveStages(
        relayLoad({{K1, 500}, {K2, 1000}, {K3, 2000}}).relaysList());

    QCOMPARE(t.levels, (QList<int>{0, 500, 1000, 1500, 2000, 2500, 3000, 3500}));
    QCOMPARE(t.mapping.size(), t.levels.size());

    // Le palier 0 est le sous-ensemble vide : aucun contact fermé. C'est ce qui garantit
    // qu'un routeur sait toujours s'arrêter.
    QCOMPARE(t.levels.first(), 0);
    QVERIFY(t.mapping.first().isEmpty());

    // Et le maximum est bien la somme de tout — c'est le maxStageW publié en télémétrie.
    QCOMPARE(t.levels.last(), 3500);
    QCOMPARE(t.mapping.last().size(), 3);
}

void TestLoadModel::testRelayOrderIsInertWhenPowersAreDistinct()
{
    const RelayStageTable direct = RelayRouter::deriveStages(
        relayLoad({{K1, 500}, {K2, 1000}, {K3, 2000}}).relaysList());
    const RelayStageTable inverse = RelayRouter::deriveStages(
        relayLoad({{K3, 2000}, {K2, 1000}, {K1, 500}}).relaysList());

    // Chaque somme n'a qu'une seule combinaison possible : la déduplication n'arbitre rien,
    // donc l'ordre de déclaration ne peut rien changer d'ÉLECTRIQUE.
    QCOMPARE(direct.levels, inverse.levels);

    // Les listes de ThingIds, elles, diffèrent : elles sont collectées dans l'ordre de
    // déclaration, donc le palier 1 500 W sort {K1,K2} d'un côté et {K2,K1} de l'autre.
    // C'est le même geste électrique — d'où la comparaison par ENSEMBLE dans la table.
    // Ce cas a fait échouer la première version de operator==, qui comparait les listes.
    QVERIFY2(direct == inverse,
             "un réordonnancement à puissances distinctes doit rendre la même table");
}

void TestLoadModel::testRelayOrderDecidesWhichContactServesATiedStage()
{
    // Deux relais de MÊME puissance : le palier 1 000 W est atteignable par K1 seul comme
    // par K2 seul. La table retient la PREMIÈRE combinaison rencontrée.
    const RelayStageTable a = RelayRouter::deriveStages(
        relayLoad({{K1, 1000}, {K2, 1000}}).relaysList());
    const RelayStageTable b = RelayRouter::deriveStages(
        relayLoad({{K2, 1000}, {K1, 1000}}).relaysList());

    // Mêmes puissances atteignables…
    QCOMPARE(a.levels, (QList<int>{0, 1000, 2000}));
    QCOMPARE(a.levels, b.levels);

    // …mais pas le même contacteur pour le palier 1 000 W. C'est un vrai changement
    // matériel : autre contact qui s'use, autre résistance qui chauffe.
    QCOMPARE(a.mapping.at(1), QList<QString>{K1});
    QCOMPARE(b.mapping.at(1), QList<QString>{K2});
    QVERIFY(a != b);
}

void TestLoadModel::testReorderingDistinctRelaysKeepsTheAdapter()
{
    const LoadConfig avant = relayLoad({{K1, 500}, {K2, 1000}, {K3, 2000}});
    const LoadConfig apres = relayLoad({{K3, 2000}, {K1, 500}, {K2, 1000}});

    // Le geste que l'installateur fait dans l'app : remonter une ligne. Mêmes Things,
    // mêmes puissances, même table — donc aucune reconstruction, donc pas de contacts
    // ouverts par l'état sûr ni de verrous réarmés à froid.
    QVERIFY2(EnergyArbitrator::sameHardware(avant, apres),
             "un réordonnancement sans effet sur la table coupait la charge");
}

void TestLoadModel::testSwappingTiedRelaysRebuilds()
{
    const LoadConfig avant = relayLoad({{K1, 1000}, {K2, 1000}});
    const LoadConfig apres = relayLoad({{K2, 1000}, {K1, 1000}});

    // Ici la table change : le palier 1 000 W passe d'un contacteur à l'autre. Comparer les
    // relais comme un ENSEMBLE aurait manqué ce changement et laissé l'adaptateur commander
    // le mauvais contact.
    QVERIFY2(!EnergyArbitrator::sameHardware(avant, apres),
             "un échange de contacts à puissance égale doit reconstruire");
}

void TestLoadModel::testSoftFieldsNeverRebuild()
{
    const QList<QPair<QString, int>> relays{{K1, 500}, {K2, 1000}};
    const LoadConfig avant = relayLoad(relays, QStringLiteral("chauffe-eau"), 1);
    const LoadConfig apres = relayLoad(relays, QStringLiteral("Ballon 200 L"), 3);

    // Renommer et changer de rang se met à jour EN PLACE (ECS-412). Le libellé part
    // désormais à l'adaptateur par updateSoftConfig() — sans quoi le journal de la box
    // continuait d'imprimer l'ancien nom alors que GetLoadConfig rendait le nouveau.
    QVERIFY(EnergyArbitrator::sameHardware(avant, apres));
}

QTEST_MAIN(TestLoadModel)