Skip to content

15. Übung zur Anwendung – Version 7

Version 7 baut auf Version 6 auf und lagert die in den Hauptskripten verwendeten Konstanten – nämlich die Namen der Datendateien und die Liste der zu ladenden PHP-Dateien – in eine Konfigurationsdatei aus. Wie Version 6 enthält sie keine neuen Klassen und verwendet die aus Version 5:

version-07
├── Data
│   ├── config.json
│   ├── database-mysql.json
│   ├── database-pgsql.json
│   ├── errors.json
│   ├── results.json
│   ├── taxadmindata.json
│   └── taxpayersdata.json
├── Main
│   ├── MainCalculateTaxWithTaxAdminDataInDatabase.php
│   └── MainTransferAdminDataFromJsonFile2Database.php
└── Tests
    ├── BusinessTest.php
    └── DaoTest.php

Der Ordner [Data] enthält die Beschreibungen der beiden Datenbanken [dbtaxes-2019]: der MySQL-Datenbank aus Version 5 ([database-mysql.json]) und der PostgreSQL-Datenbank aus Version 6 ([database-pgsql.json]). In der letztgenannten Datei sind den Tabellennamen nicht mehr das Schema [public] (["tableBrackets": "tbbrackets"]) vorangestellt.

15.1. Implementierung

Die Konfigurationsdatei ist die folgende JSON-Datei [Data/config.json]:

{
    "databaseFilename": "Data/database-pgsql.json",
    "taxAdminDataFilename": "Data/taxadmindata.json",
    "taxPayersDataFilename": "Data/taxpayersdata.json",
    "resultsFilename": "Data/results.json",
    "errorsFilename": "Data/errors.json",
    "dependencies": {
        "TaxException": "../version-05/Entities/TaxException.php",
        "TaxAdminData": "../version-05/Entities/TaxAdminData.php",
        "TaxPayerData": "../version-05/Entities/TaxPayerData.php",
        "Database": "../version-05/Entities/Database.php",
        "Utilities": "../version-05/Utilities/Utilities.php",
        "InterfaceDao": "../version-05/Dao/InterfaceDao.php",
        "TraitDao": "../version-05/Dao/TraitDao.php",
        "DaoTaxWithTaxAdminDataInDatabase": "../version-05/Dao/DaoTaxWithTaxAdminDataInDatabase.php",
        "InterfaceDao4TransferAdminData2Database": "../version-05/Dao/InterfaceDao4TransferAdminData2Database.php",
        "DaoTransferAdminDataFromJsonFile2Database": "../version-05/Dao/DaoTransferAdminDataFromJsonFile2Database.php",
        "InterfaceBusiness": "../version-05/Business/InterfaceBusiness.php",
        "Business": "../version-05/Business/Business.php"
    },
    "dependencies4calculate": [
        "TaxException",
        "TaxAdminData",
        "TaxPayerData",
        "Database",
        "Utilities",
        "InterfaceDao",
        "TraitDao",
        "DaoTaxWithTaxAdminDataInDatabase",
        "InterfaceBusiness",
        "Business"
    ],
    "dependencies4transfer": [
        "TaxException",
        "TaxAdminData",
        "Database",
        "Utilities",
        "InterfaceDao4TransferAdminData2Database",
        "DaoTransferAdminDataFromJsonFile2Database"
    ]
}

In dieser Konfiguration gilt:

  • Zeilen 2–6: die Pfade zu allen JSON-Dateien der Anwendung. Die verwendete Datenbank ist PostgreSQL;
  • Zeilen 7–20: die Pfade zu allen PHP-Dateien der Anwendung in der Form [key => path]. Es sind die Dateien aus Version 5;
  • Zeilen 21–32: die Abhängigkeiten für die Steuerberechnung in Form einer Liste von Schlüsseln aus dem Dictionary [dependencies];
  • Zeilen 33–40: die Abhängigkeiten für die Übertragung der Daten aus der JSON-Datei [taxadmindata.json] in die Datenbank, im selben Format.

Alle Pfade beziehen sich auf den Ordner [version-07]. Der PHP-7-Kurs fügte dieser Datei einen Schlüssel namens [rootDirectory] hinzu, der den absoluten Pfad zum Versionsordner auf dem Rechner des Autors angab (["C:/Data/st-2019/dev/php7/poly/scripts-console/impots/version-07"]): Dieser musste auf jedem neuen Rechner angepasst werden. Die Skripte berechnen diesen Ordnerpfad nun selbst anhand der Konstante [__DIR__]. Der Ordner [php8-oct-2026] kann daher an beliebiger Stelle liegen.

