Registering custom Comparator

[tzunghaor]

Hi, I've found a problem with using custom Comparator, and made a workaround - I'm writing to make others aware of this issue.

In my tests I registered a custom Comparator using SebastianBergmann\Comparator\Factory (as I read in the phpunit doc), but it didn't work with php-actions/phpunit

As I found out, the phpunit PHAR prefixes the SebastianBergmann namespace with PHPUnitPhar

I did the following workaround in my phpunit bootstrap.php - this way the tests run both using the phpunit in vendor directory, and with the phpunit PHAR. (Though it might be better to drop the phpunit from vendor, and always use phpunit PHAR.)

use SebastianBergmann\Comparator\Factory as ComparatorFactory;
use PHPUnitPHAR\SebastianBergmann\Comparator\Factory as PharComparatorFactory;

if (class_exists(PharComparatorFactory::class)) {
    $comparatorFactory = PharComparatorFactory::class;

    // alias PHPUnit classes used in my custom TzunghaorObjectComparator 
    class_alias(PHPUnitPHAR\SebastianBergmann\Comparator\Comparator::class, 'SebastianBergmann\Comparator\Comparator');
    class_alias(PHPUnitPhar\SebastianBergmann\Comparator\ComparisonFailure::class, 'SebastianBergmann\Comparator\ComparisonFailure');
} elseif (class_exists(ComparatorFactory::class)) {
    $comparatorFactory = ComparatorFactory::class;
} else {
    throw new RuntimeException('SebastianBergmann\Comparator\Factory not found');
}

$comparatorFactory::getInstance()->register(new TzunghaorObjectComparator());

[g105b]

Hm, this seems like a crazy hack. I'll have to read up about using a custom Comparator, because honestly I haven't come across this word before and I don't know what it is. But I'll try to replicate your setup so I can improve things for everyone. If you can provide any more information or a test bed to work from that would be appreciated.

[tzunghaor]

The custom comparator documentation I've read.

My original problem was that in this model I have $typeInfoType and $propertyInfoType properties to cache an object, but whether it is cached or not should not influence the result of the tests, and the easiest solution seemed to be to register a custom comparator once and use assertEquals.

I'm going to write a minimal working example soon.

I don't like this hack either. I think the more elegant way is: if someone uses php-actions/phpunit, then use the phpunit.phar locally too, and use PHPUnitPHAR\SebastianBergmann\... namespace directly in the tests. Though I don't know where to warn other users about this idiosyncrasy of the phpunit.phar

[g105b]

Me neither... I'll take a look into this with a small isolated project and I might be able to figure out a way to keep things clean. In the meantime, if you have the ability to share your minimal working example that will really help me when I pick this up.

[tzunghaor]

This custom comparator example works (I mean the second assert fails intentionally) with phpunit.phar.

<?php
use PHPUnit\Framework\TestCase;
use PHPUnitPHAR\SebastianBergmann\Comparator\Comparator;
use PHPUnitPHAR\SebastianBergmann\Comparator\ComparisonFailure;
use PHPUnitPHAR\SebastianBergmann\Comparator\Factory;

class Foo {
    public function __construct(
        public string $relevant,
        public string $irrelevant,
    ) {
    }
}

class FooComparator extends Comparator {
    public function accepts($expected, $actual): bool
    {
        return $expected instanceof Foo and $actual instanceof Foo;
    }

    public function assertEquals($expected, $actual, $delta = 0, $canonicalize = false, $ignoreCase = false): void
    {
        if ($expected->relevant !== $actual->relevant) {
            throw new ComparisonFailure(
                $expected,
                $actual,
                $expected->relevant,
                $actual->relevant,
                'relevant part does not match',
            );
        }
    }
}

class ComparatorTest extends TestCase {

    public function setUp(): void
    {
        Factory::getInstance()->register(new FooComparator());
    }

    public function tearDown(): void
    {
        Factory::getInstance()->reset();
    }

    public function testFoo() {
        $a = new Foo('a', 'b');
        $b = new Foo('a', 'b2');
        $c = new Foo('c', 'b');

        // Since FooComparator checks only the relevant property, the following assert should pass
        self::assertEquals($a, $b);
        // But this will fail
        self::assertEquals($a, $c);
    }
}