hiqdev\php\billing\tests\unit\type\TypeTest

Complexity

Total Complexity

22

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Importance

Changes	12
Bugs	0	Features	5

10 Methods

Rating	Name	Duplication	Size	Complexity
A	copy()	0	3	1
A	testEquals()	0	12	4
B	checkMatches()	0	12	7
A	setUp()	0	27	1
A	testGetUniqueId()	0	8	1
A	checkSingleMatch()	0	7	1
A	testMatches()	0	19	1
A	tearDown()	0	2	1
A	checkEquals()	0	7	1
A	checkDoesntMatch()	0	6	4

<?php
/**
 * PHP Billing Library
 *
 * @link      https://github.com/hiqdev/php-billing
 * @package   php-billing
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017-2020, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\php\billing\tests\unit\type;

use hiqdev\php\billing\type\Type;
use hiqdev\php\billing\type\TypeInterface;

/**
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
class TypeTest extends \PHPUnit\Framework\TestCase
{
    protected $sid1 = 101;
    protected $sid2 = 102;

    protected $sop1 = 'server1';
    protected $sop2 = 'server2';

    protected $did1 = 201;
    protected $did2 = 202;

    protected $dop1 = 'domain1';
    protected $dop2 = 'domain2';

    protected function setUp(): void
    {
        $this->nonenone = new Type(Type::NONE,   Type::NONE);

The property nonenone does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server11 = new Type($this->sid1,  $this->sop1);

The property server11 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server12 = new Type($this->sid1,  $this->sop2);

The property server12 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server_1 = new Type(Type::ANY,    $this->sop1);

The property server_1 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server1_ = new Type($this->sid1,  Type::ANY);

The property server1_ does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->serverN1 = new Type(Type::NONE,   $this->sop1);

The property serverN1 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server1N = new Type($this->sid1,  Type::NONE);

The property server1N does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->serverN_ = new Type(Type::NONE,   Type::ANY);

The property serverN_ does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server_N = new Type(Type::ANY,    Type::NONE);

The property server_N does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server22 = new Type($this->sid2,  $this->sop2);

The property server22 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server21 = new Type($this->sid2,  $this->sop1);

The property server21 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server_2 = new Type(Type::ANY,    $this->sop2);

The property server_2 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server2_ = new Type($this->sid2,  Type::ANY);

The property server2_ does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->serverN2 = new Type(Type::NONE,   $this->sop2);

The property serverN2 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->server2N = new Type($this->sid2,  Type::NONE);

The property server2N does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain11 = new Type($this->did1,  $this->dop1);

The property domain11 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain_1 = new Type(Type::ANY,    $this->dop1);

The property domain_1 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain1_ = new Type($this->did1,  Type::ANY);

The property domain1_ does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domainN1 = new Type(Type::NONE,   $this->dop1);

The property domainN1 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain1N = new Type($this->did1,  Type::NONE);

The property domain1N does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain22 = new Type($this->did2,  $this->dop2);

The property domain22 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain_2 = new Type(Type::ANY,    $this->dop2);

The property domain_2 does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->domain2_ = new Type($this->did2,  Type::ANY);

The property domain2_ does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    protected function tearDown(): void
    {
    }

    protected function copy(TypeInterface $type)
    {
        return new Type($type->getId(), $type->getName());
    }

    public function testGetUniqueId()
    {
        $this->assertSame($this->sop1,  $this->server11->getUniqueId());
        $this->assertSame($this->sop1,  $this->server_1->getUniqueId());
        $this->assertSame($this->sid1,  $this->server1_->getUniqueId());
        $this->assertSame($this->sop2,  $this->server22->getUniqueId());
        $this->assertSame($this->sop2,  $this->server_2->getUniqueId());
        $this->assertSame($this->sid2,  $this->server2_->getUniqueId());
    }

    public function testEquals()
    {
        $all = [$this->server11, $this->server_1, $this->server1_];
        $copies = [];
        foreach ($all as $k => $v) {
            $copies[$k] = $this->copy($v);
        }

        foreach ($all as $k => $v) {
            foreach ($copies as $j => $w) {
                $this->checkEquals($j === $k, $v, $w);
                $this->checkEquals($j === $k, $w, $v);
            }
        }
    }

    protected function checkEquals(bool $expect, $lhs, $rhs)
    {
        $check = $lhs->equals($rhs);
        /*if ($check !== $expect) {
            var_dump('no equality', $expect, $lhs, $rhs);
        }*/
        $this->assertSame($expect, $check);
    }

    public function testMatches()
    {
        $this->checkMatches([$this->server11, $this->server_1]);
        $this->checkMatches([$this->server_1, $this->serverN1], false);
        $this->checkMatches([$this->server11, $this->server1_, $this->server12, $this->server1N]);

        $this->checkDoesntMatch([
            $this->server1N, $this->server2N, $this->serverN_,
            $this->serverN1, $this->serverN2, $this->server_N,
        ]);

        $this->checkDoesntMatch([
            $this->server11, $this->server_2, $this->serverN1,
            $this->domain11, $this->domain_2, $this->domainN1,
        ]);

        $this->checkDoesntMatch([
            $this->server_1, $this->server1_, $this->server_2, $this->server2_,
            $this->domain_1, $this->domain1_, $this->domain_2, $this->domain2_,
        ]);
    }

    protected function checkDoesntMatch(array $types)
    {
        foreach ($types as $k => $v) {
            foreach ($types as $j => $w) {
                if ($k !== $j) {
                    $this->checkSingleMatch(false, $v, $w);
                }
            }
        }
    }

    protected function checkMatches(array $types, bool $self = true)
    {
        $all = $types;
        if ($self) {
            foreach ($types as $type) {
                $all[] = $this->copy($type);
            }
        }
        foreach ($all as $k => $v) {
            foreach ($all as $j => $w) {
                if ($self || $k !== $j) {
                    $this->checkSingleMatch(true, $v, $w);
                }
            }
        }
    }

    protected function checkSingleMatch(bool $expect, $lhs, $rhs)
    {
        $check = $lhs->matches($rhs);
        /*if ($check !== $expect) {
            var_dump('no match', $expect, $lhs, $rhs);
        }*/
        $this->assertSame($expect, $check);
    }
}