Enelix-EMS/tests/LadestationReglerTest.php

<?php

declare(strict_types=1);

namespace Belevo\EnelixEMS\Tests;

use Belevo\EnelixEMS\LadestationRegler;
use PHPUnit\Framework\TestCase;

final class LadestationReglerTest extends TestCase
{
    public function testPhasenprobeUnterscheidetBeiMindeststromOhneMaximalstromsprung(): void
    {
        self::assertSame(
            LadestationRegler::PHASEN_EIN,
            LadestationRegler::erkennePhasenzahlAusLeistung(1380.0, 6)
        );
        self::assertSame(
            LadestationRegler::PHASEN_DREI,
            LadestationRegler::erkennePhasenzahlAusLeistung(4104.0, 6)
        );
    }

    public function testPhasenprobeWeistUngueltigenErkennungsstromAb(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        LadestationRegler::erkennePhasenzahlAusLeistung(4104.0, 5);
    }

    public function testFahrzeugUndDreiPhasenWerdenWieInEnelixEinsErkannt(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 11000.0,
        ], false);

        self::assertTrue($status['FahrzeugVerbunden']);
        self::assertFalse($status['FahrzeugGeladen']);
        self::assertSame(3, $status['Fahrzeugstatus']);
        self::assertSame(LadestationRegler::PHASEN_DREI, $status['Phasenzahl']);
    }

    public function testDirektGemeldeteEinphasigkeitWirdAuchUnter7500WErkannt(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 2300.0,
            'Phasenzahl' => 1,
        ], false);

        self::assertSame(LadestationRegler::PHASEN_EIN, $status['Phasenzahl']);
        self::assertEqualsWithDelta(10.0, $status['Ladestrom_A'], 0.01);
    }

    public function testErkannteDreiphasigkeitBleibtWaehrendLadepauseErhalten(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 0.0,
        ], true, false, false, true, LadestationRegler::PHASEN_DREI);

        self::assertSame(LadestationRegler::PHASEN_DREI, $status['Phasenzahl']);
        self::assertSame(0.0, $status['Ladestrom_A']);
    }

    public function testPhasenBleibenOhneMessungBisZurErkennungUnbekannt(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 0.0,
        ], false);

        self::assertSame(LadestationRegler::PHASEN_UNBEKANNT, $status['Phasenzahl']);
        self::assertSame([0], LadestationRegler::leistungsangebot(
            true,
            true,
            true,
            false,
            LadestationRegler::PHASEN_UNBEKANNT,
            16,
            true,
            false
        ));
    }

    public function testAnlaufOhneGemesseneLadeleistungGiltNichtAlsLadeende(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 0.0,
        ], true, false, true, false);

        self::assertFalse($status['FahrzeugGeladen']);
        self::assertSame(2, $status['Fahrzeugstatus']);
    }

    public function testGeladenWirdErstNachZuvorGemessenerLadeleistungErkannt(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 0.0,
        ], true, false, true, true);

        self::assertTrue($status['FahrzeugGeladen']);
        self::assertSame(4, $status['Fahrzeugstatus']);
    }

    public function testAbsichtlichGestoppteLadungWirdNichtAlsGeladenErkannt(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 0.0,
        ], true, false, false);

        self::assertFalse($status['FahrzeugGeladen']);
        self::assertSame(2, $status['Fahrzeugstatus']);
    }

    public function testErkanntesLadeendeBleibtBisZumAbsteckenErhalten(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 0.0,
        ], true, true, false);

        self::assertTrue($status['FahrzeugGeladen']);
        self::assertSame(4, $status['Fahrzeugstatus']);
    }

    public function testDirekterPhasenstromHatVorrangVorNominalerLeistungsumrechnung(): void
    {
        $status = LadestationRegler::normalisiereStatus([
            'Rohstatus' => 2,
            'Istleistung_W' => 10263.0,
            'Iststrom_A' => 15.9,
        ], true);

        self::assertEqualsWithDelta(15.9, $status['Ladestrom_A'], 0.01);
    }

    public function testFahrzeugMaximalstromWirdMitZweiAmpereAbstandErkannt(): void
    {
        self::assertSame(18, LadestationRegler::ermittleFahrzeugMaximalstrom(20, 15.9, 20));
        self::assertNull(LadestationRegler::ermittleFahrzeugMaximalstrom(17, 15.9, 20));
        self::assertNull(LadestationRegler::ermittleFahrzeugMaximalstrom(20, 0.0, 20));
    }

    public function testBetriebsartUndSolarladenBestimmenDasLeistungsangebot(): void
    {
        $solarPV = LadestationRegler::leistungsangebot(true, true, true, false, 1, 16, true, false);
        $normalPV = LadestationRegler::leistungsangebot(true, true, true, false, 1, 16, false, false);
        $solarPeak = LadestationRegler::leistungsangebot(true, true, true, false, 1, 16, true, true);
        $normalPeak = LadestationRegler::leistungsangebot(true, true, true, false, 1, 16, false, true);

        self::assertSame(0, $solarPV[0]);
        self::assertCount(12, $solarPV);
        self::assertSame([3680], $normalPV);
        self::assertSame([0], $solarPeak);
        self::assertSame($solarPV, $normalPeak);
    }

    public function testPeakKannJedesFahrzeugAufNullSetzen(): void
    {
        self::assertSame(0, LadestationRegler::stromFuerLeistung(0, 3));
        self::assertSame(6, LadestationRegler::stromFuerLeistung(4104, 3));
        self::assertSame(16, LadestationRegler::stromFuerLeistung(10944, 3));
    }
}