11. Application Exercise – Version 4

The tax calculation application will now implement the following layered structure:

We’ll reuse the components from version 3, modifying them to adapt to the application’s new architecture. This is called “refactoring” (reworking the code). Here, we’ll assume that the data needed by the application is stored in text files. The [dao] layer will handle interactions with these files.

11.1. Script Directory Structure

Version 4 is located in the [scripts-console/tax/version-04] folder:

version-04
├── Tests
│   ├── data
│   │   ├── missing-key.json
│   │   ├── negative-value.json
│   │   └── syntax.json
│   ├── BusinessTest.php
│   └── DaoTest.php
├── Business.php
├── DaoTaxWithTaxAdminDataInJsonFile.php
├── errors.txt
├── InterfaceBusiness.php
├── InterfaceDao.php
├── main.php
├── results.txt
├── taxadmindata.json
├── TaxAdminData.php
├── TaxException.php
├── TaxPayerData.php
├── taxpayersdata.txt
├── TraitDao.php
└── Utilities.php

The [Tests] folder contains the automated tests for version 4, which we will present at the end of this chapter.

11.2. Objects Exchanged Between Layers

We are retaining certain elements from Version 3 exactly as they were:

The [TaxException] exception is the exception that the [dao] layer will throw when it encounters a problem either with data access or with the nature of the data (incorrect data);
the [Utilities] class contains methods useful for managing text files (in this case, a single method, [cutNewLineChar]);
The [readonly] class [TaxAdminData] encapsulates tax administration data. It is accessed via the static method [TaxAdminData::fromJsonFile($taxAdminDataFilename)] (or [TaxAdminData::fromArray($data)]), which validates the data and throws a [TaxException] exception if the data is invalid.

We are adding a new class, [TaxPayerData], which encapsulates a taxpayer’s data and the results of their tax calculation ([TaxPayerData.php]):

<?php

declare(strict_types=1);

// namespace
namespace Application;

