Basis\Test

Complexity

Total Complexity

6

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Test Coverage

Coverage

86%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ __construct()	0	5	1
F	hp$0 ➔ dispatch()	0	29	11
A	hp$1 ➔ withParams()	0	5	1
A	hp$1 ➔ handler()	0	5	1
A	hp$1 ➔ willReturn()	0	4	1
C	__construct()	0	41	11
A	setup()	0	4	1
A	tearDown()	0	4	1
A	hp$1 ➔ willDo()	0	4	1
B	mock()	0	43	2

<?php

namespace Basis;

use Basis\Converter;
use Basis\Runner;
use Exception;
use PHPUnit\Framework\TestCase;

abstract class Test extends TestCase
{
    use Toolkit;

    public $params = [];

    public function __construct()
    {
        parent::__construct();

        $this->app = new class(getcwd(), $this) extends Application {
            public function __construct(string $root, Test $testInstance)
            {
                parent::__construct($root);
                $this->testInstance = $testInstance;

The property testInstance does not exist. Did you maybe forget to declare it?

            }
            public function dispatch(string $job, array $params = [], string $service = null)
            {
                if (array_key_exists($job, $this->testInstance->mocks)) {
                    $mocks = $this->testInstance->mocks[$job];
                    $valid = null;
                    foreach ($mocks as $mock) {
                        if ($mock->params == $params || (!$mock->params && !$valid)) {
                            $valid = $mock;
                        }
                    }
                    if ($valid) {
                        $result = $valid->result;
                        if (is_callable($result)) {
                            $result = $result($params);
                        }
                        $valid->calls++;
                        return $this->get(Converter::class)->toObject($result);
                    }
                }
                if (!$this->get(Runner::class)->hasJob($job)) {
                    throw new Exception("Remote calls are disabled for tests");
                }
                $converter = $this->get(Converter::class);
                $global = $this->testInstance->params ?: [];
                if (!is_array($global)) {
                    $global = get_object_vars($converter->toObject($this->testInstance->params));
                }
                return parent::dispatch($job, array_merge($params, $global), $service);
            }
        };
    }

    public function setup()
    {
        $this->dispatch('tarantool.migrate');
    }

    public function tearDown()
    {
        $this->dispatch('tarantool.clear');
    }

    public $mocks = [];
    public function mock(string $job, array $params = [])
    {
        if (!array_key_exists($job, $this->mocks)) {
            $this->mocks[$job] = [];
        }

        $mock = new class {

            public $params;
            public $result;
            public $calls = 0;

            public function withParams($params)
            {
                $this->params = $params;
                return $this;
            }

            public function handler($result)
            {
                $this->result = $result;
                return $this;
            }

            public function willDo($result)
            {
                return $this->handler($result);
            }

            public function willReturn($result)
            {
                return $this->handler($result);
            }
        };

        if (count($params)) {
            $mock->params = $params;
        }

        $this->mocks[$job][] = $mock;

        return $mock;
    }
}