CallbackTest::can_enforce_min_arguments() - Code Metrics - Inspection of "add tests" - zenstruck/callback - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.x ( 100d20...a08e8e )

by Kevin

created 2021-01-08 23:04 UTC

CallbackTest::can_enforce_min_arguments() A

↳ Parent: CallbackTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	4
c	1
b	0
f	1
nc	1
nop	0
dl	0
loc	9
rs	10

<?php

namespace Zenstruck\Callback\Tests;

use PHPUnit\Framework\TestCase;
use Zenstruck\Callback;

/**
 * @author Kevin Bond <[email protected]>
 */
final class CallbackTest extends TestCase
{
    /**
     * @test
     */
    public function can_execute_string_callbacks(): void
    {
        $actual = Callback::createFor('strtoupper')
            ->minArguments(1)
            ->replaceUntypedArgument('foobar')
            ->execute()
        ;

        $this->assertSame('FOOBAR', $actual);
    }

    /**
     * @test
     */
    public function can_execute_closures(): void
    {
        $actual = Callback::createFor(function($string) { return \mb_strtoupper($string); })
            ->minArguments(1)
            ->replaceUntypedArgument('foobar')
            ->execute()
        ;

        $this->assertSame('FOOBAR', $actual);
    }

    /**
     * @test
     */
    public function can_enforce_min_arguments(): void
    {
        $callback = Callback::createFor(function() { return 'ret'; })
            ->minArguments(1)
        ;

        $this->expectException(\ArgumentCountError::class);

        $callback->execute();
    }

    /**
     * @test
     */
    public function can_replace_primitive_typehints(): void
    {
        $actual = Callback::createFor(function(string $string) { return \mb_strtoupper($string); })
            ->minArguments(1)
            ->replaceTypedArgument('string', 'foobar')
            ->execute()
        ;

        $this->assertSame('FOOBAR', $actual);
    }

    /**
     * @test
     */
    public function can_replace_class_argument(): void
    {
        $object = new Object2();
        $function = static function(Object1 $object1, Object2 $object2, $object3) {
            return [
                'object1' => $object1,
                'object2' => $object2,
                'object3' => $object3,
            ];
        };

        $actual = Callback::createFor($function)
            ->replaceTypedArgument(Object1::class, $object)
            ->replaceUntypedArgument($object)
            ->execute()
        ;

        $this->assertSame(
            [
                'object1' => $object,
                'object2' => $object,
                'object3' => $object,
            ],
            $actual
        );
    }

    /**
     * @test
     */
    public function can_replace_class_typehint_with_factory(): void
    {
        $function = static function(Object1 $object1, Object2 $object2, $object3) {
            return [
                'object1' => $object1,
                'object2' => $object2,
                'object3' => $object3,
            ];
        };
        $factoryArgs = [];
        $factory = static function($arg = null) use (&$factoryArgs) {
            $factoryArgs[] = $arg;

            return new Object2();
        };

        $ret = Callback::createFor($function)
            ->replaceTypedArgument(Object1::class, $factory)
            ->replaceUntypedArgument($factory)
            ->execute()
        ;

        $this->assertSame(['object1', 'object2', 'object3'], \array_keys($ret));
        $this->assertInstanceOf(Object2::class, $ret['object1']);
        $this->assertInstanceOf(Object2::class, $ret['object2']);
        $this->assertInstanceOf(Object2::class, $ret['object3']);
        $this->assertSame(
            [Object1::class, Object2::class, null],
            $factoryArgs
        );
    }

    /**
     * @test
     */
    public function type_error_thrown_if_no_untyped_argument_defined(): void
    {
        $callback = Callback::createFor(static function($arg) {});
        $callback = Callback::createFor(static function(/** @scrutinizer ignore-unused */ $arg) {});

        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('No replaceUntypedArgument set');

        $callback->execute();
    }

    /**
     * @test
     */
    public function type_error_thrown_if_type_argument_not_defined(): void
    {
        $callback = Callback::createFor(static function(Object2 $object1) {})
        $callback = Callback::createFor(static function(/** @scrutinizer ignore-unused */ Object2 $object1) {})
            ->replaceTypedArgument(\stdClass::class, new \stdClass())
        ;

        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Unable to replace argument "object1"');

        $callback->execute();
    }

    /**
     * @test
     */
    public function create_must_be_callable(): void
    {
        $this->expectException(\InvalidArgumentException::class);

        Callback::createFor('not a callable');
    }
}

class Object1
{
}

class Object2 extends Object1
{
}


zenstruck / callback

Push — 1.x ( 100d20...a08e8e )

CallbackTest::can_enforce_min_arguments() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like