// the data of a taxpayer and the results of the calculation of his tax: an immutable object
final readonly class TaxPayerData
{
    public function __construct(
        // data needed to calculate the taxpayer's tax
        public string $married,
        public int $children,
        public int $salary,
        // results of the tax calculation (null as long as the tax has not been calculated)
        public ?int $tax = null,
        public ?int $surcharge = null,
        public ?int $discount = null,
        public ?int $reduction = null,
        public ?float $rate = null,
    ) {
    }

    // returns a copy of the object completed with the results of the tax calculation
    // $results: array [tax, surcharge, discount, reduction, rate] returned by the [business] layer
    public function withResults(array $results): static
    {
        return clone($this, [
            "tax" => $results["tax"],
            "surcharge" => $results["surcharge"],
            "discount" => $results["discount"],
            "reduction" => $results["reduction"],
            "rate" => $results["rate"],
        ]);
    }

    // JSON string of the object
    public function __toString(): string
    {
        return json_encode(get_object_vars($this), JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
    }
}

Comments

line 9: Like [TaxAdminData], the [TaxPayerData] class is immutable: its objects pass from one layer to another without risk of being modified along the way;
Lines 13–15: the taxpayer’s data needed to calculate their tax;
Lines 17–21: The results of the tax calculation. These are nullable fields ([?int], [?float]) with the default value [null]: A [TaxPayerData] object is first created by the [dao] layer containing only the taxpayer’s data from [new TaxPayerData("yes", 2, 55555)], since the tax has not yet been calculated. The attribute names are those of the JSON keys in the Version 3 results file: the [results.txt] file will thus retain the same format;
Lines 27–36: Since the object is immutable, the calculation results cannot be added to it. The method [withResults] returns a copy of the object supplemented with the results. It uses the [clone] operator from PHP 8.5, which accepts as its second parameter an array of attributes to be modified in the copy (see the chapter on classes). The PHP 7 course used a modifiable object with eight getters and eight setters;
lines 39–42: The [__toString] method returns the JSON string from the object. It will be used to write the results file.

11.3. The [dao] layer

Here we are focusing on the [1] layer of our application:

11.3.1. The [InterfaceDao] interface

The interface for the [dao] layer will be as follows: [InterfaceDao.php]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// the interface of the [dao] layer
// all the methods throw a [TaxException] exception in case of an unrecoverable error
interface InterfaceDao
{
    // reading the taxpayers data
    // the incorrect lines are reported in the text file [$errorsFilename]
    /** @return TaxPayerData[] */
    public function getTaxPayersData(string $taxPayersFilename, string $errorsFilename): array;

    // reading the data of the tax administration (tax brackets and constants)
    public function getTaxAdminData(): TaxAdminData;

    // saving the results
    /** @param TaxPayerData[] $taxPayersData */
    public function saveResults(string $resultsFilename, array $taxPayersData): void;
}

Comments

The specifications are as follows:
- Taxpayer data is stored in a text file;
- the results of the tax calculation are saved in a text file;
- Any errors are saved in a text file;
- it is unknown in what format the tax authority’s data is available. For each new format, the [InterfaceDao] interface must be implemented by a new class;
- Methods of the interface that encounter a fatal error while accessing data must throw a [TaxException] exception;
Line 15: the method that retrieves taxpayer data, [marital status, number of children, annual salary]:
- the first parameter is the name of the text file containing this data;
- the second parameter is the name of the text file in which any errors encountered are to be logged;
Line 14: The type [array] does not specify what the array contains. The documentation comment for [/** @return TaxPayerData[] */] (syntax PHPDoc) specifies that it is an array of [TaxPayerData] objects. PHP ignores this, but the [PHP Intelephense] extension of [VS Code] uses it: it then knows the type of the array elements and can suggest their attributes during data entry;
line 18: the method that retrieves data from the tax authority. No parameters are passed to it because we do not know how the data is stored;
line 22: the method that saves the tax calculation results to a text file, whose name is passed as a parameter.

When writing the [InterfaceDao] interface, we know there will be different ways to implement the [getTaxAdminData] method depending on how the tax authority’s data is stored. The [InterfaceDao] interface will therefore be implemented by different classes, each handling a specific storage method for this data (JSON file, database, web service). These classes will, however, share common code: the implementation of the [getTaxPayersData] and [saveResults] methods. As we saw in the chapter on traits, this use case can be implemented in two ways:

We create an abstract class C that contains the code common to the derived classes. Class C implements interface I, but certain methods—which must be defined in the derived classes—are declared abstract in class C, which is therefore itself abstract. We then create classes C1 and C2 derived from C, each of which implements the abstract methods of their parent class C in its own way;
we create a trait T that is nearly identical to the abstract class C from the previous solution. This trait does not implement the interface I because, syntactically, it cannot. We then create the classes C1 and C2, which implement the interface I and use the trait T. All that remains for these classes is to implement the methods of the interface I that are not implemented by the trait T that they import.

For this example, we will use a trait [TraitDao]. Version 3 used an abstract class.

11.3.2. The trait [TraitDao]

The code for the trait [TraitDao] is as follows: [TraitDao.php]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// implementation of the methods of [InterfaceDao] that work with text files
trait TraitDao
{
    // separator of the fields of a line of the taxpayers file (trait constant, PHP 8.2)
    private const string SEPARATOR = ",";

    // reading the taxpayers data
    #[\Override]
    public function getTaxPayersData(string $taxPayersFilename, string $errorsFilename): array
    {
        // array of the taxpayers data
        $taxPayersData = [];
        // array of the errors
        $errors = [];
        // opening the taxpayers data file
        $taxPayersFile = is_readable($taxPayersFilename) ? fopen($taxPayersFilename, "r") : false;
        if ($taxPayersFile === false) {
            throw new TaxException("Unable to open the taxpayers' declarations [$taxPayersFilename] for reading", 12);
        }
        // the file is open: we will have to close it whatever happens
        try {
            // we process the current line of the taxpayers data file
            // which has the form marital status, number of children, annual salary
            $num = 0;  // no. of the current line
            while (($line = fgets($taxPayersFile, 100)) !== false) {
                // one more line
                $num++;
                // we remove the possible end-of-line mark
                $line = Utilities::cutNewLineChar($line);
                // we ignore the empty lines
                if (trim($line) === "") {
                    continue;
                }
                // the line must have 3 fields married,children,salary
                $fields = array_map(trim(...), explode(self::SEPARATOR, $line));
                $error = count($fields) !== 3;
                if (!$error) {
                    [$married, $children, $salary] = $fields;
                    // the marital status must be yes or no
                    $married = strtolower($married);
                    // the number of children and the salary must be positive or zero integers
                    $error = !in_array($married, ["yes", "no"], true)
                        || !preg_match('/^\d+$/', $children)
                        || !preg_match('/^\d+$/', $salary);
                }
                // error?
                if ($error) {
                    $errors[] = "line [$num] of the file [$taxPayersFilename] is incorrect";
                } else {
                    // we store the data of the taxpayer
                    $taxPayersData[] = new TaxPayerData($married, (int) $children, (int) $salary);
                }
            }
            // are we at the end of the file?
            if (!feof($taxPayersFile)) {
                // we exited the loop because of a read error
                throw new TaxException("Error while reading the line no. [" . ($num + 1) . "] of the file [$taxPayersFilename]", 13);
            }
        } finally {
            // we close the file
            fclose($taxPayersFile);
        }
        // we save the errors in a text file
        $this->saveLines($errorsFilename, $errors);
        // result of the function
        return $taxPayersData;
    }

    // saving the results
    #[\Override]
    public function saveResults(string $resultsFilename, array $taxPayersData): void
    {
        // each [TaxPayerData] element is turned into a JSON string by its [__toString] method
        $this->saveLines($resultsFilename, array_map(strval(...), $taxPayersData));
    }

    // saving an array of lines in a text file
    private function saveLines(string $fileName, array $lines): void
    {
        // if the text file [$fileName] does not exist, it is created, otherwise it is overwritten
        $data = implode("", array_map(fn(string $line): string => "$line\n", $lines));
        if (@file_put_contents($fileName, $data) === false) {
            throw new TaxException("Error while saving data to the text file [$fileName]", 14);
        }
    }
}

Comments

Line 9: Here we are defining a trait, not a class;
Line 12: a field separator constant (PHP 8.2), typed (PHP 8.3): the field separator for a line in the taxpayer file. It becomes a constant of the class that uses the trait and is used with the notation [self::SEPARATOR];
Line 15: Starting with PHP 8.3, the attribute [#[\Override]] is accepted on a trait method. This is verified in the class that uses the trait: here, the method must correspond to a method of the [InterfaceDao] interface implemented by this class;
Lines 16–74: The method [getTaxPayersData] implements the method of the same name from the [InterfaceDao] interface. It retrieves the data for taxpayers [marital status, number of children, annual salary] from the text file named [$taxPayersFilename]. It returns this data in the form of a [$taxPayersData] array containing elements of type [TaxPayerData] (line 58);
The method [getTaxPayersData] is very similar to the method [AbstractBaseTax::executeBatchTaxes] in version 3, with the following differences:
- The [getTaxPayersData] method only retrieves taxpayer data. It does not perform any tax calculations: that is the role of the [business] layer;
- Like the [executeBatchTaxes] method, it flags erroneous rows. Here, the errors are first stored in an array named [$errors], which is written to a text file at the end of processing (line 71). Depending on the situation, this array may or may not be empty. An erroneous line no longer triggers an exception: it is up to the calling code to consult the error file;
- in the case of a fatal error, a [TaxException] exception is thrown (line 25, line 64);
Lines 23–26: The file is opened before the [try / finally] structure. If opening the file fails, an exception is thrown and there is nothing to close. If it succeeds, the [finally] clause (lines 66–69) ensures that the file is closed, regardless of whether an exception occurs. This approach avoids the “Was the file opened?” check found in version 3;
Lines 62–65: Note the processing performed upon exiting the read loop. The function [fgets] has the drawback of returning [false] both when the read operation reaches the end of the file and when it fails due to an error. To distinguish between the two cases, we check whether we have reached the end of the file using the function [feof]. If this is not the case, an error has occurred, and an exception is then thrown;
lines 78–82: implementation of the [saveResults] method of the [InterfaceDao] interface. Each [TaxPayerData] element in the array is converted to a string by the function [strval], which calls the [__toString] method of the object: this yields its JSON string. [strval(...)] refers to the [strval] function itself (first-class callable, PHP 8.1);
lines 85–92: the private method [saveLines] writes an array of lines to a text file, with each line terminated by the line-end character \n;
line 89: the PHP function [file_put_contents] writes a string to a text file. It opens the file, writes the string to it, and closes the file. It returns [false] if an error occurs. In this case, PHP also issues a warning. The [@] operator suppresses this warning: the error is reported via the exception thrown on the next line, with a clearer message.

The trait [TraitDao] has implemented two of the methods from the [InterfaceDao] interface: [getTaxPayersData] and [saveResults]. We still need to implement the [getTaxAdminData] method, which retrieves data from the tax authority.

11.3.3. The [DaoTaxWithTaxAdminDataInJsonFile] class

The [DaoTaxWithTaxAdminDataInJsonFile] class implements the [InterfaceDao] interface as follows:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a [dao] layer that finds the data of the tax administration in a JSON file
class DaoTaxWithTaxAdminDataInJsonFile implements InterfaceDao
{
    // the trait implements the [getTaxPayersData] and [saveResults] methods of the interface
    use TraitDao;

    // the object of type [TaxAdminData] that contains the data of the tax administration
    private readonly TaxAdminData $taxAdminData;

    // the constructor
    public function __construct(string $taxAdminDataFilename)
    {
        // may throw a [TaxException] exception
        $this->taxAdminData = TaxAdminData::fromJsonFile($taxAdminDataFilename);
    }

    // returns the data used to calculate the tax
    #[\Override]
    public function getTaxAdminData(): TaxAdminData
    {
        return $this->taxAdminData;
    }
}

Comments

Line 9: The class [DaoTaxWithTaxAdminDataInJsonFile] implements the interface [InterfaceDao];
Line 12: The class uses the [TraitDao] trait, which, as we know, implements the [getTaxPayersData] and [saveResults] methods of the [InterfaceDao] interface. All that remains for the class to do is to implement the [getTaxAdminData] method, which retrieves data from the tax authority;
line 15: the attribute of type [TaxAdminData] returned by the [getTaxAdminData] method. It is initialized by the constructor;
Line 21: Data from the tax authority is read from the JSON file. If the file is missing or invalid, a [TaxException] exception is thrown to the calling code.

We are now done with the [dao] layer of our application: we have a class that fully implements the [InterfaceDao] interface we defined for ourselves. We can now move on to the [business] layer.

11.4. The [business] layer

We will now implement the [2] layer of our architecture:

11.4.1. The [InterfaceBusiness] interface

The interface for the [business] layer will be as follows: [InterfaceBusiness.php]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// the interface of the [business] layer
interface InterfaceBusiness
{
    // calculation of the tax of a taxpayer
    // returns the array [tax, surcharge, discount, reduction, rate]
    public function calculateTax(string $married, int $children, int $salary): array;

    // calculation of the taxes in batch mode
    // may throw a [TaxException] exception coming up from the [dao] layer
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void;
}

Comments

Line 13: The [business] layer can calculate a specific taxpayer’s tax amount provided it is given the following information: marital status, number of children, and annual salary. The [calculateTax] method is purely a “business” method: it does not concern itself with the source of the data it uses. It does not use the [dao] layer, so it does not throw an exception;
Line 17: The [business] layer can also calculate the tax amount for a group of taxpayers whose data is collected in the text file named [$taxPayersFileName]. It writes the results to the text file named [$resultsFileName]. Non-fatal errors are logged in the text file named [$errorsFileName]. The method [executeBatchTaxes] must call the layer [dao], which handles file system access. Exceptions may then be propagated from the [dao] layer: the [executeBatchTaxes] method will not catch them; it will allow them to be propagated to the main script.

11.4.2. The [Business] class

The [Business] class implements the [InterfaceBusiness] interface as follows:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// the [business] layer
class Business implements InterfaceBusiness
{
    // data of the tax administration
    private readonly TaxAdminData $taxAdminData;

    // the [dao] layer is injected by the constructor
    public function __construct(private readonly InterfaceDao $dao)
    {
        // we retrieve the data used to calculate the tax
        // the [getTaxAdminData] method may throw a [TaxException] exception
        // we then let it go up to the calling code
        $this->taxAdminData = $this->dao->getTaxAdminData();
    }

    // tax calculation
    // --------------------------------------------------------------------------
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        // $married: yes, no
        // $children: number of children
        // $salary: annual salary
        // $this->taxAdminData: data of the tax administration
        //
        // calculation of the tax with children
        $result1 = $this->calculateTax2($married, $children, $salary);
        $tax1 = $result1["tax"];
        // calculation of the tax without the children
        if ($children !== 0) {
            $result2 = $this->calculateTax2($married, 0, $salary);
            $tax2 = $result2["tax"];
            // application of the family quotient ceiling
            $halfShareCeiling = $this->taxAdminData->halfShareQfCeiling;
            if ($children < 3) {
                // halfShareQfCeiling euros for the first 2 children
                $tax2 = $tax2 - $children * $halfShareCeiling;
            } else {
                // halfShareQfCeiling euros for the first 2 children, double for the following ones
                $tax2 = $tax2 - 2 * $halfShareCeiling - ($children - 2) * 2 * $halfShareCeiling;
            }
        } else {
            $tax2 = $tax1;
            $result2 = $result1;
        }
        // we take the highest tax with the rate and the surcharge that go with it
        if ($tax1 > $tax2) {
            $tax = $tax1;
            $rate = $result1["rate"];
            $surcharge = $result1["surcharge"];
        } else {
            $surcharge = $tax2 - $tax1 + $result2["surcharge"];
            $tax = $tax2;
            $rate = $result2["rate"];
        }
        // calculation of a possible discount
        $discount = $this->getDiscount($married, $salary, $tax);
        $tax -= $discount;
        // calculation of a possible tax reduction
        $reduction = $this->getReduction($married, $salary, $children, $tax);
        $tax -= $reduction;
        // result
        return [
            "tax" => (int) floor($tax),
            "surcharge" => (int) $surcharge,
            "discount" => (int) $discount,
            "reduction" => (int) $reduction,
            "rate" => $rate,
        ];
    }

Comments

line 9: The [Business] class implements the [InterfaceBusiness] interface, that is, the [calculateTax] and [executeBatchTaxes] methods;
line 12: the object of type [TaxAdminData], which encapsulates the tax administration data. This data is required by the business method [calculateTax];
Lines 15–21: The constructor initializes the class’s two attributes:
- the attribute [$dao], a reference to the layer [dao], is initialized by promoting the constructor parameter. This is required so that the layer [business] knows whom to contact when it needs external data. Note that the type of this parameter is that of the [InterfaceDao] interface, thus allowing the [Business] class to work with any class that implements this interface. The PHP 7 course also offered a [setDao] setter: this is no longer present, as the [dao] layer is injected once and for all by the constructor;
- The [$taxAdminData] attribute is initialized by calling the [getTaxAdminData] method of the [dao] layer;
we conclude that when the methods [calculateTax] and [executeBatchTaxes] are executed, both attributes [$dao] and [$taxAdminData] are initialized. The [$this->taxAdminData ??= $this->getTaxAdminData()] test in version 3 is no longer necessary;
lines 26–77: this code is from the [AbstractBaseTax::calculateTax] method in version 3. The same applies to the private methods [calculateTax2], [getTaxableIncome], [getDiscount], and [getReduction], which are not reproduced here.

The method [Business::executeBatchTaxes] is as follows:

    // calculation of the taxes in batch mode
    // --------------------------------------------------------------------------
    #[\Override]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void
    {
        // we let the exceptions coming from the [dao] layer go up
        // we retrieve the taxpayers data
        $taxPayersData = $this->dao->getTaxPayersData($taxPayersFileName, $errorsFileName);
        // we calculate the tax of each taxpayer
        $results = array_map(
            fn(TaxPayerData $taxPayerData): TaxPayerData => $taxPayerData->withResults(
                $this->calculateTax($taxPayerData->married, $taxPayerData->children, $taxPayerData->salary)
            ),
            $taxPayersData
        );
        // saving the results
        $this->dao->saveResults($resultsFileName, $results);
    }
}

Comments

Line 188: The method must repeatedly call the [calculateTax] method for each taxpayer found in the text file named [$taxPayersFileName] and write the results to the text file named [$resultsFileName]. Any non-fatal errors encountered are logged in the text file named [$errorsFileName]. The method does not throw any exceptions itself but allows those thrown by the [dao] layer to propagate;
Line 192: Taxpayer data is requested from the [dao] layer. This layer returns an array of elements of type [TaxPayerData]. If an exception occurs here, since it is not caught by a [catch], it is automatically propagated to the calling code, and the rest of the method is not executed;
lines 194–199: The function [array_map] applies a function to each element of the array [$taxPayersData] and returns the array of results. The applied function is an arrow function that calculates the tax for taxpayer [$taxPayerData] and returns a copy of [$taxPayerData] populated with the results of the calculation (line 195). Note that the arrow function uses [$this]: an arrow function automatically captures variables from its context, including [$this];
Line 201: Once the tax has been calculated for all taxpayers, the results are saved to a text file. The [dao] layer performs this task.

In general, the [business] layer is fairly simple to write because it communicates with the [dao] layer, which handles data access and the associated error handling.

11.5. The Main Script

Now let’s write the script for the [3] layer of our architecture:

The main script is as follows: [main.php]:

<?php

// strict respect of the declared types of function parameters and results
declare(strict_types=1);

// namespace
namespace Application;

// inclusion of the interfaces and classes
require_once __DIR__ . "/TaxException.php";
require_once __DIR__ . "/Utilities.php";
require_once __DIR__ . "/TaxAdminData.php";
require_once __DIR__ . "/TaxPayerData.php";
require_once __DIR__ . "/InterfaceDao.php";
require_once __DIR__ . "/TraitDao.php";
require_once __DIR__ . "/DaoTaxWithTaxAdminDataInJsonFile.php";
require_once __DIR__ . "/InterfaceBusiness.php";
require_once __DIR__ . "/Business.php";

// definition of the constants
const TAXPAYERSDATA_FILENAME = "taxpayersdata.txt";
const RESULTS_FILENAME = "results.txt";
const ERRORS_FILENAME = "errors.txt";
const TAXADMINDATA_FILENAME = "taxadmindata.json";

try {
    // creation of the [dao] layer
    $dao = new DaoTaxWithTaxAdminDataInJsonFile(TAXADMINDATA_FILENAME);
    // creation of the [business] layer
    $business = new Business($dao);
    // tax calculation in batch mode
    $business->executeBatchTaxes(TAXPAYERSDATA_FILENAME, RESULTS_FILENAME, ERRORS_FILENAME);
    print "The results have been saved in the file [" . RESULTS_FILENAME . "]\n";
} catch (TaxException $ex) {
    // we display the error
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// end
print "Done\n";

Comments

Lines 10–18: Load the application’s classes, interfaces, and traits. A trait must be loaded before the class that uses it;
line 21: the name of the taxpayer data file;
line 22: the name of the results file;
line 23: the name of the error file;
line 24: the name of the JSON file containing data from the tax authority;
line 28: creation of the [dao] layer;
line 30: creation of the [business] layer based on the [dao] layer;
line 32: execution of method [executeBatchTaxes] of layer [business];
lines 34–37: As we saw, the layers [dao] and [business] can throw exceptions. These are intercepted here.

11.6. Visual Tests

11.6.1. Test #1

Run the script [main.php] in a terminal window opened in the [version-04] folder:

1
2
3

> php main.php
The results have been saved in the file [results.txt]
Done

With the taxpayer file [taxpayersdata.txt] from version 3:

yes,2,55555
yes,2,50000
yes,3,50000
no,2,100000
no,3x,100000
no,3,100000
yes,3,100000
yes,5,100000x
yes,5,100000
no,0,100000
yes,2,30000
no,0,200000
yes,3,200000

the following error file [errors.txt] is generated:

1 2	`line [5] of the file [taxpayersdata.txt] is incorrect line [8] of the file [taxpayersdata.txt] is incorrect`

and the following results file [results.txt]:

{"married":"yes","children":2,"salary":55555,"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"yes","children":2,"salary":50000,"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}
{"married":"yes","children":3,"salary":50000,"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}
{"married":"no","children":2,"salary":100000,"tax":19884,"surcharge":4480,"discount":0,"reduction":0,"rate":0.41}
{"married":"no","children":3,"salary":100000,"tax":16782,"surcharge":7176,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":3,"salary":100000,"tax":9200,"surcharge":2180,"discount":0,"reduction":0,"rate":0.3}
{"married":"yes","children":5,"salary":100000,"tax":4230,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"no","children":0,"salary":100000,"tax":22986,"surcharge":0,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":2,"salary":30000,"tax":0,"surcharge":0,"discount":0,"reduction":0,"rate":0}
{"married":"no","children":0,"salary":200000,"tax":64210,"surcharge":7498,"discount":0,"reduction":0,"rate":0.45}
{"married":"yes","children":3,"salary":200000,"tax":42842,"surcharge":17283,"discount":0,"reduction":0,"rate":0.41}

These are the results for version 3.

11.6.2. Test #2

In the main script, we assign a filename that does not exist to the taxpayer file:

1	`const TAXPAYERSDATA_FILENAME = "taxpayersdata2.txt";`

The results displayed in the console are as follows:

1
2
3

> php main.php
Error no. 12: Unable to open the taxpayers' declarations [taxpayersdata2.txt] for reading
Done

Only the exception message thrown by the [dao] layer is displayed. In the PHP 7 course, the function [fopen] was called on the nonexistent file: the PHP interpreter then displayed a warning before the exception message:

1	`Warning: fopen(taxpayersdata2.txt): failed to open stream: No such file or directory in ...`

The PHP 7 course suppressed this message by instructing PHP not to display errors using the [ini_set("display_errors", "0")] statement. This is the correct configuration for a production server (errors are then written to a log file), but during development, it is necessary to see all messages from PHP. We therefore prefer not to trigger the warning: the [dao] layer uses the [is_readable] function to verify that the file can be read before opening it.

11.7. [PHPUnit] Tests

Visual tests are highly insufficient:

we generally limit ourselves to just a few tests;
we may not pay close attention during this visual check, and details may slip past us.

In real-world professional development, tests are written as code and run automatically, often after every code change. The goal is to make the tests as comprehensive as possible. To achieve this, we use testing frameworks.

Here, we will use [PHPUnit] [https://phpunit.de/], the standard testing framework in PHP. The PHP 7 course used the [Codeception] framework, which was chosen because it integrated with the NetBeans IDE—and which, incidentally, used PHPUnit behind the scenes. We will use only a small portion of the capabilities of PHPUnit. The idea is to have a quick way, after each new version of the application exercise, to verify that it works. Successful tests give the developer confidence in the code they have written. This is an important factor.

11.7.1. Installing [PHPUnit]

Like many PHP libraries, [PHPUnit] is installed with [Composer], the PHP dependency manager, which is included with [Laragon]. The [php8-oct-2026] folder containing the course code includes a file named [composer.json] that lists the libraries used by the course. PHPUnit appears there in the [require-dev] section, which contains libraries used solely for development:

    "require-dev": {
        "phpunit/phpunit": "^12.0"
    },

If you haven’t already done so, simply open a terminal in the [php8-oct-2026] folder and type the following command:

1	`composer install`

[Composer] will then download all the libraries listed in [composer.json] into the [vendor] folder within [php8-oct-2026]. PHPUnit is installed there along with its executable, [vendor/bin/phpunit]. In a project that does not yet have PHPUnit, it would be added using the [composer require --dev phpunit/phpunit] command, which downloads it and registers it in the [require-dev] section of the [composer.json] file.

Version 12 of PHPUnit requires PHP 8.3 or later. Its documentation is available at [https://docs.phpunit.de/].

11.7.2. The configuration file [phpunit.xml]

The [php8-oct-2026] folder also contains the configuration file for PHPUnit, [phpunit.xml]. When PHPUnit is launched from this folder, it automatically uses this file:

<?xml version="1.0" encoding="UTF-8"?>
<!-- PHPUnit configuration for all the tests of the course:
     php vendor/bin/phpunit scripts-console/tax/version-04/Tests -->
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         colors="false"
         failOnDeprecation="true"
         failOnPhpunitDeprecation="true"
         failOnNotice="true"
         failOnWarning="true"
         displayDetailsOnTestsThatTriggerDeprecations="true"
         displayDetailsOnTestsThatTriggerNotices="true"
         displayDetailsOnTestsThatTriggerWarnings="true"
         cacheDirectory=".phpunit.cache">
    <source ignoreSuppressionOfDeprecations="true">
        <include>
            <directory>scripts-console</directory>
            <directory>scripts-web</directory>
        </include>
    </source>
</phpunit>

Comments

Line 5: The XML schema, which describes the file's syntax. [VS Code] uses it to validate the file and suggest possible attributes;
Line 6: No colors are used in the results display. You can use [true] to display successful tests in green and failed tests in red in the terminal;
Lines 7–10: A test that triggers a deprecation, a note, or a warning from PHP is considered a failure, even if its assertions are verified. This is a way to enforce clean PHP 8 code: for example, using a deprecated feature in PHP 8.5 would cause the tests to fail;
lines 11–13: in these cases, PHPUnit displays the details of the message from PHP;
line 14: the folder where PHPUnit stores information from one run to the next (for example, tests that failed, so they can be run first the next time);
lines 15–20: the folders containing the tested source code. [ignoreSuppressionOfDeprecations] indicates that a deprecation is reported even if it was suppressed by the operator [@].

11.7.3. Tests for the [dao] layer

The tests for version 4 are in the [version-04/Tests] folder. A PHPUnit test class:

extends the class [PHPUnit\Framework\TestCase];
has a name ending in [Test], in a file of the same name: this is how PHPUnit finds the test classes in a folder;
has public test methods whose names begin with [test];
may have a method named [setUp], executed before each test method, and a method named [tearDown], executed after each test method. These are used to set up the test environment and then clean it up. Each test method thus runs in a fresh environment, independent of the others.

In a test method, results are verified using assertion methods inherited from [TestCase], for example:

Assertion	Verifies that
[assertSame($expected, $actual)]	the two values are identical ([===]: same type and same value)
[assertEquals($expected, $actual)]	the two values are equal ([==])
[assertEqualsWithDelta($expected, $actual, $delta)]	Both numbers are equal to within [$delta]
[assertTrue($actual)], [assertFalse($actual)], [assertNull($actual)]	the value is [true], [false], [null]
[assertCount($n, $array)]	The array has [$n] elements
[assertStringContainsString($substring, $string)]	the string contains the substring
[expectException($class)]	The following code throws an exception of the specified class

To build the tests for a version of the application exercise, we use an environment identical to that of the main script [main.php] for that version: the same files are loaded, and the same layers are constructed in the same way.

The test class [DaoTest] is as follows: [Tests/DaoTest.php]:

<?php

// strict respect of the declared types of function parameters and results
declare(strict_types=1);

// namespace of the tests
namespace Application\Tests;

// the tested classes
use Application\DaoTaxWithTaxAdminDataInJsonFile;
use Application\TaxException;
use Application\InterfaceDao;
use Application\TaxPayerData;
// the PHPUnit classes
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// loading the classes of the [dao] layer
require_once __DIR__ . "/../TaxException.php";
require_once __DIR__ . "/../Utilities.php";
require_once __DIR__ . "/../TaxAdminData.php";
require_once __DIR__ . "/../TaxPayerData.php";
require_once __DIR__ . "/../InterfaceDao.php";
require_once __DIR__ . "/../TraitDao.php";
require_once __DIR__ . "/../DaoTaxWithTaxAdminDataInJsonFile.php";

final class DaoTest extends TestCase
{
    // the folder of version 4
    private const string ROOT = __DIR__ . "/..";
    // the tested [dao] layer
    private InterfaceDao $dao;
    // a temporary file for the errors
    private string $errorsFilename;

    // executed before each test
    #[\Override]
    protected function setUp(): void
    {
        // creation of the [dao] layer
        $this->dao = new DaoTaxWithTaxAdminDataInJsonFile(self::ROOT . "/taxadmindata.json");
        // a temporary file
        $this->errorsFilename = tempnam(sys_get_temp_dir(), "errors");
    }

    // executed after each test
    #[\Override]
    protected function tearDown(): void
    {
        // deletion of the temporary file
        unlink($this->errorsFilename);
    }

    // the data of the tax administration
    public function testTaxAdminData(): void
    {
        $taxAdminData = $this->dao->getTaxAdminData();
        // calculation constants
        $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);
        // tax brackets
        $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);
    }

    // incorrect tax data files
    public static function invalidFiles(): array
    {
        // [file name, expected error code]
        return [
            "non-existent file" => ["nonexistent.json", 1],
            "invalid JSON" => ["syntax.json", 2],
            "missing key" => ["missing-key.json", 4],
            "negative value" => ["negative-value.json", 6],
        ];
    }

    #[DataProvider("invalidFiles")]
    public function testInvalidTaxAdminData(string $file, int $code): void
    {
        // we expect a [TaxException] exception with a specific code
        $this->expectException(TaxException::class);
        $this->expectExceptionCode($code);
        // construction of a [dao] layer with an incorrect file
        new DaoTaxWithTaxAdminDataInJsonFile(__DIR__ . "/data/$file");
    }

    // the data of the taxpayers
    public function testTaxPayersData(): void
    {
        $taxPayersData = $this->dao->getTaxPayersData(self::ROOT . "/taxpayersdata.txt", $this->errorsFilename);
        // 11 correct taxpayers
        $this->assertCount(11, $taxPayersData);
        $this->assertContainsOnlyInstancesOf(TaxPayerData::class, $taxPayersData);
        // the first and the last one
        $this->assertEquals(new TaxPayerData("yes", 2, 55555), $taxPayersData[0]);
        $this->assertEquals(new TaxPayerData("yes", 3, 200000), $taxPayersData[10]);
        // 2 incorrect lines: lines 5 and 8
        $errors = file($this->errorsFilename, FILE_IGNORE_NEW_LINES);
        $this->assertCount(2, $errors);
        $this->assertStringContainsString("line [5]", $errors[0]);
        $this->assertStringContainsString("line [8]", $errors[1]);
    }

    // a non-existent taxpayers file
    public function testNonExistentTaxPayersData(): void
    {
        $this->expectException(TaxException::class);
        $this->expectExceptionCode(12);
        $this->dao->getTaxPayersData(self::ROOT . "/nonexistent.txt", $this->errorsFilename);
    }
}

Comments

line 7: The test classes are in the [Application\Tests] namespace, which is distinct from that of the application;
Lines 10–16: The classes used are imported with the statement [use]. The application classes are in the [Application] namespace, and those from PHPUnit are in [PHPUnit\Framework];
Lines 19–25: Load the files from the [dao] layer, as in [main.php]. The paths are relative to the test file folder ([__DIR__]): the tests run regardless of the folder from which PHPUnit is launched and regardless of the location of the [php8-oct-2026] folder on the disk. The PHP 7 course used absolute paths ([C:/Data/...]) specific to the author’s machine. The classes in PHPUnit, on the other hand, are loaded automatically by the loader in [Composer], which is initialized by PHPUnit;
line 27: the test class extends [TestCase];
line 30: the version 4 folder, where the data files are located;
Lines 38–44: Before each test, the [dao] layer is built as done by [main.php], and a temporary file is created for errors. The function [tempnam] creates a uniquely named file in the system’s temporary files folder, as returned by [sys_get_temp_dir]. The PHP 7 course performed this task in the test class constructor: the constructor for [TestCase] no longer needs to be redefined as of PHPUnit 10;
lines 48–52: After each test, the temporary file is deleted;
lines 55–73: testing the tax administration data. We verify that the contents of the [TaxAdminData] object returned by the [dao] layer match what is expected. The [assertSame] method is used: [assertSame(1551.0, ...)] verifies that the value is the real number 1551.0; [assertSame(1551, ...)] would fail because the integer 1551 is not identical to the real number 1551.0. For arrays, [assertSame] verifies that the two arrays have the same keys, in the same order, with identical values;
lines 76–85: a data provider. This is a static public method that returns an array of datasets. Each dataset is an array of arguments to be passed to a test method. The key of each dataset (“non-existent file”...) gives it a name that will appear in the test results;
line 87: the PHP 8 attribute [#[DataProvider]] indicates that the test method [testInvalidTaxAdminData] must be executed once for each dataset from the provider [invalidFiles]. Versions of PHPUnit prior to version 10 used an annotation in a comment instead: annotations are no longer recognized as of PHPUnit 12;
Lines 88–95: Verify that a layer built with an incorrect tax data file throws an exception with the correct error code. The methods [expectException] and [expectExceptionCode] must be called before the code that throws the exception: the test passes if the exception is thrown; otherwise, it fails. The incorrect files are in the [Tests/data] folder: a malformed JSON file (missing comma), a file missing the [coupleDiscountCeiling] key, and a file with a negative value;
Lines 98–112: the test for reading taxpayer data. The [taxpayersdata.txt] file from version 4 contains 11 correct lines and 2 erroneous lines. We verify the number of taxpayers retrieved, their type ([assertContainsOnlyInstancesOf]), the contents of the first and last records, and then the contents of the error file. To compare two [TaxPayerData] objects, we use [assertEquals]: two distinct objects are never identical ([===]), but they are equal ([==]) if their attributes are equal;
Lines 115–120: A nonexistent taxpayer file must trigger a code 12 exception.

11.7.4. Running the tests

The tests are run in a terminal opened in the [php8-oct-2026] folder, by passing the test folder to PHPUnit:

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

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

..................                                                18 / 18 (100%)

Time: 00:00.020, Memory: 16.00 MB

OK (18 tests, 52 assertions)

line 5: PHPUnit found and used the configuration file [phpunit.xml];
line 7: one point per successful test. The 18 tests are those from the two test classes [DaoTest] and [BusinessTest] (the latter is described in the following paragraph): a test run with a data provider counts as many tests as there are datasets;
line 11: the results: all tests passed.

The [--testdox] option provides a more descriptive display, where each test is described by a sentence composed of the name of its method and the name of its dataset:

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

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

..................                                                18 / 18 (100%)

Time: 00:00.006, 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
 ✔ Invalid tax admin data with data set "non-existent file"
 ✔ Invalid tax admin data with data set "invalid JSON"
 ✔ Invalid tax admin data with data set "missing key"
 ✔ Invalid tax admin data with data set "negative value"
 ✔ Tax payers data
 ✔ Non existent tax payers data

OK (18 tests, 52 assertions)

Now let’s look at a test that fails. In the [BusinessTest] class, we introduce an error in the expected reduction for the second taxpayer (346 instead of 347). Running the tests then yields the following result:

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

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

.F................                                                18 / 18 (100%)

Time: 00:00.008, Memory: 16.00 MB

There was 1 failure:

1) Application\Tests\BusinessTest::testCalculateTax@couple, 2 children, 50000 with data ('yes', 2, 50000, 1385, [1384, 0, 384, 346, 0.14])
Failed asserting that two arrays are identical.
--- Expected
+++ Actual
@@ @@
     'tax' => 1384,
     'surcharge' => 0,
     'discount' => 384,
-    'reduction' => 346,
+    'reduction' => 347,
     'rate' => 0.14,
 ]

.../php8-oct-2026/scripts-console/tax/version-04/Tests/BusinessTest.php:84

FAILURES!
Tests: 18, Assertions: 52, Failures: 1.

line 7: the letter F (Failure) indicates the test that failed;
line 13: the test that failed, along with the name and contents of its dataset;
lines 14–24: the assertion that failed ([assertSame]) and the difference between the expected (-) and actual (+) arrays;
line 26: the file and line number of the assertion that failed;
lines 28–29: the summary.

When a test does not even run (for example, because a file loaded by [require_once] cannot be found), PHPUnit displays the corresponding PHP error, just as running a standard PHP script would.

11.7.5. [business] Layer Tests

The test class [BusinessTest] follows the same construction rules as the class [DaoTest]: [Tests/BusinessTest.php]:

<?php

// strict respect of the declared types of function parameters and results
declare(strict_types=1);

// namespace of the tests
namespace Application\Tests;

// the tested classes
use Application\DaoTaxWithTaxAdminDataInJsonFile;
use Application\InterfaceBusiness;
use Application\Business;
// the PHPUnit classes
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// loading the classes of the [dao] and [business] layers
require_once __DIR__ . "/../TaxException.php";
require_once __DIR__ . "/../Utilities.php";
require_once __DIR__ . "/../TaxAdminData.php";
require_once __DIR__ . "/../TaxPayerData.php";
require_once __DIR__ . "/../InterfaceDao.php";
require_once __DIR__ . "/../TraitDao.php";
require_once __DIR__ . "/../DaoTaxWithTaxAdminDataInJsonFile.php";
require_once __DIR__ . "/../InterfaceBusiness.php";
require_once __DIR__ . "/../Business.php";

final class BusinessTest extends TestCase
{
    // the folder of version 4
    private const string ROOT = __DIR__ . "/..";
    // the tested [business] layer
    private InterfaceBusiness $business;

    // executed before each test
    #[\Override]
    protected function setUp(): void
    {
        // creation of the [dao] layer
        $dao = new DaoTaxWithTaxAdminDataInJsonFile(self::ROOT . "/taxadmindata.json");
        // creation of the [business] layer
        $this->business = new Business($dao);
    }

    // the taxpayers of the table of official figures
    public static function taxpayers(): array
    {
        // [married, children, salary, official tax, expected results of the algorithm]
        return [
            "couple, 2 children, 55555" => ["yes", 2, 55555, 2815,
                ["tax" => 2814, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.14]],
            "couple, 2 children, 50000" => ["yes", 2, 50000, 1385,
                ["tax" => 1384, "surcharge" => 0, "discount" => 384, "reduction" => 347, "rate" => 0.14]],
            "couple, 3 children, 50000" => ["yes", 3, 50000, 0,
                ["tax" => 0, "surcharge" => 0, "discount" => 720, "reduction" => 0, "rate" => 0.14]],
            "single, 2 children, 100000" => ["no", 2, 100000, 19884,
                ["tax" => 19884, "surcharge" => 4480, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
            "single, 3 children, 100000" => ["no", 3, 100000, 16782,
                ["tax" => 16782, "surcharge" => 7176, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
            "couple, 3 children, 100000" => ["yes", 3, 100000, 9200,
                ["tax" => 9200, "surcharge" => 2180, "discount" => 0, "reduction" => 0, "rate" => 0.3]],
            "couple, 5 children, 100000" => ["yes", 5, 100000, 4230,
                ["tax" => 4230, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.14]],
            "single, 0 children, 100000" => ["no", 0, 100000, 22986,
                ["tax" => 22986, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
            "couple, 2 children, 30000" => ["yes", 2, 30000, 0,
                ["tax" => 0, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.0]],
            "single, 0 children, 200000" => ["no", 0, 200000, 64211,
                ["tax" => 64210, "surcharge" => 7498, "discount" => 0, "reduction" => 0, "rate" => 0.45]],
            "couple, 3 children, 200000" => ["yes", 3, 200000, 42843,
                ["tax" => 42842, "surcharge" => 17283, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
        ];
    }

    // a test executed once for each of the taxpayers of the data provider
    #[DataProvider("taxpayers")]
    public function testCalculateTax(string $married, int $children, int $salary, int $officialTax, array $expected): void
    {
        // tax calculation
        $result = $this->business->calculateTax($married, $children, $salary);
        // the tax is the one of the official simulator to within 1 euro
        $this->assertEqualsWithDelta($officialTax, $result["tax"], 1);
        // the results are exactly the expected ones (same keys, same values, same types)
        $this->assertSame($expected, $result);
    }
}

Comments

lines 18–26: loading the files for layers [dao] and [business]. The test environment is the same as that of [main.php];
lines 37–43: instantiation of layers [dao] and [business], as in [main.php];
lines 46–73: the data provider: the eleven taxpayers from the table of official figures. Each dataset contains the taxpayer’s data, the tax amount generated by the tax authority’s official simulator [https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.htm], and the expected results of the algorithm described in the document;
line 76: the method [testCalculateTax] will be executed eleven times, once per taxpayer. The PHP 7 course originally included eleven nearly identical test methods, from [test1] to [test11]; the data provider eliminates this duplication;
line 80: the tax calculation is performed by the [business] layer;
line 82: We verify that the calculated tax matches the official simulator’s result to within 1 euro. We have seen that rounding issues caused the algorithm in the document to yield results that differed from the official ones by up to 1 euro;
line 84: We verify that the results table [tax, surcharge, discount, reduction, rate] is exactly as expected, including the data types: integers for the amounts, a real number for the rate. This is why the rate for the 9th taxpayer is written as 0.0 and not 0. This precise verification protects against any unintended changes to the algorithm in future versions.

The results of running these tests are those shown in the previous paragraph: all 11 tests in the [business] layer pass.

11.7.6. PHPUnit in VS Code

The easiest way to run the tests in [VS Code] is to use its built-in terminal (Terminal menu / New Terminal): it opens in the project’s [php8-oct-2026] folder, and you type the command [php vendor/bin/phpunit scripts-console/tax/version-04/Tests] there. The up arrow on the keyboard recalls the last command: rerunning the tests after making a code change takes just one keystroke.

Some useful options for the [phpunit] command:

[--testdox]: displays tests as sentences;
[--filter testCalculateTax]: runs only those tests whose names contain the specified text;
[--stop-on-failure]: stops at the first failure.

There are also extensions for [VS Code] that integrate PHPUnit into the editor’s test explorer (for example, the “PHPUnit Test Explorer” extension): these allow you to run a test with a single click and display the results next to the code. They actually execute the same [phpunit] command that we type into the terminal.

11.7.7. Tests for Upcoming Versions

Going forward, the tests for the [dao] and [business] layers will be identical to those in version 4. The only thing that will change is the test environment: the files loaded and the way the [dao] and [business] layers are built. We will therefore present only this one and the test results.