Das Skript zur Übertragung der Steuerverwaltungsdaten in die Datenbank, [Main/MainTransferAdminDataFromJsonFile2Database.php], lautet nun wie folgt:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace
namespace Application;

// der Wurzelordner der Version 7: die Pfade der Konfigurationsdatei sind relativ zu diesem Ordner
const ROOT_DIRECTORY = __DIR__ . "/..";
// Pfad der Konfigurationsdatei
const CONFIG_FILENAME = ROOT_DIRECTORY . "/Data/config.json";

// wir rufen die Konfiguration ab
$config = json_decode(file_get_contents(CONFIG_FILENAME), true, flags: JSON_THROW_ON_ERROR);

// wir binden die vom Skript benötigten Abhängigkeiten ein
foreach ($config["dependencies4transfer"] as $dependency) {
    require_once ROOT_DIRECTORY . "/" . $config["dependencies"][$dependency];
}

// die Pfade der Datendateien
$databaseFilename = ROOT_DIRECTORY . "/" . $config["databaseFilename"];
$taxAdminDataFilename = ROOT_DIRECTORY . "/" . $config["taxAdminDataFilename"];

try {
    // Erzeugung der Schicht [dao]
    $dao = new DaoTransferAdminDataFromJsonFile2Database($databaseFilename, $taxAdminDataFilename);
    // Übertragung der Daten in die Datenbank
    $dao->transferAdminData2Database();
    print "The data of the tax administration have been transferred into the database described by [{$config["databaseFilename"]}]\n";
} catch (TaxException $ex) {
    // wir zeigen den Fehler an
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// Ende
print "Done\n";

Kommentare

Der Code bleibt derselbe wie in Version 6. Der einzige Unterschied ist die Verwendung der Datei [config.json] anstelle der Konstanten:

  • Zeile 10: Das Wurzelverzeichnis von Version 7, auf das sich die Pfade in der Konfigurationsdatei beziehen. [__DIR__] ist der Ordner [Main] des Skripts; [__DIR__ . "/.."] ist dessen übergeordneter Ordner, [version-07];
  • Zeile 12: der Pfad zur Konfigurationsdatei;
  • Zeile 15: Die Funktion [file_get_contents] wandelt die Datei [config.json] in einen String um. Die Funktion [json_decode] erstellt daraus dann das assoziative Array [$config]. Der zweite Parameter [true] der Funktion [json_decode] legt fest, dass ein assoziatives Array statt eines Objekts gewünscht ist. Mit der Option [JSON_THROW_ON_ERROR] löst ein Syntaxfehler in der Datei eine Exception vom Typ [JsonException] aus. Wir versuchen hier nicht, Lesefehler der Konfigurationsdatei zu behandeln: Diese Datei gehört zur Anwendung, und ein Fehler auf dieser Ebene ist ein Programmierfehler, den PHP selbst meldet. Datenfehler (JSON-Datendateien, Datenbank) werden dagegen stets durch eine [TaxException] gemeldet;
  • Zeilen 18–20: Die vom Übertragungsskript benötigten Abhängigkeiten werden eingebunden:
    • [$config["dependencies4transfer"]] ist die Tabelle der Abhängigkeiten, die das Übertragungsskript benötigt. Sie ist eine Liste von Schlüsseln;
    • Die Pfade der einzubindenden Dateien finden sich im Dictionary [$config["dependencies"]] und werden mit dem Wurzelverzeichnis versehen. Der Schlüssel [TaxException] verweist zum Beispiel auf die Datei [version-07/../version-05/Entities/TaxException.php];
    • [require_once] (nicht [require] wie im PHP-7-Kurs) stellt sicher, dass eine Datei nicht zweimal geladen wird, was den schweren Fehler „Cannot redeclare class … (previously declared in …)“ verursachen würde;
  • Zeilen 23–24: die vollständigen Pfade zu den Datendateien. Der PHP-7-Kurs speicherte sie in Konstanten, die mit der Funktion [define] erzeugt wurden. Variablen genügen;
  • Zeile 31: Der Name der Datei, die die verwendete Datenbank beschreibt, wird angezeigt. In einem String in Anführungszeichen muss das Array-Element [$config["databaseFilename"]] in geschweifte Klammern gesetzt werden.

Ergebnisse:

1
2
3
> php MainTransferAdminDataFromJsonFile2Database.php
The data of the tax administration have been transferred into the database described by [Data/database-pgsql.json]
Done

Ebenso wird das Skript zur Steuerberechnung zu der folgenden Datei [Main/MainCalculateTaxWithTaxAdminDataInDatabase.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace
namespace Application;

// der Wurzelordner der Version 7: die Pfade der Konfigurationsdatei sind relativ zu diesem Ordner
const ROOT_DIRECTORY = __DIR__ . "/..";
// Pfad der Konfigurationsdatei
const CONFIG_FILENAME = ROOT_DIRECTORY . "/Data/config.json";

// wir rufen die Konfiguration ab
$config = json_decode(file_get_contents(CONFIG_FILENAME), true, flags: JSON_THROW_ON_ERROR);

// wir binden die vom Skript benötigten Abhängigkeiten ein
foreach ($config["dependencies4calculate"] as $dependency) {
    require_once ROOT_DIRECTORY . "/" . $config["dependencies"][$dependency];
}

// die Pfade der Datendateien
$databaseFilename = ROOT_DIRECTORY . "/" . $config["databaseFilename"];
$taxPayersDataFilename = ROOT_DIRECTORY . "/" . $config["taxPayersDataFilename"];
$resultsFilename = ROOT_DIRECTORY . "/" . $config["resultsFilename"];
$errorsFilename = ROOT_DIRECTORY . "/" . $config["errorsFilename"];

try {
    // Erzeugung der Schicht [dao]
    $dao = new DaoTaxWithTaxAdminDataInDatabase($databaseFilename);
    // Erzeugung der Schicht [business]
    $business = new Business($dao);
    // Steuerberechnung im Batch-Modus
    $business->executeBatchTaxes($taxPayersDataFilename, $resultsFilename, $errorsFilename);
    print "The results have been saved in the file [{$config["resultsFilename"]}]\n";
} catch (TaxException $ex) {
    // wir zeigen den Fehler an
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// Ende
print "Done\n";
  • Zeilen 18–20: Diesmal werden die Abhängigkeiten der Steuerberechnung eingebunden;
  • Zeilen 23–26: die Dateipfade der JSON-Dateien der Anwendung;
  • Zeilen 28–39: Der Rest des Codes ist derselbe wie in Version 6.

Ergebnisse:

1
2
3
> php MainCalculateTaxWithTaxAdminDataInDatabase.php
The results have been saved in the file [Data/results.json]
Done

Die erzeugte Datei [Data/results.json] ist identisch mit der Datei [results.json] der Versionen 5 und 6.

Die Namen der beiden Skripte haben sich geändert. Im PHP-7-Kurs verwiesen sie auf PostgreSQL ([MainTransferAdminDataFromFile2PostgresSQLDatabase.php], [MainCalculateImpotsWithTaxAdminDataInPostgresDatabase.php]). Diese Skripte hängen jedoch von keinem bestimmten DBMS mehr ab: Es wird über den Schlüssel [databaseFilename] in der Konfigurationsdatei ausgewählt. Wenn Sie in dieser Datei ["Data/database-pgsql.json"] durch ["Data/database-mysql.json"] ersetzen, verwendet das Übertragungsskript die MySQL-Datenbank, ohne dass eine einzige Zeile PHP-Code geändert wird:

1
2
3
> php MainTransferAdminDataFromJsonFile2Database.php
The data of the tax administration have been transferred into the database described by [Data/database-mysql.json]
Done

Das ist der Vorteil einer Konfigurationsdatei: Sie können die Anwendung an ihre Umgebung (DBMS, Speicherorte von Dateien usw.) anpassen, ohne den Code anzufassen. Dieser Konfigurationsdatei werden wir in späteren Versionen der Anwendung wieder begegnen.

15.2. [PHPUnit]-Tests

Diese Version wird wie die vorherigen mit [PHPUnit]-Tests validiert. Auch deren Umgebung wird auf Grundlage der Konfigurationsdatei aufgebaut.

15.2.1. [dao]-Schicht testen

Die Tests der Schicht [dao] verwenden die beiden Datenbankbeschreibungen aus dem Ordner [Data]: Wir prüfen also mit denselben Tests, dass die Schicht [dao] sowohl mit MySQL als auch mit PostgreSQL funktioniert. Der Test [Tests/DaoTest.php] lautet wie folgt:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace der Tests
namespace Application\Tests;

// die getesteten Klassen
use Application\DaoTaxWithTaxAdminDataInDatabase;
use Application\DaoTransferAdminDataFromJsonFile2Database;
use Application\TaxAdminData;
// die PHPUnit-Klassen
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class DaoTest extends TestCase
{
    // der Wurzelordner der Version 7
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // die Konfiguration der Anwendung
    private static array $config;

    // einmal vor dem ersten Test der Klasse ausgeführt
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // wir rufen die Konfiguration ab
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config.json"), true, flags: JSON_THROW_ON_ERROR);
        // wir binden die Abhängigkeiten der Steuerberechnung und die der Datenübertragung ein
        $dependencies = array_unique([...self::$config["dependencies4calculate"], ...self::$config["dependencies4transfer"]]);
        foreach ($dependencies as $dependency) {
            require_once self::ROOT_DIRECTORY . "/" . self::$config["dependencies"][$dependency];
        }
    }

    // die beiden Datenbanken
    public static function databases(): array
    {
        // [Datei mit der Datenbankbeschreibung]
        return [
            "MySQL" => ["Data/database-mysql.json"],
            "PostgreSQL" => ["Data/database-pgsql.json"],
        ];
    }

    // die aus der Datenbank gelesenen Daten der Steuerverwaltung
    #[DataProvider("databases")]
    public function testTaxAdminData(string $databaseFilename): void
    {
        $dao = new DaoTaxWithTaxAdminDataInDatabase(self::ROOT_DIRECTORY . "/$databaseFilename");
        $taxAdminData = $dao->getTaxAdminData();
        // Berechnungskonstanten
        $this->assertSame(1551.0, $taxAdminData->halfShareQfCeiling);
        $this->assertSame(21037.0, $taxAdminData->singleIncomeCeilingForReduction);
        $this->assertSame(42074.0, $taxAdminData->coupleIncomeCeilingForReduction);
        $this->assertSame(3797.0, $taxAdminData->halfShareReductionValue);
        $this->assertSame(1196.0, $taxAdminData->singleDiscountCeiling);
        $this->assertSame(1970.0, $taxAdminData->coupleDiscountCeiling);
        $this->assertSame(1595.0, $taxAdminData->singleTaxCeilingForDiscount);
        $this->assertSame(2627.0, $taxAdminData->coupleTaxCeilingForDiscount);
        $this->assertSame(12502.0, $taxAdminData->tenPercentAllowanceMax);
        $this->assertSame(437.0, $taxAdminData->tenPercentAllowanceMin);
        // Steuerstufen
        $this->assertSame([9964.0, 27519.0, 73779.0, 156244.0, 0.0], $taxAdminData->limits);
        $this->assertSame([0.0, 0.14, 0.30, 0.41, 0.45], $taxAdminData->coeffR);
        $this->assertSame([0.0, 1394.96, 5798.0, 13913.69, 20163.45], $taxAdminData->coeffN);
    }

    // die Übertragung der JSON-Datei in die Datenbank, dann das erneute Lesen der Datenbank
    #[DataProvider("databases")]
    public function testTransfer(string $databaseFilename): void
    {
        // die JSON-Dateien
        $databaseFilename = self::ROOT_DIRECTORY . "/$databaseFilename";
        $taxAdminDataFilename = self::ROOT_DIRECTORY . "/" . self::$config["taxAdminDataFilename"];
        // Übertragung
        (new DaoTransferAdminDataFromJsonFile2Database($databaseFilename, $taxAdminDataFilename))->transferAdminData2Database();
        // erneutes Lesen der Datenbank durch eine Schicht [dao]
        $dao = new DaoTaxWithTaxAdminDataInDatabase($databaseFilename);
        // die Datenbank enthält die Daten der JSON-Datei
        $this->assertEquals(TaxAdminData::fromJsonFile($taxAdminDataFilename), $dao->getTaxAdminData());
    }
}

Kommentare

  • Zeilen 10–12: Die getesteten Klassen werden importiert. Die Anweisung [use] lädt die Klassen nicht, sondern erlaubt lediglich, sie mit ihren Kurznamen anzusprechen;
  • Zeile 22: Die Konfiguration der Anwendung wird in einem statischen Attribut (Klassenattribut) gespeichert;
  • Zeilen 26–35: Die statische Methode [setUpBeforeClass] von [TestCase] wird einmal vor dem ersten Test der Klasse ausgeführt. Sie liest die Konfigurationsdatei und lädt die Dateien der Anwendung. Der PHP-7-Kurs erledigte diese Aufgabe auf oberster Ebene der Testdatei, außerhalb der Klasse. Mit PHPUnit wird dieser Code ausgeführt, wenn PHPUnit die Datei lädt, also zu einem Zeitpunkt, den wir nicht kontrollieren; die Methode [setUpBeforeClass] ist für diesen Zweck gedacht;
  • Zeile 31: Die Tests der Schicht [dao] benötigen Abhängigkeiten der Steuerberechnung (für die Klasse [DaoTaxWithTaxAdminDataInDatabase]) und der Übertragung (für die Klasse [DaoTransferAdminDataFromJsonFile2Database]). Die beiden Listen werden zusammengeführt, und anschließend entfernt die Funktion [array_unique] die Duplikate;
  • Zeilen 38–45: die Datenquelle: die Beschreibungsdateien der beiden Datenbanken;
  • Zeilen 48–49: Der Test [testTaxAdminData] aus Version 5 wird für jede der beiden Datenbanken einmal ausgeführt;
  • Zeilen 71–83: Dasselbe gilt für den Test der Übertragung der Daten aus der JSON-Datei in die Datenbank.

15.2.2. Test der Schicht [business]

Der Test [Tests/BusinessTest.php] ist der Test aus Version 5 mit einer aus der Konfigurationsdatei aufgebauten Umgebung:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace der Tests
namespace Application\Tests;

// die getesteten Klassen
use Application\DaoTaxWithTaxAdminDataInDatabase;
use Application\InterfaceBusiness;
use Application\Business;
// die PHPUnit-Klassen
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class BusinessTest extends TestCase
{
    // der Wurzelordner der Version 7
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // die Konfiguration der Anwendung
    private static array $config;
    // die getestete Schicht [business]
    private InterfaceBusiness $business;

    // einmal vor dem ersten Test der Klasse ausgeführt
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // wir rufen die Konfiguration ab
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config.json"), true, flags: JSON_THROW_ON_ERROR);
        // wir binden die Abhängigkeiten der Steuerberechnung ein
        foreach (self::$config["dependencies4calculate"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/" . self::$config["dependencies"][$dependency];
        }
    }

    // wird vor jedem Test ausgeführt
    #[\Override]
    protected function setUp(): void
    {
        // Erzeugung der Schicht [dao] auf der Datenbank der Konfiguration
        $dao = new DaoTaxWithTaxAdminDataInDatabase(self::ROOT_DIRECTORY . "/" . self::$config["databaseFilename"]);
        // Erzeugung der Schicht [business]
        $this->business = new Business($dao);
    }

Kommentare

  • Zeilen 28–36: Die Konfigurationsdatei wird gelesen, und die Abhängigkeiten der Steuerberechnung werden geladen, genau wie es das Hauptskript [MainCalculateTaxWithTaxAdminDataInDatabase] tut;
  • Zeile 43: Die Schicht [dao] verwendet die Datenbank, die in der Konfigurationsdatei angegeben ist;
  • Der Data Provider [taxpayers] und die Methode [testCalculateTax], die hier nicht gezeigt werden, sind die aus Version 4.

15.2.3. Tests ausführen

Beide DBMS, MySQL und PostgreSQL, müssen gestartet sein. Die Testergebnisse lauten wie folgt:

> php vendor/bin/phpunit scripts-console/tax/version-07/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml

...............                                                   15 / 15 (100%)

Time: 00:00.602, Memory: 16.00 MB

Business (Application\Tests\Business)
 ✔ Calculate tax with data set "couple, 2 children, 55555"
 ✔ Calculate tax with data set "couple, 2 children, 50000"
 ✔ Calculate tax with data set "couple, 3 children, 50000"
 ✔ Calculate tax with data set "single, 2 children, 100000"
 ✔ Calculate tax with data set "single, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 5 children, 100000"
 ✔ Calculate tax with data set "single, 0 children, 100000"
 ✔ Calculate tax with data set "couple, 2 children, 30000"
 ✔ Calculate tax with data set "single, 0 children, 200000"
 ✔ Calculate tax with data set "couple, 3 children, 200000"

Dao (Application\Tests\Dao)
 ✔ Tax admin data with data set "MySQL"
 ✔ Tax admin data with data set "PostgreSQL"
 ✔ Transfer with data set "MySQL"
 ✔ Transfer with data set "PostgreSQL"

OK (15 tests, 50 assertions)
  • Zeilen 12–15: Die Tests der Schicht [dao] wurden mit jeder der beiden Datenbanken ausgeführt;
  • Zeilen 18–28: die 11 Tests der Schicht [business].

Damit haben wir die Konsolenversionen der Anwendung zur Steuerberechnung abgeschlossen. Version 8 wird sie in eine Client-Server-Anwendung verwandeln: Die Datenbank und die Steuerberechnung liegen dann auf einem Webserver, der von Clients abgefragt wird. Sie übernimmt die Klassen aus Version 5 und die Technik der Konfigurationsdatei aus Version 7.