Enelix-EMS/tests/Symcon/modules/VerbraucherEinStufig.php

<?php

declare(strict_types=1);

use Belevo\EnelixEMS\SymconTest\TestContext;

return static function (TestContext $test): void {
    $kontaktId = $test->createActionVariable('Schaltkontakt');
    $rueckmeldungId = $test->createVariable(0, 'Rückmeldung', false);
    $verbraucherId = $test->createInstance(
        '{15879A4E-D0C2-4495-83DE-46E1E462591E}',
        'Verbraucher 1-Stufig',
        [
            'Nennleistung' => 1200,
            'SchaltkontaktVariableID' => $kontaktId,
            'RueckmeldungVariableID' => $rueckmeldungId,
            'Mindestlaufzeit' => 0,
            'Mindesteinschaltdauer' => 2,
            'Mindestausschaltdauer' => 2,
            'VorgabeTimeout' => 30,
            'DiagnosevariablenAnzeigen' => true,
        ]
    );
    $managerId = $test->createInstance(
        '{6F771B18-59D4-4C8A-B951-3B2FE9F6A2C4}',
        'Hilfsmanager',
        [
            'AutomatischeSuche' => false,
            'VerbraucherZuordnung' => json_encode([
                ['InstanzID' => $verbraucherId, 'Aktiv' => true],
            ], JSON_THROW_ON_ERROR),
        ]
    );

    $anforderungSenden = static function (
        ?int $leistung,
        string $betriebsart = 'PV'
    ) use (
        $managerId,
        $verbraucherId
    ): void {
        $paket = [
            'Kopf' => [
                'Version' => '4.0',
                'AbsenderID' => $managerId,
                'EmpfaengerID' => $verbraucherId,
                'Zeitpunkt' => time(),
            ],
            'Betriebsart' => $betriebsart,
            'Sollleistung_W' => $leistung,
        ];
        IPS_RequestAction(
            $verbraucherId,
            'ManagerdatenEmpfangen',
            json_encode($paket, JSON_THROW_ON_ERROR)
        );
    };
    $test->runCase('Instanz und Diagnosevariablen werden angelegt', static function (
        TestContext $test
    ) use ($verbraucherId): void {
        $test->assertInstanceStatus($verbraucherId);
        foreach ([
            'Aktiv', 'Schaltzustand', 'Tageslaufzeit', 'Istleistung', 'Sollleistung',
            'AenderungMoeglich', 'Rueckmeldefehler', 'SchaltbefehlAusstehend',
            'RestMindestzeit',
        ] as $ident) {
            $test->objectByIdent($ident, $verbraucherId);
        }
    });

    $test->runCase('PV und Peak liefern unterschiedliche Leistungsangebote', static function (
        TestContext $test
    ) use ($verbraucherId, $anforderungSenden): void {
        IPS_RequestAction($verbraucherId, 'Aktiv', true);
        IPS_Sleep(2100);
        $anforderungSenden(null, 'Peak');

        $abgewiesen = false;
        try {
            $anforderungSenden(1200, 'Peak');
        } catch (Throwable $fehler) {
            $abgewiesen = true;
        }
        if (!$abgewiesen) {
            $abgewiesen = GetValue($test->objectByIdent('SollwertGueltig', $verbraucherId)) !== true
                || GetValue($test->objectByIdent('Sollleistung', $verbraucherId)) !== 1200;
        }
        $test->assertSame(true, $abgewiesen, 'Peak darf die Nennleistung nicht anbieten.');

        $anforderungSenden(null, 'PV');
    });

    $test->runCase('Nur angebotene Leistungsanforderungen werden angenommen', static function (
        TestContext $test
    ) use (
        $verbraucherId,
        $kontaktId,
        $rueckmeldungId,
        $anforderungSenden
    ): void {
        IPS_RequestAction($verbraucherId, 'Aktiv', true);
        IPS_Sleep(2100);

        $anforderungSenden(600);
        $test->assertSame(false, GetValue($kontaktId));
        $test->assertSame(
            0,
            (int) GetValue($test->objectByIdent('Sollleistung', $verbraucherId))
        );
        $anforderungSenden(1200);
        $test->waitUntil(static fn (): bool => GetValue($kontaktId) === true);
        $test->assertSame(false, GetValue(
            $test->objectByIdent('Schaltzustand', $verbraucherId)
        ));
        $test->assertSame(true, GetValue(
            $test->objectByIdent('SchaltbefehlAusstehend', $verbraucherId)
        ));

        SetValue($rueckmeldungId, true);
        $test->waitUntil(static fn (): bool => GetValue(
            $test->objectByIdent('Schaltzustand', $verbraucherId)
        ) === true);
        $test->assertSame(
            1200,
            (int) round((float) GetValue($test->objectByIdent('Istleistung', $verbraucherId)))
        );
    });

    $test->runCase('Mindesteinschaltdauer verhindert zu frühes Ausschalten', static function (
        TestContext $test
    ) use (
        $verbraucherId,
        $kontaktId,
        $rueckmeldungId,
        $anforderungSenden
    ): void {
        $anforderungSenden(0);
        $test->assertSame(true, GetValue($kontaktId));
        $test->assertTrue(
            (int) GetValue($test->objectByIdent('RestMindestzeit', $verbraucherId)) > 0
        );

        IPS_Sleep(2100);
        $anforderungSenden(0);
        $test->waitUntil(static fn (): bool => GetValue($kontaktId) === false);
        $test->assertSame(true, GetValue(
            $test->objectByIdent('SchaltbefehlAusstehend', $verbraucherId)
        ));

        SetValue($rueckmeldungId, false);
        $test->waitUntil(static fn (): bool => GetValue(
            $test->objectByIdent('Schaltzustand', $verbraucherId)
        ) === false);
    });

    $test->runCase('Mindestausschaltdauer verhindert zu frühes Einschalten', static function (
        TestContext $test
    ) use (
        $kontaktId,
        $rueckmeldungId,
        $anforderungSenden
    ): void {
        $anforderungSenden(1200);
        $test->assertSame(false, GetValue($kontaktId));

        IPS_Sleep(2100);
        $anforderungSenden(1200);
        $test->waitUntil(static fn (): bool => GetValue($kontaktId) === true);
        SetValue($rueckmeldungId, true);
    });

    $test->runCase('Peak kann die Tagesmindestlaufzeit ohne angebotene Sperre erzwingen', static function (
        TestContext $test
    ) use (
        $verbraucherId,
        $kontaktId,
        $rueckmeldungId,
        $anforderungSenden
    ): void {
        IPS_Sleep(2100);
        $anforderungSenden(0);
        $test->waitUntil(static fn (): bool => GetValue($kontaktId) === false);
        SetValue($rueckmeldungId, false);
        $test->waitUntil(static fn (): bool => GetValue(
            $test->objectByIdent('Schaltzustand', $verbraucherId)
        ) === false);
        IPS_Sleep(2100);

        $anforderungSenden(null, 'Peak');
        IPS_SetProperty($verbraucherId, 'PeakSperreBeiMindestlaufzeitAnbieten', false);
        IPS_SetProperty($verbraucherId, 'Mindestlaufzeit', 86400);
        IPS_ApplyChanges($verbraucherId);
        $test->waitUntil(static fn (): bool => GetValue($kontaktId) === true);
        $test->assertSame(1200, (int) GetValue(
            $test->objectByIdent('Sollleistung', $verbraucherId)
        ));
        SetValue($rueckmeldungId, true);
        $test->waitUntil(static fn (): bool => GetValue(
            $test->objectByIdent('Schaltzustand', $verbraucherId)
        ) === true);

        IPS_SetProperty($verbraucherId, 'Mindestlaufzeit', 0);
        IPS_SetProperty($verbraucherId, 'PeakSperreBeiMindestlaufzeitAnbieten', true);
        IPS_ApplyChanges($verbraucherId);
        $anforderungSenden(null, 'PV');
    });

    $test->runCase('Physische Rückmeldung bestätigt und überwacht den Zustand', static function (
        TestContext $test
    ) use ($verbraucherId, $kontaktId, $rueckmeldungId): void {
        $test->assertSame(true, GetValue($kontaktId));
        SetValue($rueckmeldungId, false);
        IPS_RequestAction($verbraucherId, 'Melden', true);
        $test->waitUntil(static fn (): bool => GetValue(
            $test->objectByIdent('Rueckmeldefehler', $verbraucherId)
        ) === true);
        $test->assertSame(true, GetValue(
            $test->objectByIdent('Stoerung', $verbraucherId)
        ));

        SetValue($rueckmeldungId, true);
        IPS_RequestAction($verbraucherId, 'Melden', true);
        $test->waitUntil(static fn (): bool => GetValue(
            $test->objectByIdent('Rueckmeldefehler', $verbraucherId)
        ) === false);
        $test->assertInstanceStatus($verbraucherId);
    });

    $test->runCase('Deaktivierung verwirft eine positive Vorgabe vollstaendig', static function (
        TestContext $test
    ) use ($verbraucherId, $anforderungSenden): void {
        IPS_SetProperty($verbraucherId, 'Mindestlaufzeit', 0);
        IPS_SetProperty($verbraucherId, 'Mindesteinschaltdauer', 0);
        IPS_SetProperty($verbraucherId, 'Mindestausschaltdauer', 0);
        IPS_ApplyChanges($verbraucherId);
        $anforderungSenden(1200);
        $test->assertSame(1200, GetValue($test->objectByIdent('Sollleistung', $verbraucherId)));
        IPS_RequestAction($verbraucherId, 'Aktiv', false);
        $test->assertSame(false, GetValue($test->objectByIdent('SollwertGueltig', $verbraucherId)));
        $test->assertSame(0, GetValue($test->objectByIdent('Sollleistung', $verbraucherId)));
    });
};