pax_global_header00006660000000000000000000000064127121623740014517gustar00rootroot0000000000000052 comment=8025426794f1944de806618671d4fa476dc7626f promise-2.4.1/000077500000000000000000000000001271216237400132015ustar00rootroot00000000000000promise-2.4.1/.gitignore000066400000000000000000000000671271216237400151740ustar00rootroot00000000000000composer.lock composer.phar phpunit.xml build/ vendor/ promise-2.4.1/.travis.yml000066400000000000000000000007201271216237400153110ustar00rootroot00000000000000language: php php: - 5.4 - 5.5 - 5.6 - 7.0 - nightly - hhvm before_install: - composer self-update install: - composer install script: - phpunit -v --coverage-text --coverage-clover=./build/logs/clover.xml after_script: - if [ -f ./build/logs/clover.xml ]; then travis_retry composer require satooshi/php-coveralls --no-interaction --update-with-dependencies; fi - if [ -f ./build/logs/clover.xml ]; then php vendor/bin/coveralls -v; fi promise-2.4.1/CHANGELOG.md000066400000000000000000000064121271216237400150150ustar00rootroot00000000000000CHANGELOG ========= * 2.4.1 (2016-05-03) * Fix `some()` not cancelling pending promises when too much input promises reject (16ff799). * 2.4.0 (2016-03-31) * Support foreign thenables in `resolve()`. Any object that provides a `then()` method is now assimilated to a trusted promise that follows the state of this thenable (#52). * Fix `some()` and `any()` for input arrays containing not enough items (#34). * 2.3.0 (2016-03-24) * Allow cancellation of promises returned by functions working on promise collections (#36). * Handle `\Throwable` in the same way as `\Exception` (#51 by @joshdifabio). * 2.2.2 (2016-02-26) * Fix cancellation handlers called multiple times (#47 by @clue). * 2.2.1 (2015-07-03) * Fix stack error when resolving a promise in its own fulfillment or rejection handlers. * 2.2.0 (2014-12-30) * Introduce new `ExtendedPromiseInterface` implemented by all promises. * Add new `done()` method (part of the `ExtendedPromiseInterface`). * Add new `otherwise()` method (part of the `ExtendedPromiseInterface`). * Add new `always()` method (part of the `ExtendedPromiseInterface`). * Add new `progress()` method (part of the `ExtendedPromiseInterface`). * Rename `Deferred::progress` to `Deferred::notify` to avoid confusion with `ExtendedPromiseInterface::progress` (a `Deferred::progress` alias is still available for backward compatibility) * `resolve()` now always returns a `ExtendedPromiseInterface`. * 2.1.0 (2014-10-15) * Introduce new `CancellablePromiseInterface` implemented by all promises. * Add new `cancel()` method (part of the `CancellablePromiseInterface`). * 2.0.0 (2013-12-10) New major release. The goal is to streamline the API and to make it more compliant with other promise libraries and especially with the new upcoming [ES6 promises specification](https://github.com/domenic/promises-unwrapping/). * Add standalone Promise class. * Add new `race()` function. * BC break: Bump minimum PHP version to PHP 5.4. * BC break: Remove `ResolverInterface` and `PromiseInterface` from `Deferred`. * BC break: Change signature of `PromiseInterface`. * BC break: Remove `When` and `Util` classes and move static methods to functions. * BC break: `FulfilledPromise` and `RejectedPromise` now throw an exception when initialized with a promise instead of a value/reason. * BC break: `Deferred::resolve()` and `Deferred::reject()` no longer return a promise. * 1.0.4 (2013-04-03) * Trigger PHP errors when invalid callback is passed. * Fully resolve rejection value before calling rejection handler. * Add `When::lazy()` to create lazy promises which will be initialized once a consumer calls the `then()` method. * 1.0.3 (2012-11-17) * Add `PromisorInterface` for objects that have a `promise()` method. * 1.0.2 (2012-11-14) * Fix bug in `When::any()` not correctly unwrapping to a single result value. * `$promiseOrValue` argument of `When::resolve()` and When::reject() is now optional. * 1.0.1 (2012-11-13) * Prevent deep recursion which was reaching `xdebug.max_nesting_level` default of 100. * 1.0.0 (2012-11-07) * First tagged release. promise-2.4.1/LICENSE000066400000000000000000000020451271216237400142070ustar00rootroot00000000000000Copyright (c) 2012-2016 Jan Sorgalla Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. promise-2.4.1/README.md000066400000000000000000000635671271216237400145010ustar00rootroot00000000000000React/Promise ============= A lightweight implementation of [CommonJS Promises/A](http://wiki.commonjs.org/wiki/Promises/A) for PHP. [![Build Status](https://travis-ci.org/reactphp/promise.svg?branch=master)](http://travis-ci.org/reactphp/promise) [![Coverage Status](https://coveralls.io/repos/github/reactphp/promise/badge.svg?branch=master)](https://coveralls.io/github/reactphp/promise?branch=master) Table of Contents ----------------- 1. [Introduction](#introduction) 2. [Concepts](#concepts) * [Deferred](#deferred) * [Promise](#promise) 3. [API](#api) * [Deferred](#deferred-1) * [Deferred::promise()](#deferredpromise) * [Deferred::resolve()](#deferredresolve) * [Deferred::reject()](#deferredreject) * [Deferred::notify()](#deferrednotify) * [PromiseInterface](#promiseinterface) * [PromiseInterface::then()](#promiseinterfacethen) * [ExtendedPromiseInterface](#extendedpromiseinterface) * [ExtendedPromiseInterface::done()](#extendedpromiseinterfacedone) * [ExtendedPromiseInterface::otherwise()](#extendedpromiseinterfaceotherwise) * [ExtendedPromiseInterface::always()](#extendedpromiseinterfacealways) * [ExtendedPromiseInterface::progress()](#extendedpromiseinterfaceprogress) * [CancellablePromiseInterface](#cancellablepromiseinterface) * [CancellablePromiseInterface::cancel()](#cancellablepromiseinterfacecancel) * [Promise](#promise-1) * [FulfilledPromise](#fulfilledpromise) * [RejectedPromise](#rejectedpromise) * [LazyPromise](#lazypromise) * [Functions](#functions) * [resolve()](#resolve) * [reject()](#reject) * [all()](#all) * [race()](#race) * [any()](#any) * [some()](#some) * [map()](#map) * [reduce()](#reduce) * [PromisorInterface](#promisorinterface) 4. [Examples](#examples) * [How to use Deferred](#how-to-use-deferred) * [How promise forwarding works](#how-promise-forwarding-works) * [Resolution forwarding](#resolution-forwarding) * [Rejection forwarding](#rejection-forwarding) * [Mixed resolution and rejection forwarding](#mixed-resolution-and-rejection-forwarding) * [Progress event forwarding](#progress-event-forwarding) * [done() vs. then()](#done-vs-then) 5. [Credits](#credits) 6. [License](#license) Introduction ------------ React/Promise is a library implementing [CommonJS Promises/A](http://wiki.commonjs.org/wiki/Promises/A) for PHP. It also provides several other useful promise-related concepts, such as joining multiple promises and mapping and reducing collections of promises. If you've never heard about promises before, [read this first](https://gist.github.com/3889970). Concepts -------- ### Deferred A **Deferred** represents a computation or unit of work that may not have completed yet. Typically (but not always), that computation will be something that executes asynchronously and completes at some point in the future. ### Promise While a deferred represents the computation itself, a **Promise** represents the result of that computation. Thus, each deferred has a promise that acts as a placeholder for its actual result. API --- ### Deferred A deferred represents an operation whose resolution is pending. It has separate promise and resolver parts. ```php $deferred = new React\Promise\Deferred(); $promise = $deferred->promise(); $deferred->resolve(mixed $value = null); $deferred->reject(mixed $reason = null); $deferred->notify(mixed $update = null); ``` The `promise` method returns the promise of the deferred. The `resolve` and `reject` methods control the state of the deferred. The `notify` method is for progress notification. The constructor of the `Deferred` accepts an optional `$canceller` argument. See [Promise](#promise-1) for more information. #### Deferred::promise() ```php $promise = $deferred->promise(); ``` Returns the promise of the deferred, which you can hand out to others while keeping the authority to modify its state to yourself. #### Deferred::resolve() ```php $deferred->resolve(mixed $value = null); ``` Resolves the promise returned by `promise()`. All consumers are notified by having `$onFulfilled` (which they registered via `$promise->then()`) called with `$value`. If `$value` itself is a promise, the promise will transition to the state of this promise once it is resolved. #### Deferred::reject() ```php $deferred->reject(mixed $reason = null); ``` Rejects the promise returned by `promise()`, signalling that the deferred's computation failed. All consumers are notified by having `$onRejected` (which they registered via `$promise->then()`) called with `$reason`. If `$reason` itself is a promise, the promise will be rejected with the outcome of this promise regardless whether it fulfills or rejects. #### Deferred::notify() ```php $deferred->notify(mixed $update = null); ``` Triggers progress notifications, to indicate to consumers that the computation is making progress toward its result. All consumers are notified by having `$onProgress` (which they registered via `$promise->then()`) called with `$update`. ### PromiseInterface The promise interface provides the common interface for all promise implementations. A promise represents an eventual outcome, which is either fulfillment (success) and an associated value, or rejection (failure) and an associated reason. Once in the fulfilled or rejected state, a promise becomes immutable. Neither its state nor its result (or error) can be modified. #### Implementations * [Promise](#promise-1) * [FulfilledPromise](#fulfilledpromise) * [RejectedPromise](#rejectedpromise) * [LazyPromise](#lazypromise) #### PromiseInterface::then() ```php $transformedPromise = $promise->then(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null); ``` Transforms a promise's value by applying a function to the promise's fulfillment or rejection value. Returns a new promise for the transformed result. The `then()` method registers new fulfilled, rejection and progress handlers with a promise (all parameters are optional): * `$onFulfilled` will be invoked once the promise is fulfilled and passed the result as the first argument. * `$onRejected` will be invoked once the promise is rejected and passed the reason as the first argument. * `$onProgress` will be invoked whenever the producer of the promise triggers progress notifications and passed a single argument (whatever it wants) to indicate progress. It returns a new promise that will fulfill with the return value of either `$onFulfilled` or `$onRejected`, whichever is called, or will reject with the thrown exception if either throws. A promise makes the following guarantees about handlers registered in the same call to `then()`: 1. Only one of `$onFulfilled` or `$onRejected` will be called, never both. 2. `$onFulfilled` and `$onRejected` will never be called more than once. 3. `$onProgress` may be called multiple times. #### See also * [resolve()](#resolve) - Creating a resolved promise * [reject()](#reject) - Creating a rejected promise * [ExtendedPromiseInterface::done()](#extendedpromiseinterfacedone) * [done() vs. then()](#done-vs-then) ### ExtendedPromiseInterface The ExtendedPromiseInterface extends the PromiseInterface with useful shortcut and utility methods which are not part of the Promises/A specification. #### Implementations * [Promise](#promise-1) * [FulfilledPromise](#fulfilledpromise) * [RejectedPromise](#rejectedpromise) * [LazyPromise](#lazypromise) #### ExtendedPromiseInterface::done() ```php $promise->done(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null); ``` Consumes the promise's ultimate value if the promise fulfills, or handles the ultimate error. It will cause a fatal error if either `$onFulfilled` or `$onRejected` throw or return a rejected promise. Since the purpose of `done()` is consumption rather than transformation, `done()` always returns `null`. #### See also * [PromiseInterface::then()](#promiseinterfacethen) * [done() vs. then()](#done-vs-then) #### ExtendedPromiseInterface::otherwise() ```php $promise->otherwise(callable $onRejected); ``` Registers a rejection handler for promise. It is a shortcut for: ```php $promise->then(null, $onRejected); ``` Additionally, you can type hint the `$reason` argument of `$onRejected` to catch only specific errors. ```php $promise ->otherwise(function (\RuntimeException $reason) { // Only catch \RuntimeException instances // All other types of errors will propagate automatically }) ->otherwise(function ($reason) { // Catch other errors )}; ``` #### ExtendedPromiseInterface::always() ```php $newPromise = $promise->always(callable $onFulfilledOrRejected); ``` Allows you to execute "cleanup" type tasks in a promise chain. It arranges for `$onFulfilledOrRejected` to be called, with no arguments, when the promise is either fulfilled or rejected. * If `$promise` fulfills, and `$onFulfilledOrRejected` returns successfully, `$newPromise` will fulfill with the same value as `$promise`. * If `$promise` fulfills, and `$onFulfilledOrRejected` throws or returns a rejected promise, `$newPromise` will reject with the thrown exception or rejected promise's reason. * If `$promise` rejects, and `$onFulfilledOrRejected` returns successfully, `$newPromise` will reject with the same reason as `$promise`. * If `$promise` rejects, and `$onFulfilledOrRejected` throws or returns a rejected promise, `$newPromise` will reject with the thrown exception or rejected promise's reason. `always()` behaves similarly to the synchronous finally statement. When combined with `otherwise()`, `always()` allows you to write code that is similar to the familiar synchronous catch/finally pair. Consider the following synchronous code: ```php try { return doSomething(); } catch(\Exception $e) { return handleError($e); } finally { cleanup(); } ``` Similar asynchronous code (with `doSomething()` that returns a promise) can be written: ```php return doSomething() ->otherwise('handleError') ->always('cleanup'); ``` #### ExtendedPromiseInterface::progress() ```php $promise->progress(callable $onProgress); ``` Registers a handler for progress updates from promise. It is a shortcut for: ```php $promise->then(null, null, $onProgress); ``` ### CancellablePromiseInterface A cancellable promise provides a mechanism for consumers to notify the creator of the promise that they are not longer interested in the result of an operation. #### CancellablePromiseInterface::cancel() ``` php $promise->cancel(); ``` The `cancel()` method notifies the creator of the promise that there is no further interest in the results of the operation. Once a promise is settled (either fulfilled or rejected), calling `cancel()` on a promise has no effect. #### Implementations * [Promise](#promise-1) * [FulfilledPromise](#fulfilledpromise) * [RejectedPromise](#rejectedpromise) * [LazyPromise](#lazypromise) ### Promise Creates a promise whose state is controlled by the functions passed to `$resolver`. ```php $resolver = function (callable $resolve, callable $reject, callable $notify) { // Do some work, possibly asynchronously, and then // resolve or reject. You can notify of progress events // along the way if you want/need. $resolve($awesomeResult); // or $resolve($anotherPromise); // or $reject($nastyError); // or $notify($progressNotification); }; $canceller = function (callable $resolve, callable $reject, callable $progress) { // Cancel/abort any running operations like network connections, streams etc. $reject(new \Exception('Promise cancelled')); }; $promise = new React\Promise\Promise($resolver, $canceller); ``` The promise constructor receives a resolver function and an optional canceller function which both will be called with 3 arguments: * `$resolve($value)` - Primary function that seals the fate of the returned promise. Accepts either a non-promise value, or another promise. When called with a non-promise value, fulfills promise with that value. When called with another promise, e.g. `$resolve($otherPromise)`, promise's fate will be equivalent to that of `$otherPromise`. * `$reject($reason)` - Function that rejects the promise. * `$notify($update)` - Function that issues progress events for the promise. If the resolver or canceller throw an exception, the promise will be rejected with that thrown exception as the rejection reason. The resolver function will be called immediately, the canceller function only once all consumers called the `cancel()` method of the promise. ### FulfilledPromise Creates a already fulfilled promise. ```php $promise = React\Promise\FulfilledPromise($value); ``` Note, that `$value` **cannot** be a promise. It's recommended to use [resolve()](#resolve) for creating resolved promises. ### RejectedPromise Creates a already rejected promise. ```php $promise = React\Promise\RejectedPromise($reason); ``` Note, that `$reason` **cannot** be a promise. It's recommended to use [reject()](#reject) for creating rejected promises. ### LazyPromise Creates a promise which will be lazily initialized by `$factory` once a consumer calls the `then()` method. ```php $factory = function () { $deferred = new React\Promise\Deferred(); // Do some heavy stuff here and resolve the deferred once completed return $deferred->promise(); }; $promise = React\Promise\LazyPromise($factory); // $factory will only be executed once we call then() $promise->then(function ($value) { }); ``` ### Functions Useful functions for creating, joining, mapping and reducing collections of promises. All functions working on promise collections (like `all()`, `race()`, `some()` etc.) support cancellation. This means, if you call `cancel()` on the returned promise, all promises in the collection are cancelled. If the collection itself is a promise which resolves to an array, this promise is also cancelled. #### resolve() ```php $promise = React\Promise\resolve(mixed $promiseOrValue); ``` Creates a promise for the supplied `$promiseOrValue`. If `$promiseOrValue` is a value, it will be the resolution value of the returned promise. If `$promiseOrValue` is a thenable (any object that provides a `then()` method), a trusted promise that follows the state of the thenable is returned. If `$promiseOrValue` is a promise, it will be returned as is. Note: The promise returned is always a promise implementing [ExtendedPromiseInterface](#extendedpromiseinterface). If you pass in a custom promise which only implements [PromiseInterface](#promiseinterface), this promise will be assimilated to a extended promise following `$promiseOrValue`. #### reject() ```php $promise = React\Promise\reject(mixed $promiseOrValue); ``` Creates a rejected promise for the supplied `$promiseOrValue`. If `$promiseOrValue` is a value, it will be the rejection value of the returned promise. If `$promiseOrValue` is a promise, its completion value will be the rejected value of the returned promise. This can be useful in situations where you need to reject a promise without throwing an exception. For example, it allows you to propagate a rejection with the value of another promise. #### all() ```php $promise = React\Promise\all(array|React\Promise\PromiseInterface $promisesOrValues); ``` Returns a promise that will resolve only once all the items in `$promisesOrValues` have resolved. The resolution value of the returned promise will be an array containing the resolution values of each of the items in `$promisesOrValues`. #### race() ```php $promise = React\Promise\race(array|React\Promise\PromiseInterface $promisesOrValues); ``` Initiates a competitive race that allows one winner. Returns a promise which is resolved in the same way the first settled promise resolves. #### any() ```php $promise = React\Promise\any(array|React\Promise\PromiseInterface $promisesOrValues); ``` Returns a promise that will resolve when any one of the items in `$promisesOrValues` resolves. The resolution value of the returned promise will be the resolution value of the triggering item. The returned promise will only reject if *all* items in `$promisesOrValues` are rejected. The rejection value will be an array of all rejection reasons. The returned promise will also reject with a `React\Promise\Exception\LengthException` if `$promisesOrValues` contains 0 items. #### some() ```php $promise = React\Promise\some(array|React\Promise\PromiseInterface $promisesOrValues, integer $howMany); ``` Returns a promise that will resolve when `$howMany` of the supplied items in `$promisesOrValues` resolve. The resolution value of the returned promise will be an array of length `$howMany` containing the resolution values of the triggering items. The returned promise will reject if it becomes impossible for `$howMany` items to resolve (that is, when `(count($promisesOrValues) - $howMany) + 1` items reject). The rejection value will be an array of `(count($promisesOrValues) - $howMany) + 1` rejection reasons. The returned promise will also reject with a `React\Promise\Exception\LengthException` if `$promisesOrValues` contains less items than `$howMany`. #### map() ```php $promise = React\Promise\map(array|React\Promise\PromiseInterface $promisesOrValues, callable $mapFunc); ``` Traditional map function, similar to `array_map()`, but allows input to contain promises and/or values, and `$mapFunc` may return either a value or a promise. The map function receives each item as argument, where item is a fully resolved value of a promise or value in `$promisesOrValues`. #### reduce() ```php $promise = React\Promise\reduce(array|React\Promise\PromiseInterface $promisesOrValues, callable $reduceFunc , $initialValue = null); ``` Traditional reduce function, similar to `array_reduce()`, but input may contain promises and/or values, and `$reduceFunc` may return either a value or a promise, *and* `$initialValue` may be a promise or a value for the starting value. ### PromisorInterface The `React\Promise\PromisorInterface` provides a common interface for objects that provide a promise. `React\Promise\Deferred` implements it, but since it is part of the public API anyone can implement it. Examples -------- ### How to use Deferred ```php function getAwesomeResultPromise() { $deferred = new React\Promise\Deferred(); // Execute a Node.js-style function using the callback pattern computeAwesomeResultAsynchronously(function ($error, $result) use ($deferred) { if ($error) { $deferred->reject($error); } else { $deferred->resolve($result); } }); // Return the promise return $deferred->promise(); } getAwesomeResultPromise() ->then( function ($value) { // Deferred resolved, do something with $value }, function ($reason) { // Deferred rejected, do something with $reason }, function ($update) { // Progress notification triggered, do something with $update } ); ``` ### How promise forwarding works A few simple examples to show how the mechanics of Promises/A forwarding works. These examples are contrived, of course, and in real usage, promise chains will typically be spread across several function calls, or even several levels of your application architecture. #### Resolution forwarding Resolved promises forward resolution values to the next promise. The first promise, `$deferred->promise()`, will resolve with the value passed to `$deferred->resolve()` below. Each call to `then()` returns a new promise that will resolve with the return value of the previous handler. This creates a promise "pipeline". ```php $deferred = new React\Promise\Deferred(); $deferred->promise() ->then(function ($x) { // $x will be the value passed to $deferred->resolve() below // and returns a *new promise* for $x + 1 return $x + 1; }) ->then(function ($x) { // $x === 2 // This handler receives the return value of the // previous handler. return $x + 1; }) ->then(function ($x) { // $x === 3 // This handler receives the return value of the // previous handler. return $x + 1; }) ->then(function ($x) { // $x === 4 // This handler receives the return value of the // previous handler. echo 'Resolve ' . $x; }); $deferred->resolve(1); // Prints "Resolve 4" ``` #### Rejection forwarding Rejected promises behave similarly, and also work similarly to try/catch: When you catch an exception, you must rethrow for it to propagate. Similarly, when you handle a rejected promise, to propagate the rejection, "rethrow" it by either returning a rejected promise, or actually throwing (since promise translates thrown exceptions into rejections) ```php $deferred = new React\Promise\Deferred(); $deferred->promise() ->then(function ($x) { throw new \Exception($x + 1); }) ->otherwise(function (\Exception $x) { // Propagate the rejection throw $x; }) ->otherwise(function (\Exception $x) { // Can also propagate by returning another rejection return React\Promise\reject( new \Exception($x->getMessage() + 1) ); }) ->otherwise(function ($x) { echo 'Reject ' . $x->getMessage(); // 3 }); $deferred->resolve(1); // Prints "Reject 3" ``` #### Mixed resolution and rejection forwarding Just like try/catch, you can choose to propagate or not. Mixing resolutions and rejections will still forward handler results in a predictable way. ```php $deferred = new React\Promise\Deferred(); $deferred->promise() ->then(function ($x) { return $x + 1; }) ->then(function ($x) { throw new \Exception($x + 1); }) ->otherwise(function (\Exception $x) { // Handle the rejection, and don't propagate. // This is like catch without a rethrow return $x->getMessage() + 1; }) ->then(function ($x) { echo 'Mixed ' . $x; // 4 }); $deferred->resolve(1); // Prints "Mixed 4" ``` #### Progress event forwarding In the same way as resolution and rejection handlers, your progress handler **MUST** return a progress event to be propagated to the next link in the chain. If you return nothing, `null` will be propagated. Also in the same way as resolutions and rejections, if you don't register a progress handler, the update will be propagated through. If your progress handler throws an exception, the exception will be propagated to the next link in the chain. The best thing to do is to ensure your progress handlers do not throw exceptions. This gives you the opportunity to transform progress events at each step in the chain so that they are meaningful to the next step. It also allows you to choose not to transform them, and simply let them propagate untransformed, by not registering a progress handler. ```php $deferred = new React\Promise\Deferred(); $deferred->promise() ->progress(function ($update) { return $update + 1; }) ->progress(function ($update) { echo 'Progress ' . $update; // 2 }); $deferred->notify(1); // Prints "Progress 2" ``` ### done() vs. then() The golden rule is: Either return your promise, or call done() on it. At a first glance, `then()` and `done()` seem very similar. However, there are important distinctions. The intent of `then()` is to transform a promise's value and to pass or return a new promise for the transformed value along to other parts of your code. The intent of `done()` is to consume a promise's value, transferring responsibility for the value to your code. In addition to transforming a value, `then()` allows you to recover from, or propagate intermediate errors. Any errors that are not handled will be caught by the promise machinery and used to reject the promise returned by `then()`. Calling `done()` transfers all responsibility for errors to your code. If an error (either a thrown exception or returned rejection) escapes the `$onFulfilled` or `$onRejected` callbacks you provide to done, it will be rethrown in an uncatchable way causing a fatal error. ```php function getJsonResult() { return queryApi() ->then( // Transform API results to an object function ($jsonResultString) { return json_decode($jsonResultString); }, // Transform API errors to an exception function ($jsonErrorString) { $object = json_decode($jsonErrorString); throw new ApiErrorException($object->errorMessage); } ); } // Here we provide no rejection handler. If the promise returned has been // rejected, the ApiErrorException will be thrown getJsonResult() ->done( // Consume transformed object function ($jsonResultObject) { // Do something with $jsonResultObject } ); // Here we provide a rejection handler which will either throw while debugging // or log the exception getJsonResult() ->done( function ($jsonResultObject) { // Do something with $jsonResultObject }, function (ApiErrorException $exception) { if (isDebug()) { throw $exception; } else { logException($exception); } } ); ``` Note that if a rejection value is not an instance of `\Exception`, it will be wrapped in an exception of the type `React\Promise\UnhandledRejectionException`. You can get the original rejection reason by calling `$exception->getReason()`. Credits ------- React/Promise is a port of [when.js](https://github.com/cujojs/when) by [Brian Cavalier](https://github.com/briancavalier). Also, large parts of the documentation have been ported from the when.js [Wiki](https://github.com/cujojs/when/wiki) and the [API docs](https://github.com/cujojs/when/blob/master/docs/api.md). License ------- React/Promise is released under the [MIT](https://github.com/reactphp/promise/blob/master/LICENSE) license. promise-2.4.1/composer.json000066400000000000000000000011501271216237400157200ustar00rootroot00000000000000{ "name": "react/promise", "description": "A lightweight implementation of CommonJS Promises/A for PHP", "license": "MIT", "authors": [ {"name": "Jan Sorgalla", "email": "jsorgalla@gmail.com"} ], "require": { "php": ">=5.4.0" }, "autoload": { "psr-4": { "React\\Promise\\": "src/" }, "files": ["src/functions_include.php"] }, "autoload-dev": { "psr-4": { "React\\Promise\\": "tests/fixtures" } }, "extra": { "branch-alias": { "dev-master": "2.0-dev" } } } promise-2.4.1/phpunit.xml.dist000066400000000000000000000014021271216237400163510ustar00rootroot00000000000000 ./tests/ ./src/ ./src/functions_include.php promise-2.4.1/src/000077500000000000000000000000001271216237400137705ustar00rootroot00000000000000promise-2.4.1/src/CancellablePromiseInterface.php000066400000000000000000000002461271216237400220500ustar00rootroot00000000000000started) { return; } $this->started = true; $this->drain(); } public function enqueue($cancellable) { if (!method_exists($cancellable, 'then') || !method_exists($cancellable, 'cancel')) { return; } $length = array_push($this->queue, $cancellable); if ($this->started && 1 === $length) { $this->drain(); } } private function drain() { for ($i = key($this->queue); isset($this->queue[$i]); $i++) { $cancellable = $this->queue[$i]; $exception = null; try { $cancellable->cancel(); } catch (\Throwable $exception) { } catch (\Exception $exception) { } unset($this->queue[$i]); if ($exception) { throw $exception; } } $this->queue = []; } } promise-2.4.1/src/Deferred.php000066400000000000000000000024201271216237400162170ustar00rootroot00000000000000canceller = $canceller; } public function promise() { if (null === $this->promise) { $this->promise = new Promise(function ($resolve, $reject, $notify) { $this->resolveCallback = $resolve; $this->rejectCallback = $reject; $this->notifyCallback = $notify; }, $this->canceller); } return $this->promise; } public function resolve($value = null) { $this->promise(); call_user_func($this->resolveCallback, $value); } public function reject($reason = null) { $this->promise(); call_user_func($this->rejectCallback, $reason); } public function notify($update = null) { $this->promise(); call_user_func($this->notifyCallback, $update); } /** * @deprecated 2.2.0 * @see Deferred::notify() */ public function progress($update = null) { $this->notify($update); } } promise-2.4.1/src/Exception/000077500000000000000000000000001271216237400157265ustar00rootroot00000000000000promise-2.4.1/src/Exception/LengthException.php000066400000000000000000000001361271216237400215370ustar00rootroot00000000000000value = $value; } public function then(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { if (null === $onFulfilled) { return $this; } try { return resolve($onFulfilled($this->value)); } catch (\Throwable $exception) { return new RejectedPromise($exception); } catch (\Exception $exception) { return new RejectedPromise($exception); } } public function done(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { if (null === $onFulfilled) { return; } $result = $onFulfilled($this->value); if ($result instanceof ExtendedPromiseInterface) { $result->done(); } } public function otherwise(callable $onRejected) { return $this; } public function always(callable $onFulfilledOrRejected) { return $this->then(function ($value) use ($onFulfilledOrRejected) { return resolve($onFulfilledOrRejected())->then(function () use ($value) { return $value; }); }); } public function progress(callable $onProgress) { return $this; } public function cancel() { } } promise-2.4.1/src/LazyPromise.php000066400000000000000000000030711271216237400167600ustar00rootroot00000000000000factory = $factory; } public function then(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { return $this->promise()->then($onFulfilled, $onRejected, $onProgress); } public function done(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { return $this->promise()->done($onFulfilled, $onRejected, $onProgress); } public function otherwise(callable $onRejected) { return $this->promise()->otherwise($onRejected); } public function always(callable $onFulfilledOrRejected) { return $this->promise()->always($onFulfilledOrRejected); } public function progress(callable $onProgress) { return $this->promise()->progress($onProgress); } public function cancel() { return $this->promise()->cancel(); } private function promise() { if (null === $this->promise) { try { $this->promise = resolve(call_user_func($this->factory)); } catch (\Throwable $exception) { $this->promise = new RejectedPromise($exception); } catch (\Exception $exception) { $this->promise = new RejectedPromise($exception); } } return $this->promise; } } promise-2.4.1/src/Promise.php000066400000000000000000000127441271216237400161270ustar00rootroot00000000000000canceller = $canceller; $this->call($resolver); } public function then(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { if (null !== $this->result) { return $this->result()->then($onFulfilled, $onRejected, $onProgress); } if (null === $this->canceller) { return new static($this->resolver($onFulfilled, $onRejected, $onProgress)); } $this->requiredCancelRequests++; return new static($this->resolver($onFulfilled, $onRejected, $onProgress), function () { if (++$this->cancelRequests < $this->requiredCancelRequests) { return; } $this->cancel(); }); } public function done(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { if (null !== $this->result) { return $this->result()->done($onFulfilled, $onRejected, $onProgress); } $this->handlers[] = function (ExtendedPromiseInterface $promise) use ($onFulfilled, $onRejected) { $promise ->done($onFulfilled, $onRejected); }; if ($onProgress) { $this->progressHandlers[] = $onProgress; } } public function otherwise(callable $onRejected) { return $this->then(null, function ($reason) use ($onRejected) { if (!_checkTypehint($onRejected, $reason)) { return new RejectedPromise($reason); } return $onRejected($reason); }); } public function always(callable $onFulfilledOrRejected) { return $this->then(function ($value) use ($onFulfilledOrRejected) { return resolve($onFulfilledOrRejected())->then(function () use ($value) { return $value; }); }, function ($reason) use ($onFulfilledOrRejected) { return resolve($onFulfilledOrRejected())->then(function () use ($reason) { return new RejectedPromise($reason); }); }); } public function progress(callable $onProgress) { return $this->then(null, null, $onProgress); } public function cancel() { if (null === $this->canceller || null !== $this->result) { return; } $canceller = $this->canceller; $this->canceller = null; $this->call($canceller); } private function resolver(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { return function ($resolve, $reject, $notify) use ($onFulfilled, $onRejected, $onProgress) { if ($onProgress) { $progressHandler = function ($update) use ($notify, $onProgress) { try { $notify($onProgress($update)); } catch (\Throwable $e) { $notify($e); } catch (\Exception $e) { $notify($e); } }; } else { $progressHandler = $notify; } $this->handlers[] = function (ExtendedPromiseInterface $promise) use ($onFulfilled, $onRejected, $resolve, $reject, $progressHandler) { $promise ->then($onFulfilled, $onRejected) ->done($resolve, $reject, $progressHandler); }; $this->progressHandlers[] = $progressHandler; }; } private function resolve($value = null) { if (null !== $this->result) { return; } $this->settle(resolve($value)); } private function reject($reason = null) { if (null !== $this->result) { return; } $this->settle(reject($reason)); } private function notify($update = null) { if (null !== $this->result) { return; } foreach ($this->progressHandlers as $handler) { $handler($update); } } private function settle(ExtendedPromiseInterface $promise) { $handlers = $this->handlers; $this->progressHandlers = $this->handlers = []; $this->result = $promise; foreach ($handlers as $handler) { $handler($promise); } } private function result() { while ($this->result instanceof self && null !== $this->result->result) { $this->result = $this->result->result; } return $this->result; } private function call(callable $callback) { try { $callback( function ($value = null) { $this->resolve($value); }, function ($reason = null) { $this->reject($reason); }, function ($update = null) { $this->notify($update); } ); } catch (\Throwable $e) { $this->reject($e); } catch (\Exception $e) { $this->reject($e); } } } promise-2.4.1/src/PromiseInterface.php000066400000000000000000000003421271216237400177370ustar00rootroot00000000000000reason = $reason; } public function then(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { if (null === $onRejected) { return $this; } try { return resolve($onRejected($this->reason)); } catch (\Throwable $exception) { return new RejectedPromise($exception); } catch (\Exception $exception) { return new RejectedPromise($exception); } } public function done(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null) { if (null === $onRejected) { throw UnhandledRejectionException::resolve($this->reason); } $result = $onRejected($this->reason); if ($result instanceof self) { throw UnhandledRejectionException::resolve($result->reason); } if ($result instanceof ExtendedPromiseInterface) { $result->done(); } } public function otherwise(callable $onRejected) { if (!_checkTypehint($onRejected, $this->reason)) { return $this; } return $this->then(null, $onRejected); } public function always(callable $onFulfilledOrRejected) { return $this->then(null, function ($reason) use ($onFulfilledOrRejected) { return resolve($onFulfilledOrRejected())->then(function () use ($reason) { return new RejectedPromise($reason); }); }); } public function progress(callable $onProgress) { return $this; } public function cancel() { } } promise-2.4.1/src/UnhandledRejectionException.php000066400000000000000000000011431271216237400221240ustar00rootroot00000000000000reason = $reason; $message = sprintf('Unhandled Rejection: %s', json_encode($reason)); parent::__construct($message, 0); } public function getReason() { return $this->reason; } } promise-2.4.1/src/functions.php000066400000000000000000000207301271216237400165130ustar00rootroot00000000000000then($resolve, $reject, $notify); }, $canceller); } return new FulfilledPromise($promiseOrValue); } function reject($promiseOrValue = null) { if ($promiseOrValue instanceof PromiseInterface) { return resolve($promiseOrValue)->then(function ($value) { return new RejectedPromise($value); }); } return new RejectedPromise($promiseOrValue); } function all($promisesOrValues) { return map($promisesOrValues, function ($val) { return $val; }); } function race($promisesOrValues) { $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($promisesOrValues); return new Promise(function ($resolve, $reject, $notify) use ($promisesOrValues, $cancellationQueue) { resolve($promisesOrValues) ->done(function ($array) use ($cancellationQueue, $resolve, $reject, $notify) { if (!is_array($array) || !$array) { $resolve(); return; } $fulfiller = function ($value) use ($cancellationQueue, $resolve) { $cancellationQueue(); $resolve($value); }; $rejecter = function ($reason) use ($cancellationQueue, $reject) { $cancellationQueue(); $reject($reason); }; foreach ($array as $promiseOrValue) { $cancellationQueue->enqueue($promiseOrValue); resolve($promiseOrValue) ->done($fulfiller, $rejecter, $notify); } }, $reject, $notify); }, $cancellationQueue); } function any($promisesOrValues) { return some($promisesOrValues, 1) ->then(function ($val) { return array_shift($val); }); } function some($promisesOrValues, $howMany) { $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($promisesOrValues); return new Promise(function ($resolve, $reject, $notify) use ($promisesOrValues, $howMany, $cancellationQueue) { resolve($promisesOrValues) ->done(function ($array) use ($howMany, $cancellationQueue, $resolve, $reject, $notify) { if (!is_array($array) || $howMany < 1) { $resolve([]); return; } $len = count($array); if ($len < $howMany) { throw new Exception\LengthException( sprintf( 'Input array must contain at least %d item%s but contains only %s item%s.', $howMany, 1 === $howMany ? '' : 's', $len, 1 === $len ? '' : 's' ) ); } $toResolve = $howMany; $toReject = ($len - $toResolve) + 1; $values = []; $reasons = []; foreach ($array as $i => $promiseOrValue) { $fulfiller = function ($val) use ($i, &$values, &$toResolve, $toReject, $resolve, $cancellationQueue) { if ($toResolve < 1 || $toReject < 1) { return; } $values[$i] = $val; if (0 === --$toResolve) { $cancellationQueue(); $resolve($values); } }; $rejecter = function ($reason) use ($i, &$reasons, &$toReject, $toResolve, $reject, $cancellationQueue) { if ($toResolve < 1 || $toReject < 1) { return; } $reasons[$i] = $reason; if (0 === --$toReject) { $cancellationQueue(); $reject($reasons); } }; $cancellationQueue->enqueue($promiseOrValue); resolve($promiseOrValue) ->done($fulfiller, $rejecter, $notify); } }, $reject, $notify); }, $cancellationQueue); } function map($promisesOrValues, callable $mapFunc) { $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($promisesOrValues); return new Promise(function ($resolve, $reject, $notify) use ($promisesOrValues, $mapFunc, $cancellationQueue) { resolve($promisesOrValues) ->done(function ($array) use ($mapFunc, $cancellationQueue, $resolve, $reject, $notify) { if (!is_array($array) || !$array) { $resolve([]); return; } $toResolve = count($array); $values = []; foreach ($array as $i => $promiseOrValue) { $cancellationQueue->enqueue($promiseOrValue); resolve($promiseOrValue) ->then($mapFunc) ->done( function ($mapped) use ($i, &$values, &$toResolve, $resolve) { $values[$i] = $mapped; if (0 === --$toResolve) { $resolve($values); } }, $reject, $notify ); } }, $reject, $notify); }, $cancellationQueue); } function reduce($promisesOrValues, callable $reduceFunc, $initialValue = null) { $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($promisesOrValues); return new Promise(function ($resolve, $reject, $notify) use ($promisesOrValues, $reduceFunc, $initialValue, $cancellationQueue) { resolve($promisesOrValues) ->done(function ($array) use ($reduceFunc, $initialValue, $cancellationQueue, $resolve, $reject, $notify) { if (!is_array($array)) { $array = []; } $total = count($array); $i = 0; // Wrap the supplied $reduceFunc with one that handles promises and then // delegates to the supplied. $wrappedReduceFunc = function ($current, $val) use ($reduceFunc, $cancellationQueue, $total, &$i) { $cancellationQueue->enqueue($val); return $current ->then(function ($c) use ($reduceFunc, $total, &$i, $val) { return resolve($val) ->then(function ($value) use ($reduceFunc, $total, &$i, $c) { return $reduceFunc($c, $value, $i++, $total); }); }); }; $cancellationQueue->enqueue($initialValue); array_reduce($array, $wrappedReduceFunc, resolve($initialValue)) ->done($resolve, $reject, $notify); }, $reject, $notify); }, $cancellationQueue); } // Internal functions function _checkTypehint(callable $callback, $object) { if (!is_object($object)) { return true; } if (is_array($callback)) { $callbackReflection = new \ReflectionMethod($callback[0], $callback[1]); } elseif (is_object($callback) && !$callback instanceof \Closure) { $callbackReflection = new \ReflectionMethod($callback, '__invoke'); } else { $callbackReflection = new \ReflectionFunction($callback); } $parameters = $callbackReflection->getParameters(); if (!isset($parameters[0])) { return true; } $expectedException = $parameters[0]; if (!$expectedException->getClass()) { return true; } return $expectedException->getClass()->isInstance($object); } promise-2.4.1/src/functions_include.php000066400000000000000000000001401271216237400202070ustar00rootroot00000000000000enqueue($p); $cancellationQueue(); $this->assertTrue($p->cancelCalled); } /** @test */ public function ignoresSimpleCancellable() { $p = new SimpleTestCancellable(); $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($p); $cancellationQueue(); $this->assertFalse($p->cancelCalled); } /** @test */ public function callsCancelOnPromisesEnqueuedBeforeStart() { $d1 = $this->getCancellableDeferred(); $d2 = $this->getCancellableDeferred(); $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($d1->promise()); $cancellationQueue->enqueue($d2->promise()); $cancellationQueue(); } /** @test */ public function callsCancelOnPromisesEnqueuedAfterStart() { $d1 = $this->getCancellableDeferred(); $d2 = $this->getCancellableDeferred(); $cancellationQueue = new CancellationQueue(); $cancellationQueue(); $cancellationQueue->enqueue($d2->promise()); $cancellationQueue->enqueue($d1->promise()); } /** @test */ public function doesNotCallCancelTwiceWhenStartedTwice() { $d = $this->getCancellableDeferred(); $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($d->promise()); $cancellationQueue(); $cancellationQueue(); } /** @test */ public function rethrowsExceptionsThrownFromCancel() { $this->setExpectedException('\Exception', 'test'); $mock = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock ->expects($this->once()) ->method('cancel') ->will($this->throwException(new \Exception('test'))); $cancellationQueue = new CancellationQueue(); $cancellationQueue->enqueue($mock); $cancellationQueue(); } private function getCancellableDeferred() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke'); return new Deferred($mock); } } promise-2.4.1/tests/DeferredTest.php000066400000000000000000000020031271216237400174270ustar00rootroot00000000000000 [$d, 'promise'], 'resolve' => [$d, 'resolve'], 'reject' => [$d, 'reject'], 'notify' => [$d, 'progress'], 'settle' => [$d, 'resolve'], ]); } /** @test */ public function progressIsAnAliasForNotify() { $deferred = new Deferred(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($sentinel); $deferred->promise() ->then($this->expectCallableNever(), $this->expectCallableNever(), $mock); $deferred->progress($sentinel); } } promise-2.4.1/tests/FulfilledPromiseTest.php000066400000000000000000000027541271216237400211710ustar00rootroot00000000000000 function () use (&$promise) { if (!$promise) { throw new \LogicException('FulfilledPromise must be resolved before obtaining the promise'); } return $promise; }, 'resolve' => function ($value = null) use (&$promise) { if (!$promise) { $promise = new FulfilledPromise($value); } }, 'reject' => function () { throw new \LogicException('You cannot call reject() for React\Promise\FulfilledPromise'); }, 'notify' => function () { // no-op }, 'settle' => function ($value = null) use (&$promise) { if (!$promise) { $promise = new FulfilledPromise($value); } }, ]); } /** @test */ public function shouldThrowExceptionIfConstructedWithAPromise() { $this->setExpectedException('\InvalidArgumentException'); return new FulfilledPromise(new FulfilledPromise()); } } promise-2.4.1/tests/FunctionAllTest.php000066400000000000000000000045151271216237400201370ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([])); all([]) ->then($mock); } /** @test */ public function shouldResolveValuesArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2, 3])); all([1, 2, 3]) ->then($mock); } /** @test */ public function shouldResolvePromisesArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2, 3])); all([resolve(1), resolve(2), resolve(3)]) ->then($mock); } /** @test */ public function shouldResolveSparseArrayInput() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([null, 1, null, 1, 1])); all([null, 1, null, 1, 1]) ->then($mock); } /** @test */ public function shouldRejectIfAnyInputPromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); all([resolve(1), reject(2), resolve(3)]) ->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldAcceptAPromiseForAnArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2, 3])); all(resolve([1, 2, 3])) ->then($mock); } /** @test */ public function shouldResolveToEmptyArrayWhenInputPromiseDoesNotResolveToArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([])); all(resolve(1)) ->then($mock); } } promise-2.4.1/tests/FunctionAnyTest.php000066400000000000000000000121041271216237400201470ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with( $this->callback(function($exception){ return $exception instanceof LengthException && 'Input array must contain at least 1 item but contains only 0 items.' === $exception->getMessage(); }) ); any([]) ->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldResolveToNullWithNonArrayInput() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); any(null) ->then($mock); } /** @test */ public function shouldResolveWithAnInputValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); any([1, 2, 3]) ->then($mock); } /** @test */ public function shouldResolveWithAPromisedInputValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); any([resolve(1), resolve(2), resolve(3)]) ->then($mock); } /** @test */ public function shouldRejectWithAllRejectedInputValuesIfAllInputsAreRejected() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([0 => 1, 1 => 2, 2 => 3])); any([reject(1), reject(2), reject(3)]) ->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldResolveWhenFirstInputPromiseResolves() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); any([resolve(1), reject(2), reject(3)]) ->then($mock); } /** @test */ public function shouldAcceptAPromiseForAnArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); any(resolve([1, 2, 3])) ->then($mock); } /** @test */ public function shouldResolveToNullArrayWhenInputPromiseDoesNotResolveToArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); any(resolve(1)) ->then($mock); } /** @test */ public function shouldNotRelyOnArryIndexesWhenUnwrappingToASingleResolutionValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $d1 = new Deferred(); $d2 = new Deferred(); any(['abc' => $d1->promise(), 1 => $d2->promise()]) ->then($mock); $d2->resolve(2); $d1->resolve(1); } /** @test */ public function shouldRejectWhenInputPromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); any(reject()) ->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldCancelInputPromise() { $mock = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock ->expects($this->once()) ->method('cancel'); any($mock)->cancel(); } /** @test */ public function shouldCancelInputArrayPromises() { $mock1 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock1 ->expects($this->once()) ->method('cancel'); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); any([$mock1, $mock2])->cancel(); } /** @test */ public function shouldCancelOtherPendingInputArrayPromisesIfOnePromiseFulfills() { $mock = $this->createCallableMock(); $mock ->expects($this->never()) ->method('__invoke'); $deferred = New Deferred($mock); $deferred->resolve(); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); some([$deferred->promise(), $mock2], 1)->cancel(); } } promise-2.4.1/tests/FunctionCheckTypehintTest.php000066400000000000000000000067141271216237400221740ustar00rootroot00000000000000assertTrue(_checkTypehint(function (\InvalidArgumentException $e) { }, new \InvalidArgumentException())); $this->assertfalse(_checkTypehint(function (\InvalidArgumentException $e) { }, new \Exception())); } /** @test */ public function shouldAcceptFunctionStringCallbackWithTypehint() { $this->assertTrue(_checkTypehint('React\Promise\testCallbackWithTypehint', new \InvalidArgumentException())); $this->assertfalse(_checkTypehint('React\Promise\testCallbackWithTypehint', new \Exception())); } /** @test */ public function shouldAcceptInvokableObjectCallbackWithTypehint() { $this->assertTrue(_checkTypehint(new TestCallbackWithTypehintClass(), new \InvalidArgumentException())); $this->assertfalse(_checkTypehint(new TestCallbackWithTypehintClass(), new \Exception())); } /** @test */ public function shouldAcceptObjectMethodCallbackWithTypehint() { $this->assertTrue(_checkTypehint([new TestCallbackWithTypehintClass(), 'testCallback'], new \InvalidArgumentException())); $this->assertfalse(_checkTypehint([new TestCallbackWithTypehintClass(), 'testCallback'], new \Exception())); } /** @test */ public function shouldAcceptStaticClassCallbackWithTypehint() { $this->assertTrue(_checkTypehint(['React\Promise\TestCallbackWithTypehintClass', 'testCallbackStatic'], new \InvalidArgumentException())); $this->assertfalse(_checkTypehint(['React\Promise\TestCallbackWithTypehintClass', 'testCallbackStatic'], new \Exception())); } /** @test */ public function shouldAcceptClosureCallbackWithoutTypehint() { $this->assertTrue(_checkTypehint(function (\InvalidArgumentException $e) { }, new \InvalidArgumentException())); } /** @test */ public function shouldAcceptFunctionStringCallbackWithoutTypehint() { $this->assertTrue(_checkTypehint('React\Promise\testCallbackWithoutTypehint', new \InvalidArgumentException())); } /** @test */ public function shouldAcceptInvokableObjectCallbackWithoutTypehint() { $this->assertTrue(_checkTypehint(new TestCallbackWithoutTypehintClass(), new \InvalidArgumentException())); } /** @test */ public function shouldAcceptObjectMethodCallbackWithoutTypehint() { $this->assertTrue(_checkTypehint([new TestCallbackWithoutTypehintClass(), 'testCallback'], new \InvalidArgumentException())); } /** @test */ public function shouldAcceptStaticClassCallbackWithoutTypehint() { $this->assertTrue(_checkTypehint(['React\Promise\TestCallbackWithoutTypehintClass', 'testCallbackStatic'], new \InvalidArgumentException())); } } function testCallbackWithTypehint(\InvalidArgumentException $e) { } function testCallbackWithoutTypehint() { } class TestCallbackWithTypehintClass { public function __invoke(\InvalidArgumentException $e) { } public function testCallback(\InvalidArgumentException $e) { } public static function testCallbackStatic(\InvalidArgumentException $e) { } } class TestCallbackWithoutTypehintClass { public function __invoke() { } public function testCallback() { } public static function testCallbackStatic() { } } promise-2.4.1/tests/FunctionMapTest.php000066400000000000000000000100421271216237400201340ustar00rootroot00000000000000createCallableMock(); $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 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->getMock('React\Promise\CancellablePromiseInterface'); $mock ->expects($this->once()) ->method('cancel'); map( $mock, $this->mapper() )->cancel(); } /** @test */ public function shouldCancelInputArrayPromises() { $mock1 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock1 ->expects($this->once()) ->method('cancel'); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); map( [$mock1, $mock2], $this->mapper() )->cancel(); } } promise-2.4.1/tests/FunctionRaceTest.php000066400000000000000000000114701271216237400202770ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); race( [] )->then($mock); } /** @test */ public function shouldResolveValuesArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); race( [1, 2, 3] )->then($mock); } /** @test */ public function shouldResolvePromisesArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $d1 = new Deferred(); $d2 = new Deferred(); $d3 = new Deferred(); race( [$d1->promise(), $d2->promise(), $d3->promise()] )->then($mock); $d2->resolve(2); $d1->resolve(1); $d3->resolve(3); } /** @test */ public function shouldResolveSparseArrayInput() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); race( [null, 1, null, 2, 3] )->then($mock); } /** @test */ public function shouldRejectIfFirstSettledPromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $d1 = new Deferred(); $d2 = new Deferred(); $d3 = new Deferred(); race( [$d1->promise(), $d2->promise(), $d3->promise()] )->then($this->expectCallableNever(), $mock); $d2->reject(2); $d1->resolve(1); $d3->resolve(3); } /** @test */ public function shouldAcceptAPromiseForAnArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); race( resolve([1, 2, 3]) )->then($mock); } /** @test */ public function shouldResolveToNullWhenInputPromiseDoesNotResolveToArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); race( resolve(1) )->then($mock); } /** @test */ public function shouldRejectWhenInputPromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); race( reject() )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldCancelInputPromise() { $mock = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock ->expects($this->once()) ->method('cancel'); race($mock)->cancel(); } /** @test */ public function shouldCancelInputArrayPromises() { $mock1 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock1 ->expects($this->once()) ->method('cancel'); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); race([$mock1, $mock2])->cancel(); } /** @test */ public function shouldCancelOtherPendingInputArrayPromisesIfOnePromiseFulfills() { $mock = $this->createCallableMock(); $mock ->expects($this->never()) ->method('__invoke'); $deferred = New Deferred($mock); $deferred->resolve(); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); race([$deferred->promise(), $mock2])->cancel(); } /** @test */ public function shouldCancelOtherPendingInputArrayPromisesIfOnePromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->never()) ->method('__invoke'); $deferred = New Deferred($mock); $deferred->reject(); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); race([$deferred->promise(), $mock2])->cancel(); } } promise-2.4.1/tests/FunctionReduceTest.php000066400000000000000000000201301271216237400206250ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(6)); reduce( [1, 2, 3], $this->plus() )->then($mock); } /** @test */ public function shouldReduceValuesWithInitialValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(7)); reduce( [1, 2, 3], $this->plus(), 1 )->then($mock); } /** @test */ public function shouldReduceValuesWithInitialPromise() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(7)); reduce( [1, 2, 3], $this->plus(), resolve(1) )->then($mock); } /** @test */ public function shouldReducePromisedValuesWithoutInitialValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(6)); reduce( [resolve(1), resolve(2), resolve(3)], $this->plus() )->then($mock); } /** @test */ public function shouldReducePromisedValuesWithInitialValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(7)); reduce( [resolve(1), resolve(2), resolve(3)], $this->plus(), 1 )->then($mock); } /** @test */ public function shouldReducePromisedValuesWithInitialPromise() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(7)); reduce( [resolve(1), resolve(2), resolve(3)], $this->plus(), resolve(1) )->then($mock); } /** @test */ public function shouldReduceEmptyInputWithInitialValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); reduce( [], $this->plus(), 1 )->then($mock); } /** @test */ public function shouldReduceEmptyInputWithInitialPromise() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); reduce( [], $this->plus(), resolve(1) )->then($mock); } /** @test */ public function shouldRejectWhenInputContainsRejection() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); reduce( [resolve(1), reject(2), resolve(3)], $this->plus(), resolve(1) )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldResolveWithNullWhenInputIsEmptyAndNoInitialValueOrPromiseProvided() { // Note: this is different from when.js's behavior! // In when.reduce(), this rejects with a TypeError exception (following // JavaScript's [].reduce behavior. // We're following PHP's array_reduce behavior and resolve with NULL. $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); reduce( [], $this->plus() )->then($mock); } /** @test */ public function shouldAllowSparseArrayInputWithoutInitialValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(3)); reduce( [null, null, 1, null, 1, 1], $this->plus() )->then($mock); } /** @test */ public function shouldAllowSparseArrayInputWithInitialValue() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(4)); reduce( [null, null, 1, null, 1, 1], $this->plus(), 1 )->then($mock); } /** @test */ public function shouldReduceInInputOrder() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo('123')); reduce( [1, 2, 3], $this->append(), '' )->then($mock); } /** @test */ public function shouldAcceptAPromiseForAnArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo('123')); reduce( resolve([1, 2, 3]), $this->append(), '' )->then($mock); } /** @test */ public function shouldResolveToInitialValueWhenInputPromiseDoesNotResolveToAnArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); reduce( resolve(1), $this->plus(), 1 )->then($mock); } /** @test */ public function shouldProvideCorrectBasisValue() { $insertIntoArray = function ($arr, $val, $i) { $arr[$i] = $val; return $arr; }; $d1 = new Deferred(); $d2 = new Deferred(); $d3 = new Deferred(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2, 3])); reduce( [$d1->promise(), $d2->promise(), $d3->promise()], $insertIntoArray, [] )->then($mock); $d3->resolve(3); $d1->resolve(1); $d2->resolve(2); } /** @test */ public function shouldRejectWhenInputPromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); reduce( reject(), $this->plus(), 1 )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldCancelInputPromise() { $mock = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock ->expects($this->once()) ->method('cancel'); reduce( $mock, $this->plus(), 1 )->cancel(); } /** @test */ public function shouldCancelInputArrayPromises() { $mock1 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock1 ->expects($this->once()) ->method('cancel'); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); reduce( [$mock1, $mock2], $this->plus(), 1 )->cancel(); } } promise-2.4.1/tests/FunctionRejectTest.php000066400000000000000000000026351271216237400206440ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($expected)); reject($expected) ->then( $this->expectCallableNever(), $mock ); } /** @test */ public function shouldRejectAFulfilledPromise() { $expected = 123; $resolved = new FulfilledPromise($expected); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($expected)); reject($resolved) ->then( $this->expectCallableNever(), $mock ); } /** @test */ public function shouldRejectARejectedPromise() { $expected = 123; $resolved = new RejectedPromise($expected); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($expected)); reject($resolved) ->then( $this->expectCallableNever(), $mock ); } } promise-2.4.1/tests/FunctionResolveTest.php000066400000000000000000000077701271216237400210540ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($expected)); resolve($expected) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function shouldResolveAFulfilledPromise() { $expected = 123; $resolved = new FulfilledPromise($expected); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($expected)); resolve($resolved) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function shouldResolveAThenable() { $thenable = new SimpleFulfilledTestThenable(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo('foo')); resolve($thenable) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function shouldResolveACancellableThenable() { $thenable = new SimpleTestCancellableThenable(); $promise = resolve($thenable); $promise->cancel(); $this->assertTrue($thenable->cancelCalled); } /** @test */ public function shouldRejectARejectedPromise() { $expected = 123; $resolved = new RejectedPromise($expected); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($expected)); resolve($resolved) ->then( $this->expectCallableNever(), $mock ); } /** @test */ public function shouldSupportDeepNestingInPromiseChains() { $d = new Deferred(); $d->resolve(false); $result = resolve(resolve($d->promise()->then(function ($val) { $d = new Deferred(); $d->resolve($val); $identity = function ($val) { return $val; }; return resolve($d->promise()->then($identity))->then( function ($val) { return !$val; } ); }))); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(true)); $result->then($mock); } /** @test */ public function shouldSupportVeryDeepNestedPromises() { $deferreds = []; // @TODO Increase count once global-queue is merged for ($i = 0; $i < 10; $i++) { $deferreds[] = $d = new Deferred(); $p = $d->promise(); $last = $p; for ($j = 0; $j < 10; $j++) { $last = $last->then(function($result) { return $result; }); } } $p = null; foreach ($deferreds as $d) { if ($p) { $d->resolve($p); } $p = $d->promise(); } $deferreds[0]->resolve(true); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(true)); $deferreds[0]->promise()->then($mock); } /** @test */ public function returnsExtendePromiseForSimplePromise() { $promise = $this->getMock('React\Promise\PromiseInterface'); $this->assertInstanceOf('React\Promise\ExtendedPromiseInterface', resolve($promise)); } } promise-2.4.1/tests/FunctionSomeTest.php000066400000000000000000000144671271216237400203410ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with( $this->callback(function($exception){ return $exception instanceof LengthException && 'Input array must contain at least 1 item but contains only 0 items.' === $exception->getMessage(); }) ); some( [], 1 )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldRejectWithLengthExceptionWithInputArrayContainingNotEnoughItems() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with( $this->callback(function($exception){ return $exception instanceof LengthException && 'Input array must contain at least 4 items but contains only 3 items.' === $exception->getMessage(); }) ); some( [1, 2, 3], 4 )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldResolveToEmptyArrayWithNonArrayInput() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([])); some( null, 1 )->then($mock); } /** @test */ public function shouldResolveValuesArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2])); some( [1, 2, 3], 2 )->then($mock); } /** @test */ public function shouldResolvePromisesArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2])); some( [resolve(1), resolve(2), resolve(3)], 2 )->then($mock); } /** @test */ public function shouldResolveSparseArrayInput() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([null, 1])); some( [null, 1, null, 2, 3], 2 )->then($mock); } /** @test */ public function shouldRejectIfAnyInputPromiseRejectsBeforeDesiredNumberOfInputsAreResolved() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1 => 2, 2 => 3])); some( [resolve(1), reject(2), reject(3)], 2 )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldAcceptAPromiseForAnArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([1, 2])); some( resolve([1, 2, 3]), 2 )->then($mock); } /** @test */ public function shouldResolveWithEmptyArrayIfHowManyIsLessThanOne() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([])); some( [1], 0 )->then($mock); } /** @test */ public function shouldResolveToEmptyArrayWhenInputPromiseDoesNotResolveToArray() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo([])); some( resolve(1), 1 )->then($mock); } /** @test */ public function shouldRejectWhenInputPromiseRejects() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(null)); some( reject(), 1 )->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldCancelInputPromise() { $mock = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock ->expects($this->once()) ->method('cancel'); some($mock, 1)->cancel(); } /** @test */ public function shouldCancelInputArrayPromises() { $mock1 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock1 ->expects($this->once()) ->method('cancel'); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); some([$mock1, $mock2], 1)->cancel(); } /** @test */ public function shouldCancelOtherPendingInputArrayPromisesIfEnoughPromisesFulfill() { $mock = $this->createCallableMock(); $mock ->expects($this->never()) ->method('__invoke'); $deferred = New Deferred($mock); $deferred->resolve(); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); some([$deferred->promise(), $mock2], 1); } /** @test */ public function shouldCancelOtherPendingInputArrayPromisesIfEnoughPromisesReject() { $mock = $this->createCallableMock(); $mock ->expects($this->never()) ->method('__invoke'); $deferred = New Deferred($mock); $deferred->reject(); $mock2 = $this->getMock('React\Promise\CancellablePromiseInterface'); $mock2 ->expects($this->once()) ->method('cancel'); some([$deferred->promise(), $mock2], 2); } } promise-2.4.1/tests/LazyPromiseTest.php000066400000000000000000000054301271216237400201740ustar00rootroot00000000000000promise(); }; return new CallbackPromiseAdapter([ 'promise' => function () use ($factory) { return new LazyPromise($factory); }, 'resolve' => [$d, 'resolve'], 'reject' => [$d, 'reject'], 'notify' => [$d, 'progress'], 'settle' => [$d, 'resolve'], ]); } /** @test */ public function shouldNotCallFactoryIfThenIsNotInvoked() { $factory = $this->createCallableMock(); $factory ->expects($this->never()) ->method('__invoke'); new LazyPromise($factory); } /** @test */ public function shouldCallFactoryIfThenIsInvoked() { $factory = $this->createCallableMock(); $factory ->expects($this->once()) ->method('__invoke'); $p = new LazyPromise($factory); $p->then(); } /** @test */ public function shouldReturnPromiseFromFactory() { $factory = $this->createCallableMock(); $factory ->expects($this->once()) ->method('__invoke') ->will($this->returnValue(new FulfilledPromise(1))); $onFulfilled = $this->createCallableMock(); $onFulfilled ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $p = new LazyPromise($factory); $p->then($onFulfilled); } /** @test */ public function shouldReturnPromiseIfFactoryReturnsNull() { $factory = $this->createCallableMock(); $factory ->expects($this->once()) ->method('__invoke') ->will($this->returnValue(null)); $p = new LazyPromise($factory); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $p->then()); } /** @test */ public function shouldReturnRejectedPromiseIfFactoryThrowsException() { $exception = new \Exception(); $factory = $this->createCallableMock(); $factory ->expects($this->once()) ->method('__invoke') ->will($this->throwException($exception)); $onRejected = $this->createCallableMock(); $onRejected ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $p = new LazyPromise($factory); $p->then($this->expectCallableNever(), $onRejected); } } promise-2.4.1/tests/PromiseAdapter/000077500000000000000000000000001271216237400172625ustar00rootroot00000000000000promise-2.4.1/tests/PromiseAdapter/CallbackPromiseAdapter.php000066400000000000000000000015661271216237400243370ustar00rootroot00000000000000callbacks = $callbacks; } public function promise() { return call_user_func_array($this->callbacks['promise'], func_get_args()); } public function resolve() { return call_user_func_array($this->callbacks['resolve'], func_get_args()); } public function reject() { return call_user_func_array($this->callbacks['reject'], func_get_args()); } public function notify() { return call_user_func_array($this->callbacks['notify'], func_get_args()); } public function settle() { return call_user_func_array($this->callbacks['settle'], func_get_args()); } } promise-2.4.1/tests/PromiseAdapter/PromiseAdapterInterface.php000066400000000000000000000004021271216237400245270ustar00rootroot00000000000000 function () use ($promise) { return $promise; }, 'resolve' => $resolveCallback, 'reject' => $rejectCallback, 'notify' => $progressCallback, 'settle' => $resolveCallback, ]); } /** @test */ public function shouldRejectIfResolverThrowsException() { $exception = new \Exception('foo'); $promise = new Promise(function () use ($exception) { throw $exception; }); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $promise ->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldFulfillIfFullfilledWithSimplePromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo('foo')); $adapter->promise() ->then($mock); $adapter->resolve(new SimpleFulfilledTestPromise()); } /** @test */ public function shouldRejectIfRejectedWithSimplePromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo('foo')); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->resolve(new SimpleRejectedTestPromise()); } } promise-2.4.1/tests/PromiseTest/000077500000000000000000000000001271216237400166215ustar00rootroot00000000000000promise-2.4.1/tests/PromiseTest/CancelTestTrait.php000066400000000000000000000137131271216237400223700ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->isType('callable'), $this->isType('callable'), $this->isType('callable')); $adapter = $this->getPromiseTestAdapter($mock); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldFulfillPromiseIfCancellerFulfills() { $adapter = $this->getPromiseTestAdapter(function ($resolve) { $resolve(1); }); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($mock, $this->expectCallableNever()); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldRejectPromiseIfCancellerRejects() { $adapter = $this->getPromiseTestAdapter(function ($resolve, $reject) { $reject(1); }); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldRejectPromiseWithExceptionIfCancellerThrows() { $e = new \Exception(); $adapter = $this->getPromiseTestAdapter(function () use ($e) { throw $e; }); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($e)); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldProgressPromiseIfCancellerNotifies() { $adapter = $this->getPromiseTestAdapter(function ($resolve, $reject, $progress) { $progress(1); }); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $this->expectCallableNever(), $mock); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldCallCancellerOnlyOnceIfCancellerResolves() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->returnCallback(function ($resolve) { $resolve(); })); $adapter = $this->getPromiseTestAdapter($mock); $adapter->promise()->cancel(); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldHaveNoEffectIfCancellerDoesNothing() { $adapter = $this->getPromiseTestAdapter(function () {}); $adapter->promise() ->then($this->expectCallableNever(), $this->expectCallableNever()); $adapter->promise()->cancel(); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldCallCancellerFromDeepNestedPromiseChain() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke'); $adapter = $this->getPromiseTestAdapter($mock); $promise = $adapter->promise() ->then(function () { return new Promise\Promise(function () {}); }) ->then(function () { $d = new Promise\Deferred(); return $d->promise(); }) ->then(function () { return new Promise\Promise(function () {}); }); $promise->cancel(); } /** @test */ public function cancelCalledOnChildrenSouldOnlyCancelWhenAllChildrenCancelled() { $adapter = $this->getPromiseTestAdapter($this->expectCallableNever()); $child1 = $adapter->promise() ->then() ->then(); $adapter->promise() ->then(); $child1->cancel(); } /** @test */ public function cancelShouldTriggerCancellerWhenAllChildrenCancel() { $adapter = $this->getPromiseTestAdapter($this->expectCallableOnce()); $child1 = $adapter->promise() ->then() ->then(); $child2 = $adapter->promise() ->then(); $child1->cancel(); $child2->cancel(); } /** @test */ public function cancelShouldNotTriggerCancellerWhenCancellingOneChildrenMultipleTimes() { $adapter = $this->getPromiseTestAdapter($this->expectCallableNever()); $child1 = $adapter->promise() ->then() ->then(); $child2 = $adapter->promise() ->then(); $child1->cancel(); $child1->cancel(); } /** @test */ public function cancelShouldTriggerCancellerOnlyOnceWhenCancellingMultipleTimes() { $adapter = $this->getPromiseTestAdapter($this->expectCallableOnce()); $adapter->promise()->cancel(); $adapter->promise()->cancel(); } /** @test */ public function cancelShouldAlwaysTriggerCancellerWhenCalledOnRootPromise() { $adapter = $this->getPromiseTestAdapter($this->expectCallableOnce()); $adapter->promise() ->then() ->then(); $adapter->promise() ->then(); $adapter->promise()->cancel(); } } promise-2.4.1/tests/PromiseTest/FullTestTrait.php000066400000000000000000000004611271216237400221010ustar00rootroot00000000000000getPromiseTestAdapter(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($sentinel); $adapter->promise() ->then($this->expectCallableNever(), $this->expectCallableNever(), $mock); $adapter->notify($sentinel); } /** @test */ public function notifyShouldPropagateProgressToDownstreamPromises() { $adapter = $this->getPromiseTestAdapter(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->returnArgument(0)); $mock2 = $this->createCallableMock(); $mock2 ->expects($this->once()) ->method('__invoke') ->with($sentinel); $adapter->promise() ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock ) ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock2 ); $adapter->notify($sentinel); } /** @test */ public function notifyShouldPropagateTransformedProgressToDownstreamPromises() { $adapter = $this->getPromiseTestAdapter(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->returnValue($sentinel)); $mock2 = $this->createCallableMock(); $mock2 ->expects($this->once()) ->method('__invoke') ->with($sentinel); $adapter->promise() ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock ) ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock2 ); $adapter->notify(1); } /** @test */ public function notifyShouldPropagateCaughtExceptionValueAsProgress() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->throwException($exception)); $mock2 = $this->createCallableMock(); $mock2 ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock ) ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock2 ); $adapter->notify(1); } /** @test */ public function notifyShouldForwardProgressEventsWhenIntermediaryCallbackTiedToAResolvedPromiseReturnsAPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter2 = $this->getPromiseTestAdapter(); $promise2 = $adapter2->promise(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($sentinel); // resolve BEFORE attaching progress handler $adapter->resolve(); $adapter->promise() ->then(function () use ($promise2) { return $promise2; }) ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock ); $adapter2->notify($sentinel); } /** @test */ public function notifyShouldForwardProgressEventsWhenIntermediaryCallbackTiedToAnUnresolvedPromiseReturnsAPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter2 = $this->getPromiseTestAdapter(); $promise2 = $adapter2->promise(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($sentinel); $adapter->promise() ->then(function () use ($promise2) { return $promise2; }) ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock ); // resolve AFTER attaching progress handler $adapter->resolve(); $adapter2->notify($sentinel); } /** @test */ public function notifyShouldForwardProgressWhenResolvedWithAnotherPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter2 = $this->getPromiseTestAdapter(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->returnValue($sentinel)); $mock2 = $this->createCallableMock(); $mock2 ->expects($this->once()) ->method('__invoke') ->with($sentinel); $adapter->promise() ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock ) ->then( $this->expectCallableNever(), $this->expectCallableNever(), $mock2 ); $adapter->resolve($adapter2->promise()); $adapter2->notify($sentinel); } /** @test */ public function notifyShouldAllowResolveAfterProgress() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->at(0)) ->method('__invoke') ->with($this->identicalTo(1)); $mock ->expects($this->at(1)) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->promise() ->then( $mock, $this->expectCallableNever(), $mock ); $adapter->notify(1); $adapter->resolve(2); } /** @test */ public function notifyShouldAllowRejectAfterProgress() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->at(0)) ->method('__invoke') ->with($this->identicalTo(1)); $mock ->expects($this->at(1)) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->promise() ->then( $this->expectCallableNever(), $mock, $mock ); $adapter->notify(1); $adapter->reject(2); } /** @test */ public function notifyShouldReturnSilentlyOnProgressWhenAlreadyRejected() { $adapter = $this->getPromiseTestAdapter(); $adapter->reject(1); $this->assertNull($adapter->notify()); } /** @test */ public function notifyShouldInvokeProgressHandler() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise()->progress($mock); $adapter->notify(1); } /** @test */ public function notifyShouldInvokeProgressHandlerFromDone() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $this->assertNull($adapter->promise()->done(null, null, $mock)); $adapter->notify(1); } /** @test */ public function notifyShouldThrowExceptionThrownProgressHandlerFromDone() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $this->assertNull($adapter->promise()->done(null, null, function () { throw new \Exception('UnhandledRejectionException'); })); $adapter->notify(1); } } promise-2.4.1/tests/PromiseTest/PromiseFulfilledTestTrait.php000066400000000000000000000224061271216237400244470ustar00rootroot00000000000000getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->resolve(1); $adapter->resolve(2); $adapter->promise() ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function fulfilledPromiseShouldInvokeNewlyAddedCallback() { $adapter = $this->getPromiseTestAdapter(); $adapter->resolve(1); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($mock, $this->expectCallableNever()); } /** @test */ public function thenShouldForwardResultWhenCallbackIsNull() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->resolve(1); $adapter->promise() ->then( null, $this->expectCallableNever() ) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function thenShouldForwardCallbackResultToNextCallback() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->resolve(1); $adapter->promise() ->then( function ($val) { return $val + 1; }, $this->expectCallableNever() ) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function thenShouldForwardPromisedCallbackResultValueToNextCallback() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->resolve(1); $adapter->promise() ->then( function ($val) { return \React\Promise\resolve($val + 1); }, $this->expectCallableNever() ) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function thenShouldSwitchFromCallbacksToErrbacksWhenCallbackReturnsARejection() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->resolve(1); $adapter->promise() ->then( function ($val) { return \React\Promise\reject($val + 1); }, $this->expectCallableNever() ) ->then( $this->expectCallableNever(), $mock ); } /** @test */ public function thenShouldSwitchFromCallbacksToErrbacksWhenCallbackThrows() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->throwException($exception)); $mock2 = $this->createCallableMock(); $mock2 ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->resolve(1); $adapter->promise() ->then( $mock, $this->expectCallableNever() ) ->then( $this->expectCallableNever(), $mock2 ); } /** @test */ public function cancelShouldReturnNullForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->resolve(); $this->assertNull($adapter->promise()->cancel()); } /** @test */ public function cancelShouldHaveNoEffectForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter($this->expectCallableNever()); $adapter->resolve(); $adapter->promise()->cancel(); } /** @test */ public function doneShouldInvokeFulfillmentHandlerForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->resolve(1); $this->assertNull($adapter->promise()->done($mock)); } /** @test */ public function doneShouldThrowExceptionThrownFulfillmentHandlerForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $adapter->resolve(1); $this->assertNull($adapter->promise()->done(function () { throw new \Exception('UnhandledRejectionException'); })); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenFulfillmentHandlerRejectsForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $adapter->resolve(1); $this->assertNull($adapter->promise()->done(function () { return \React\Promise\reject(); })); } /** @test */ public function otherwiseShouldNotInvokeRejectionHandlerForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->resolve(1); $adapter->promise()->otherwise($this->expectCallableNever()); } /** @test */ public function alwaysShouldNotSuppressValueForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $value = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($value)); $adapter->resolve($value); $adapter->promise() ->always(function () {}) ->then($mock); } /** @test */ public function alwaysShouldNotSuppressValueWhenHandlerReturnsANonPromiseForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $value = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($value)); $adapter->resolve($value); $adapter->promise() ->always(function () { return 1; }) ->then($mock); } /** @test */ public function alwaysShouldNotSuppressValueWhenHandlerReturnsAPromiseForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $value = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($value)); $adapter->resolve($value); $adapter->promise() ->always(function () { return \React\Promise\resolve(1); }) ->then($mock); } /** @test */ public function alwaysShouldRejectWhenHandlerThrowsForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->resolve(1); $adapter->promise() ->always(function () use ($exception) { throw $exception; }) ->then(null, $mock); } /** @test */ public function alwaysShouldRejectWhenHandlerRejectsForFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->resolve(1); $adapter->promise() ->always(function () use ($exception) { return \React\Promise\reject($exception); }) ->then(null, $mock); } } promise-2.4.1/tests/PromiseTest/PromisePendingTestTrait.php000066400000000000000000000035421271216237400241250ustar00rootroot00000000000000getPromiseTestAdapter(); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $adapter->promise()->then()); } /** @test */ public function thenShouldReturnAllowNullForPendingPromise() { $adapter = $this->getPromiseTestAdapter(); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $adapter->promise()->then(null, null, null)); } /** @test */ public function cancelShouldReturnNullForPendingPromise() { $adapter = $this->getPromiseTestAdapter(); $this->assertNull($adapter->promise()->cancel()); } /** @test */ public function doneShouldReturnNullForPendingPromise() { $adapter = $this->getPromiseTestAdapter(); $this->assertNull($adapter->promise()->done()); } /** @test */ public function doneShouldReturnAllowNullForPendingPromise() { $adapter = $this->getPromiseTestAdapter(); $this->assertNull($adapter->promise()->done(null, null, null)); } /** @test */ public function otherwiseShouldNotInvokeRejectionHandlerForPendingPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $adapter->promise()->otherwise($this->expectCallableNever()); } /** @test */ public function alwaysShouldReturnAPromiseForPendingPromise() { $adapter = $this->getPromiseTestAdapter(); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $adapter->promise()->always(function () {})); } } promise-2.4.1/tests/PromiseTest/PromiseRejectedTestTrait.php000066400000000000000000000344101271216237400242640ustar00rootroot00000000000000getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->reject(1); $adapter->reject(2); $adapter->promise() ->then( $this->expectCallableNever(), $mock ); } /** @test */ public function rejectedPromiseShouldInvokeNewlyAddedCallback() { $adapter = $this->getPromiseTestAdapter(); $adapter->reject(1); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $mock); } /** @test */ public function shouldForwardUndefinedRejectionValue() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with(null); $adapter->reject(1); $adapter->promise() ->then( $this->expectCallableNever(), function () { // Presence of rejection handler is enough to switch back // to resolve mode, even though it returns undefined. // The ONLY way to propagate a rejection is to re-throw or // return a rejected promise; } ) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function shouldSwitchFromErrbacksToCallbacksWhenErrbackDoesNotExplicitlyPropagate() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->reject(1); $adapter->promise() ->then( $this->expectCallableNever(), function ($val) { return $val + 1; } ) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function shouldSwitchFromErrbacksToCallbacksWhenErrbackReturnsAResolution() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->reject(1); $adapter->promise() ->then( $this->expectCallableNever(), function ($val) { return \React\Promise\resolve($val + 1); } ) ->then( $mock, $this->expectCallableNever() ); } /** @test */ public function shouldPropagateRejectionsWhenErrbackThrows() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->will($this->throwException($exception)); $mock2 = $this->createCallableMock(); $mock2 ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->reject(1); $adapter->promise() ->then( $this->expectCallableNever(), $mock ) ->then( $this->expectCallableNever(), $mock2 ); } /** @test */ public function shouldPropagateRejectionsWhenErrbackReturnsARejection() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(2)); $adapter->reject(1); $adapter->promise() ->then( $this->expectCallableNever(), function ($val) { return \React\Promise\reject($val + 1); } ) ->then( $this->expectCallableNever(), $mock ); } /** @test */ public function doneShouldInvokeRejectionHandlerForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->reject(1); $this->assertNull($adapter->promise()->done(null, $mock)); } /** @test */ public function doneShouldThrowExceptionThrownByRejectionHandlerForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $adapter->reject(1); $this->assertNull($adapter->promise()->done(null, function () { throw new \Exception('UnhandledRejectionException'); })); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenRejectedWithNonExceptionForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $adapter->reject(1); $this->assertNull($adapter->promise()->done()); } /** @test */ public function unhandledRejectionExceptionThrownByDoneHoldsRejectionValue() { $adapter = $this->getPromiseTestAdapter(); $expected = new \stdClass(); $adapter->reject($expected); try { $adapter->promise()->done(); } catch (UnhandledRejectionException $e) { $this->assertSame($expected, $e->getReason()); return; } $this->fail(); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenRejectionHandlerRejectsForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $adapter->reject(1); $this->assertNull($adapter->promise()->done(null, function () { return \React\Promise\reject(); })); } /** @test */ public function doneShouldThrowRejectionExceptionWhenRejectionHandlerRejectsWithExceptionForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $adapter->reject(1); $this->assertNull($adapter->promise()->done(null, function () { return \React\Promise\reject(new \Exception('UnhandledRejectionException')); })); } /** @test */ public function doneShouldThrowExceptionProvidedAsRejectionValueForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $adapter->reject(new \Exception('UnhandledRejectionException')); $this->assertNull($adapter->promise()->done()); } /** @test */ public function doneShouldThrowWithDeepNestingPromiseChainsForRejectedPromise() { $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $exception = new \Exception('UnhandledRejectionException'); $d = new Deferred(); $d->resolve(); $result = \React\Promise\resolve(\React\Promise\resolve($d->promise()->then(function () use ($exception) { $d = new Deferred(); $d->resolve(); return \React\Promise\resolve($d->promise()->then(function () {}))->then( function () use ($exception) { throw $exception; } ); }))); $result->done(); } /** @test */ public function doneShouldRecoverWhenRejectionHandlerCatchesExceptionForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->reject(new \Exception('UnhandledRejectionException')); $this->assertNull($adapter->promise()->done(null, function (\Exception $e) { })); } /** @test */ public function otherwiseShouldInvokeRejectionHandlerForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->reject(1); $adapter->promise()->otherwise($mock); } /** @test */ public function otherwiseShouldInvokeNonTypeHintedRejectionHandlerIfReasonIsAnExceptionForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->reject($exception); $adapter->promise() ->otherwise(function ($reason) use ($mock) { $mock($reason); }); } /** @test */ public function otherwiseShouldInvokeRejectionHandlerIfReasonMatchesTypehintForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \InvalidArgumentException(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->reject($exception); $adapter->promise() ->otherwise(function (\InvalidArgumentException $reason) use ($mock) { $mock($reason); }); } /** @test */ public function otherwiseShouldNotInvokeRejectionHandlerIfReaonsDoesNotMatchTypehintForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->expectCallableNever(); $adapter->reject($exception); $adapter->promise() ->otherwise(function (\InvalidArgumentException $reason) use ($mock) { $mock($reason); }); } /** @test */ public function alwaysShouldNotSuppressRejectionForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->reject($exception); $adapter->promise() ->always(function () {}) ->then(null, $mock); } /** @test */ public function alwaysShouldNotSuppressRejectionWhenHandlerReturnsANonPromiseForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->reject($exception); $adapter->promise() ->always(function () { return 1; }) ->then(null, $mock); } /** @test */ public function alwaysShouldNotSuppressRejectionWhenHandlerReturnsAPromiseForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->reject($exception); $adapter->promise() ->always(function () { return \React\Promise\resolve(1); }) ->then(null, $mock); } /** @test */ public function alwaysShouldRejectWhenHandlerThrowsForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception1 = new \Exception(); $exception2 = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception2)); $adapter->reject($exception1); $adapter->promise() ->always(function () use ($exception2) { throw $exception2; }) ->then(null, $mock); } /** @test */ public function alwaysShouldRejectWhenHandlerRejectsForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $exception1 = new \Exception(); $exception2 = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception2)); $adapter->reject($exception1); $adapter->promise() ->always(function () use ($exception2) { return \React\Promise\reject($exception2); }) ->then(null, $mock); } /** @test */ public function cancelShouldReturnNullForRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->reject(); $this->assertNull($adapter->promise()->cancel()); } /** @test */ public function cancelShouldHaveNoEffectForRejectedPromise() { $adapter = $this->getPromiseTestAdapter($this->expectCallableNever()); $adapter->reject(); $adapter->promise()->cancel(); } } promise-2.4.1/tests/PromiseTest/PromiseSettledTestTrait.php000066400000000000000000000044641271216237400241510ustar00rootroot00000000000000getPromiseTestAdapter(); $adapter->settle(); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $adapter->promise()->then()); } /** @test */ public function thenShouldReturnAllowNullForSettledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $adapter->promise()->then(null, null, null)); } /** @test */ public function cancelShouldReturnNullForSettledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $this->assertNull($adapter->promise()->cancel()); } /** @test */ public function cancelShouldHaveNoEffectForSettledPromise() { $adapter = $this->getPromiseTestAdapter($this->expectCallableNever()); $adapter->settle(); $adapter->promise()->cancel(); } /** @test */ public function doneShouldReturnNullForSettledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $this->assertNull($adapter->promise()->done(null, function () {})); } /** @test */ public function doneShouldReturnAllowNullForSettledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $this->assertNull($adapter->promise()->done(null, function () {}, null)); } /** @test */ public function progressShouldNotInvokeProgressHandlerForSettledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $adapter->promise()->progress($this->expectCallableNever()); $adapter->notify(); } /** @test */ public function alwaysShouldReturnAPromiseForSettledPromise() { $adapter = $this->getPromiseTestAdapter(); $adapter->settle(); $this->assertInstanceOf('React\\Promise\\PromiseInterface', $adapter->promise()->always(function () {})); } } promise-2.4.1/tests/PromiseTest/RejectTestTrait.php000066400000000000000000000235021271216237400224140ustar00rootroot00000000000000getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->reject(1); } /** @test */ public function rejectShouldRejectWithFulfilledPromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->reject(Promise\resolve(1)); } /** @test */ public function rejectShouldRejectWithRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->reject(Promise\reject(1)); } /** @test */ public function rejectShouldForwardReasonWhenCallbackIsNull() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then( $this->expectCallableNever() ) ->then( $this->expectCallableNever(), $mock ); $adapter->reject(1); } /** @test */ public function rejectShouldMakePromiseImmutable() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then(null, function ($value) use ($adapter) { $adapter->reject(3); return Promise\reject($value); }) ->then( $this->expectCallableNever(), $mock ); $adapter->reject(1); $adapter->reject(2); } /** @test */ public function notifyShouldInvokeOtherwiseHandler() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->otherwise($mock); $adapter->reject(1); } /** @test */ public function doneShouldInvokeRejectionHandler() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $this->assertNull($adapter->promise()->done(null, $mock)); $adapter->reject(1); } /** @test */ public function doneShouldThrowExceptionThrownByRejectionHandler() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $this->assertNull($adapter->promise()->done(null, function () { throw new \Exception('UnhandledRejectionException'); })); $adapter->reject(1); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenRejectedWithNonException() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $this->assertNull($adapter->promise()->done()); $adapter->reject(1); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenRejectionHandlerRejects() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $this->assertNull($adapter->promise()->done(null, function () { return \React\Promise\reject(); })); $adapter->reject(1); } /** @test */ public function doneShouldThrowRejectionExceptionWhenRejectionHandlerRejectsWithException() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $this->assertNull($adapter->promise()->done(null, function () { return \React\Promise\reject(new \Exception('UnhandledRejectionException')); })); $adapter->reject(1); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenRejectionHandlerRetunsPendingPromiseWhichRejectsLater() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $d = new Deferred(); $promise = $d->promise(); $this->assertNull($adapter->promise()->done(null, function () use ($promise) { return $promise; })); $adapter->reject(1); $d->reject(1); } /** @test */ public function doneShouldThrowExceptionProvidedAsRejectionValue() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $this->assertNull($adapter->promise()->done()); $adapter->reject(new \Exception('UnhandledRejectionException')); } /** @test */ public function doneShouldThrowWithDeepNestingPromiseChains() { $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $exception = new \Exception('UnhandledRejectionException'); $d = new Deferred(); $result = \React\Promise\resolve(\React\Promise\resolve($d->promise()->then(function () use ($exception) { $d = new Deferred(); $d->resolve(); return \React\Promise\resolve($d->promise()->then(function () {}))->then( function () use ($exception) { throw $exception; } ); }))); $result->done(); $d->resolve(); } /** @test */ public function doneShouldRecoverWhenRejectionHandlerCatchesException() { $adapter = $this->getPromiseTestAdapter(); $this->assertNull($adapter->promise()->done(null, function (\Exception $e) { })); $adapter->reject(new \Exception('UnhandledRejectionException')); } /** @test */ public function alwaysShouldNotSuppressRejection() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () {}) ->then(null, $mock); $adapter->reject($exception); } /** @test */ public function alwaysShouldNotSuppressRejectionWhenHandlerReturnsANonPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () { return 1; }) ->then(null, $mock); $adapter->reject($exception); } /** @test */ public function alwaysShouldNotSuppressRejectionWhenHandlerReturnsAPromise() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () { return \React\Promise\resolve(1); }) ->then(null, $mock); $adapter->reject($exception); } /** @test */ public function alwaysShouldRejectWhenHandlerThrowsForRejection() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () use ($exception) { throw $exception; }) ->then(null, $mock); $adapter->reject($exception); } /** @test */ public function alwaysShouldRejectWhenHandlerRejectsForRejection() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () use ($exception) { return \React\Promise\reject($exception); }) ->then(null, $mock); $adapter->reject($exception); } } promise-2.4.1/tests/PromiseTest/ResolveTestTrait.php000066400000000000000000000150721271216237400226220ustar00rootroot00000000000000getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($mock); $adapter->resolve(1); } /** @test */ public function resolveShouldResolveWithPromisedValue() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($mock); $adapter->resolve(Promise\resolve(1)); } /** @test */ public function resolveShouldRejectWhenResolvedWithRejectedPromise() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then($this->expectCallableNever(), $mock); $adapter->resolve(Promise\reject(1)); } /** @test */ public function resolveShouldForwardValueWhenCallbackIsNull() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then( null, $this->expectCallableNever() ) ->then( $mock, $this->expectCallableNever() ); $adapter->resolve(1); } /** @test */ public function resolveShouldMakePromiseImmutable() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $adapter->promise() ->then(function ($value) use ($adapter) { $adapter->resolve(3); return $value; }) ->then( $mock, $this->expectCallableNever() ); $adapter->resolve(1); $adapter->resolve(2); } /** @test */ public function doneShouldInvokeFulfillmentHandler() { $adapter = $this->getPromiseTestAdapter(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo(1)); $this->assertNull($adapter->promise()->done($mock)); $adapter->resolve(1); } /** @test */ public function doneShouldThrowExceptionThrownFulfillmentHandler() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('\Exception', 'UnhandledRejectionException'); $this->assertNull($adapter->promise()->done(function () { throw new \Exception('UnhandledRejectionException'); })); $adapter->resolve(1); } /** @test */ public function doneShouldThrowUnhandledRejectionExceptionWhenFulfillmentHandlerRejects() { $adapter = $this->getPromiseTestAdapter(); $this->setExpectedException('React\\Promise\\UnhandledRejectionException'); $this->assertNull($adapter->promise()->done(function () { return \React\Promise\reject(); })); $adapter->resolve(1); } /** @test */ public function alwaysShouldNotSuppressValue() { $adapter = $this->getPromiseTestAdapter(); $value = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($value)); $adapter->promise() ->always(function () {}) ->then($mock); $adapter->resolve($value); } /** @test */ public function alwaysShouldNotSuppressValueWhenHandlerReturnsANonPromise() { $adapter = $this->getPromiseTestAdapter(); $value = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($value)); $adapter->promise() ->always(function () { return 1; }) ->then($mock); $adapter->resolve($value); } /** @test */ public function alwaysShouldNotSuppressValueWhenHandlerReturnsAPromise() { $adapter = $this->getPromiseTestAdapter(); $value = new \stdClass(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($value)); $adapter->promise() ->always(function () { return \React\Promise\resolve(1); }) ->then($mock); $adapter->resolve($value); } /** @test */ public function alwaysShouldRejectWhenHandlerThrowsForFulfillment() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () use ($exception) { throw $exception; }) ->then(null, $mock); $adapter->resolve(1); } /** @test */ public function alwaysShouldRejectWhenHandlerRejectsForFulfillment() { $adapter = $this->getPromiseTestAdapter(); $exception = new \Exception(); $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke') ->with($this->identicalTo($exception)); $adapter->promise() ->always(function () use ($exception) { return \React\Promise\reject($exception); }) ->then(null, $mock); $adapter->resolve(1); } } promise-2.4.1/tests/RejectedPromiseTest.php000066400000000000000000000027511271216237400210050ustar00rootroot00000000000000 function () use (&$promise) { if (!$promise) { throw new \LogicException('RejectedPromise must be rejected before obtaining the promise'); } return $promise; }, 'resolve' => function () { throw new \LogicException('You cannot call resolve() for React\Promise\RejectedPromise'); }, 'reject' => function ($reason = null) use (&$promise) { if (!$promise) { $promise = new RejectedPromise($reason); } }, 'notify' => function () { // no-op }, 'settle' => function ($reason = null) use (&$promise) { if (!$promise) { $promise = new RejectedPromise($reason); } }, ]); } /** @test */ public function shouldThrowExceptionIfConstructedWithAPromise() { $this->setExpectedException('\InvalidArgumentException'); return new RejectedPromise(new RejectedPromise()); } } promise-2.4.1/tests/Stub/000077500000000000000000000000001271216237400152605ustar00rootroot00000000000000promise-2.4.1/tests/Stub/CallableStub.php000066400000000000000000000001501271216237400203220ustar00rootroot00000000000000createCallableMock(); $mock ->expects($this->exactly($amount)) ->method('__invoke'); return $mock; } public function expectCallableOnce() { $mock = $this->createCallableMock(); $mock ->expects($this->once()) ->method('__invoke'); return $mock; } public function expectCallableNever() { $mock = $this->createCallableMock(); $mock ->expects($this->never()) ->method('__invoke'); return $mock; } public function createCallableMock() { return $this->getMock('React\\Promise\Stub\CallableStub'); } } promise-2.4.1/tests/bootstrap.php000066400000000000000000000003001271216237400170620ustar00rootroot00000000000000addPsr4('React\\Promise\\', __DIR__); promise-2.4.1/tests/fixtures/000077500000000000000000000000001271216237400162145ustar00rootroot00000000000000promise-2.4.1/tests/fixtures/SimpleFulfilledTestPromise.php000066400000000000000000000010461271216237400242050ustar00rootroot00000000000000cancelCalled = true; } } promise-2.4.1/tests/fixtures/SimpleTestCancellableThenable.php000066400000000000000000000005221271216237400245660ustar00rootroot00000000000000cancelCalled = true; } }