hiqdev\php\billing\tests\unit\target\TargetTest

Complexity

Total Complexity

23

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	testEquals()	0	16	4
A	tearDown()	0	2	1
A	testMatches()	0	22	1
A	checkDoesntMatch()	0	6	4
A	copy()	0	6	2
A	testGetUniqueId()	0	8	1
A	checkSingleMatch()	0	7	2
A	setUp()	0	15	1
B	checkMatches()	0	12	7

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

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

use hiqdev\php\billing\target\Target;
use hiqdev\php\billing\target\TargetCollection;
use hiqdev\php\billing\target\TargetInterface;

/**
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
class TargetTest extends \PHPUnit\Framework\TestCase
{
    protected $id1 = 1;

    protected $id2 = 2;

    protected function setUp()
    {
        $this->target_ = new Target(Target::ANY,    Target::ANY);

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

        $this->target1 = new Target($this->id1,     Target::ANY);

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

        $this->target2 = new Target($this->id2,     Target::ANY);

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

        $this->server_ = new Target(Target::ANY,    'server');

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

        $this->server1 = new Target($this->id1,     'server');

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

        $this->server2 = new Target($this->id2,     'server');

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

        $this->serverN = new Target(Target::NONE,   'server');

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

        $this->servers = new TargetCollection([$this->server1, $this->server2]);

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

        $this->domain_ = new Target(Target::ANY,    'domain');

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

        $this->domain1 = new Target($this->id1,     'domain');

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

        $this->domain2 = new Target($this->id2,     'domain');

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

        $this->domainN = new Target(Target::NONE,   'domain');

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

        $this->domains = new TargetCollection([$this->domain1, $this->domain2]);

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

    }

    protected function tearDown()
    {
    }

    public function testGetUniqueId()
    {
        $this->assertSame(':',          $this->target_->getUniqueId());
        $this->assertSame(':1',         $this->target1->getUniqueId());
        $this->assertSame(':2',         $this->target2->getUniqueId());
        $this->assertSame('server:',    $this->server_->getUniqueId());
        $this->assertSame('server:1',   $this->server1->getUniqueId());
        $this->assertSame('server:2',   $this->server2->getUniqueId());
    }

    public function testEquals()
    {
        $all = [
            $this->target_, $this->target1, $this->target2,
            $this->server_, $this->server1, $this->server2,
            $this->domain_, $this->domain1, $this->domain2,
        ];
        $copies = [];
        foreach ($all as $k => $v) {
            $copies[$k] = $this->copy($v);
        }

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

    protected function copy(TargetInterface $target)
    {
        if ($target instanceof TargetCollection) {
            return new TargetCollection($target->getTargets());
        } else {
            return new Target($target->getId(), $target->getType());
        }
    }

    public function testMatches()
    {
        $this->checkMatches([
            $this->target_, $this->server_, $this->serverN,
        ], false);

        $this->checkMatches([
            $this->target_, $this->server_, $this->server1, $this->servers,
        ]);
        $this->checkMatches([
            $this->target_, $this->server_, $this->server2, $this->servers,
        ]);

        $this->checkDoesntMatch([
            $this->server1, $this->server2, $this->serverN, $this->domain_,
        ]);
        $this->checkDoesntMatch([
            $this->domain1, $this->domain2, $this->domainN, $this->servers,
        ]);

        $this->checkDoesntMatch([
            $this->server_, $this->domains, $this->domainN, $this->domainN,
        ]);
    }

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

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

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

var_dump('no match', $expect, $lhs, $rhs) looks like debug code. Are you sure you do not want to remove it?

        }
        $this->assertSame($expect, $check);
    }
}