Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
PromiseAdapter	[ DIR ]	drwxr-xr-x	2018-06-13 09:00
PromiseTest	[ DIR ]	drwxr-xr-x	2018-06-13 09:00
Stub	[ DIR ]	drwxr-xr-x	2018-06-13 09:00
fixtures	[ DIR ]	drwxr-xr-x	2018-06-13 09:00
CancellationQueueTest.php	2.46 KB	-rw-r--r--	2018-06-13 09:00
DeferredTest.php	3.08 KB	-rw-r--r--	2018-06-13 09:00
FulfilledPromiseTest.php	2.24 KB	-rw-r--r--	2018-06-13 09:00
FunctionAllTest.php	2.76 KB	-rw-r--r--	2018-06-13 09:00
FunctionAnyTest.php	5.24 KB	-rw-r--r--	2018-06-13 09:00
FunctionCheckTypehintTest.php	3.45 KB	-rw-r--r--	2018-06-13 09:00
FunctionMapTest.php	4.63 KB	-rw-r--r--	2018-06-13 09:00
FunctionRaceTest.php	5.03 KB	-rw-r--r--	2018-06-13 09:00
FunctionReduceTest.php	8.21 KB	-rw-r--r--	2018-06-13 09:00
FunctionRejectTest.php	1.4 KB	-rw-r--r--	2018-06-13 09:00
FunctionResolveTest.php	4.04 KB	-rw-r--r--	2018-06-13 09:00
FunctionSomeTest.php	6.53 KB	-rw-r--r--	2018-06-13 09:00
LazyPromiseTest.php	2.77 KB	-rw-r--r--	2018-06-13 09:00
PromiseTest.php	8.59 KB	-rw-r--r--	2018-06-13 09:00
RejectedPromiseTest.php	2.24 KB	-rw-r--r--	2018-06-13 09:00
TestCase.php	895 B	-rw-r--r--	2018-06-13 09:00
bootstrap.php	192 B	-rw-r--r--	2018-06-13 09:00

Rename

<?php

namespace React\Promise;

class FunctionMapTest extends TestCase
{
    protected function mapper()
    {
        return function ($val) {
            return $val * 2;
        };
    }

protected function promiseMapper()
    {
        return function ($val) {
            return resolve($val * 2);
        };
    }

/** @test */
    public function shouldMapInputValuesArray()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([2, 4, 6]));

map(
            [1, 2, 3],
            $this->mapper()
        )->then($mock);
    }

/** @test */
    public function shouldMapInputPromisesArray()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([2, 4, 6]));

map(
            [resolve(1), resolve(2), resolve(3)],
            $this->mapper()
        )->then($mock);
    }

/** @test */
    public function shouldMapMixedInputArray()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([2, 4, 6]));

map(
            [1, resolve(2), 3],
            $this->mapper()
        )->then($mock);
    }

/** @test */
    public function shouldMapInputWhenMapperReturnsAPromise()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([2, 4, 6]));

map(
            [1, 2, 3],
            $this->promiseMapper()
        )->then($mock);
    }

/** @test */
    public function shouldAcceptAPromiseForAnArray()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([2, 4, 6]));

map(
            resolve([1, resolve(2), 3]),
            $this->mapper()
        )->then($mock);
    }

/** @test */
    public function shouldResolveToEmptyArrayWhenInputPromiseDoesNotResolveToArray()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([]));

map(
            resolve(1),
            $this->mapper()
        )->then($mock);
    }

/** @test */
    public function shouldPreserveTheOrderOfArrayWhenResolvingAsyncPromises()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo([2, 4, 6]));

$deferred = new Deferred();

map(
            [resolve(1), $deferred->promise(), resolve(3)],
            $this->mapper()
        )->then($mock);

$deferred->resolve(2);
    }

/** @test */
    public function shouldRejectWhenInputContainsRejection()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo(2));

map(
            [resolve(1), reject(2), resolve(3)],
            $this->mapper()
        )->then($this->expectCallableNever(), $mock);
    }

/** @test */
    public function shouldRejectWhenInputPromiseRejects()
    {
        $mock = $this->createCallableMock();
        $mock
            ->expects($this->once())
            ->method('__invoke')
            ->with($this->identicalTo(null));

map(
            reject(),
            $this->mapper()
        )->then($this->expectCallableNever(), $mock);
    }

/** @test */
    public function shouldCancelInputPromise()
    {
        $mock = $this
            ->getMockBuilder('React\Promise\CancellablePromiseInterface')
            ->getMock();
        $mock
            ->expects($this->once())
            ->method('cancel');

map(
            $mock,
            $this->mapper()
        )->cancel();
    }

/** @test */
    public function shouldCancelInputArrayPromises()
    {
        $mock1 = $this
            ->getMockBuilder('React\Promise\CancellablePromiseInterface')
            ->getMock();
        $mock1
            ->expects($this->once())
            ->method('cancel');

$mock2 = $this
            ->getMockBuilder('React\Promise\CancellablePromiseInterface')
            ->getMock();
        $mock2
            ->expects($this->once())
            ->method('cancel');

map(
            [$mock1, $mock2],
            $this->mapper()
        )->cancel();
    }
}