diff options
Diffstat (limited to 'assets/php/vendor/react/promise-timer')
15 files changed, 975 insertions, 0 deletions
diff --git a/assets/php/vendor/react/promise-timer/.gitignore b/assets/php/vendor/react/promise-timer/.gitignore new file mode 100644 index 0000000..de4a392 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/.gitignore @@ -0,0 +1,2 @@ +/vendor +/composer.lock diff --git a/assets/php/vendor/react/promise-timer/.travis.yml b/assets/php/vendor/react/promise-timer/.travis.yml new file mode 100644 index 0000000..a71864a --- /dev/null +++ b/assets/php/vendor/react/promise-timer/.travis.yml @@ -0,0 +1,26 @@ +language: php + +php: +# - 5.3 # requires old distro, see below + - 5.4 + - 5.5 + - 5.6 + - 7.0 + - 7.1 + - hhvm # ignore errors, see below + +# lock distro so new future defaults will not break the build +dist: trusty + +matrix: + include: + - php: 5.3 + dist: precise + allow_failures: + - php: hhvm + +install: + - composer install --no-interaction + +script: + - vendor/bin/phpunit --coverage-text diff --git a/assets/php/vendor/react/promise-timer/CHANGELOG.md b/assets/php/vendor/react/promise-timer/CHANGELOG.md new file mode 100644 index 0000000..0a21244 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/CHANGELOG.md @@ -0,0 +1,40 @@ +# Changelog + +## 1.2.1 (2017-12-22) + +* README improvements + (#28 by @jsor) + +* Improve test suite by adding forward compatiblity with PHPUnit 6 and + fix test suite forward compatibility with upcoming EventLoop releases + (#30 and #31 by @clue) + +## 1.2.0 (2017-08-08) + +* Feature: Only start timers if input Promise is still pending and + return a settled output promise if the input is already settled. + (#25 by @clue) + +* Feature: Cap minimum timer interval at 1µs across all versions + (#23 by @clue) + +* Feature: Forward compatibility with EventLoop v1.0 and v0.5 + (#27 by @clue) + +* Improve test suite by adding PHPUnit to require-dev and + lock Travis distro so new defaults will not break the build + (#24 and #26 by @clue) + +## 1.1.1 (2016-12-27) + +* Improve test suite to use PSR-4 autoloader and proper namespaces. + (#21 by @clue) + +## 1.1.0 (2016-02-29) + +* Feature: Support promise cancellation for all timer primitives + (#18 by @clue) + +## 1.0.0 (2015-09-29) + +* First tagged release diff --git a/assets/php/vendor/react/promise-timer/LICENSE b/assets/php/vendor/react/promise-timer/LICENSE new file mode 100644 index 0000000..dc09d1e --- /dev/null +++ b/assets/php/vendor/react/promise-timer/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Christian Lück + +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. diff --git a/assets/php/vendor/react/promise-timer/README.md b/assets/php/vendor/react/promise-timer/README.md new file mode 100644 index 0000000..2ea94fa --- /dev/null +++ b/assets/php/vendor/react/promise-timer/README.md @@ -0,0 +1,372 @@ +# PromiseTimer + +[](https://travis-ci.org/reactphp/promise-timer) + +A trivial implementation of timeouts for `Promise`s, built on top of [ReactPHP](https://reactphp.org/). + +**Table of contents** + +* [Usage](#usage) + * [timeout()](#timeout) + * [Timeout cancellation](#timeout-cancellation) + * [Cancellation handler](#cancellation-handler) + * [Input cancellation](#input-cancellation) + * [Output cancellation](#output-cancellation) + * [Collections](#collections) + * [resolve()](#resolve) + * [Resolve cancellation](#resolve-cancellation) + * [reject()](#reject) + * [Reject cancellation](#reject-cancellation) + * [TimeoutException](#timeoutexception) +* [Install](#install) +* [Tests](#tests) +* [License](#license) + +## Usage + +This lightweight library consists only of a few simple functions. +All functions reside under the `React\Promise\Timer` namespace. + +The below examples assume you use an import statement similar to this: + +```php +use React\Promise\Timer; + +Timer\timeout(…); +``` + +Alternatively, you can also refer to them with their fully-qualified name: + +```php +\React\Promise\Timer\timeout(…); +``` + +### timeout() + +The `timeout(PromiseInterface $promise, $time, LoopInterface $loop)` function +can be used to *cancel* operations that take *too long*. +You need to pass in an input `$promise` that represents a pending operation and timeout parameters. +It returns a new `Promise` with the following resolution behavior: + +* If the input `$promise` resolves before `$time` seconds, resolve the resulting promise with its fulfillment value. +* If the input `$promise` rejects before `$time` seconds, reject the resulting promise with its rejection value. +* If the input `$promise` does not settle before `$time` seconds, *cancel* the operation and reject the resulting promise with a [`TimeoutException`](#timeoutexception). + +Internally, the given `$time` value will be used to start a timer that will +*cancel* the pending operation once it triggers. +This implies that if you pass a really small (or negative) value, it will still +start a timer and will thus trigger at the earliest possible time in the future. + +If the input `$promise` is already settled, then the resulting promise will +resolve or reject immediately without starting a timer at all. + +A common use case for handling only resolved values looks like this: + +```php +$promise = accessSomeRemoteResource(); +Timer\timeout($promise, 10.0, $loop)->then(function ($value) { + // the operation finished within 10.0 seconds +}); +``` + +A more complete example could look like this: + +```php +$promise = accessSomeRemoteResource(); +Timer\timeout($promise, 10.0, $loop)->then( + function ($value) { + // the operation finished within 10.0 seconds + }, + function ($error) { + if ($error instanceof Timer\TimeoutException) { + // the operation has failed due to a timeout + } else { + // the input operation has failed due to some other error + } + } +); +``` + +Or if you're using [react/promise v2.2.0](https://github.com/reactphp/promise) or up: + +```php +Timer\timeout($promise, 10.0, $loop) + ->then(function ($value) { + // the operation finished within 10.0 seconds + }) + ->otherwise(function (Timer\TimeoutException $error) { + // the operation has failed due to a timeout + }) + ->otherwise(function ($error) { + // the input operation has failed due to some other error + }) +; +``` + +#### Timeout cancellation + +As discussed above, the [`timeout()`](#timeout) function will *cancel* the +underlying operation if it takes *too long*. +This means that you can be sure the resulting promise will then be rejected +with a [`TimeoutException`](#timeoutexception). + +However, what happens to the underlying input `$promise` is a bit more tricky: +Once the timer fires, we will try to call +[`$promise->cancel()`](https://github.com/reactphp/promise#cancellablepromiseinterfacecancel) +on the input `$promise` which in turn invokes its [cancellation handler](#cancellation-handler). + +This means that it's actually up the input `$promise` to handle +[cancellation support](https://github.com/reactphp/promise#cancellablepromiseinterface). + +* A common use case involves cleaning up any resources like open network sockets or + file handles or terminating external processes or timers. + +* If the given input `$promise` does not support cancellation, then this is a NO-OP. + This means that while the resulting promise will still be rejected, the underlying + input `$promise` may still be pending and can hence continue consuming resources. + +See the following chapter for more details on the cancellation handler. + +#### Cancellation handler + +For example, an implementation for the above operation could look like this: + +```php +function accessSomeRemoteResource() +{ + return new Promise( + function ($resolve, $reject) use (&$socket) { + // this will be called once the promise is created + // a common use case involves opening any resources and eventually resolving + $socket = createSocket(); + $socket->on('data', function ($data) use ($resolve) { + $resolve($data); + }); + }, + function ($resolve, $reject) use (&$socket) { + // this will be called once calling `cancel()` on this promise + // a common use case involves cleaning any resources and then rejecting + $socket->close(); + $reject(new \RuntimeException('Operation cancelled')); + } + ); +} +``` + +In this example, calling `$promise->cancel()` will invoke the registered cancellation +handler which then closes the network socket and rejects the `Promise` instance. + +If no cancellation handler is passed to the `Promise` constructor, then invoking +its `cancel()` method it is effectively a NO-OP. +This means that it may still be pending and can hence continue consuming resources. + +For more details on the promise cancellation, please refer to the +[Promise documentation](https://github.com/reactphp/promise#cancellablepromiseinterface). + +#### Input cancellation + +Irrespective of the timout handling, you can also explicitly `cancel()` the +input `$promise` at any time. +This means that the `timeout()` handling does not affect cancellation of the +input `$promise`, as demonstrated in the following example: + +```php +$promise = accessSomeRemoteResource(); +$timeout = Timer\timeout($promise, 10.0, $loop); + +$promise->cancel(); +``` + +The registered [cancellation handler](#cancellation-handler) is responsible for +handling the `cancel()` call: + +* A described above, a common use involves resource cleanup and will then *reject* + the `Promise`. + If the input `$promise` is being rejected, then the timeout will be aborted + and the resulting promise will also be rejected. +* If the input `$promise` is still pending, then the timout will continue + running until the timer expires. + The same happens if the input `$promise` does not register a + [cancellation handler](#cancellation-handler). + +#### Output cancellation + +Similarily, you can also explicitly `cancel()` the resulting promise like this: + +```php +$promise = accessSomeRemoteResource(); +$timeout = Timer\timeout($promise, 10.0, $loop); + +$timeout->cancel(); +``` + +Note how this looks very similar to the above [input cancellation](#input-cancellation) +example. Accordingly, it also behaves very similar. + +Calling `cancel()` on the resulting promise will merely try +to `cancel()` the input `$promise`. +This means that we do not take over responsibility of the outcome and it's +entirely up to the input `$promise` to handle cancellation support. + +The registered [cancellation handler](#cancellation-handler) is responsible for +handling the `cancel()` call: + +* As described above, a common use involves resource cleanup and will then *reject* + the `Promise`. + If the input `$promise` is being rejected, then the timeout will be aborted + and the resulting promise will also be rejected. +* If the input `$promise` is still pending, then the timout will continue + running until the timer expires. + The same happens if the input `$promise` does not register a + [cancellation handler](#cancellation-handler). + +To re-iterate, note that calling `cancel()` on the resulting promise will merely +try to cancel the input `$promise` only. +It is then up to the cancellation handler of the input promise to settle the promise. +If the input promise is still pending when the timeout occurs, then the normal +[timeout cancellation](#timeout-cancellation) handling will trigger, effectively rejecting +the output promise with a [`TimeoutException`](#timeoutexception). + +This is done for consistency with the [timeout cancellation](#timeout-cancellation) +handling and also because it is assumed this is often used like this: + +```php +$timeout = Timer\timeout(accessSomeRemoteResource(), 10.0, $loop); + +$timeout->cancel(); +``` + +As described above, this example works as expected and cleans up any resources +allocated for the input `$promise`. + +Note that if the given input `$promise` does not support cancellation, then this +is a NO-OP. +This means that while the resulting promise will still be rejected after the +timeout, the underlying input `$promise` may still be pending and can hence +continue consuming resources. + +#### Collections + +If you want to wait for multiple promises to resolve, you can use the normal promise primitives like this: + +```php +$promises = array( + accessSomeRemoteResource(), + accessSomeRemoteResource(), + accessSomeRemoteResource() +); + +$promise = \React\Promise\all($promises); + +Timer\timeout($promise, 10, $loop)->then(function ($values) { + // *all* promises resolved +}); +``` + +The applies to all promise collection primitives alike, i.e. `all()`, `race()`, `any()`, `some()` etc. + +For more details on the promise primitives, please refer to the +[Promise documentation](https://github.com/reactphp/promise#functions). + +### resolve() + +The `resolve($time, LoopInterface $loop)` function can be used to create a new Promise that +resolves in `$time` seconds with the `$time` as the fulfillment value. + +```php +Timer\resolve(1.5, $loop)->then(function ($time) { + echo 'Thanks for waiting ' . $time . ' seconds' . PHP_EOL; +}); +``` + +Internally, the given `$time` value will be used to start a timer that will +resolve the promise once it triggers. +This implies that if you pass a really small (or negative) value, it will still +start a timer and will thus trigger at the earliest possible time in the future. + +#### Resolve cancellation + +You can explicitly `cancel()` the resulting timer promise at any time: + +```php +$timer = Timer\resolve(2.0, $loop); + +$timer->cancel(); +``` + +This will abort the timer and *reject* with a `RuntimeException`. + +### reject() + +The `reject($time, LoopInterface $loop)` function can be used to create a new Promise +which rejects in `$time` seconds with a `TimeoutException`. + +```php +Timer\reject(2.0, $loop)->then(null, function (TimeoutException $e) { + echo 'Rejected after ' . $e->getTimeout() . ' seconds ' . PHP_EOL; +}); +``` + +Internally, the given `$time` value will be used to start a timer that will +reject the promise once it triggers. +This implies that if you pass a really small (or negative) value, it will still +start a timer and will thus trigger at the earliest possible time in the future. + +This function complements the [`resolve()`](#resolve) function +and can be used as a basic building block for higher-level promise consumers. + +#### Reject cancellation + +You can explicitly `cancel()` the resulting timer promise at any time: + +```php +$timer = Timer\reject(2.0, $loop); + +$timer->cancel(); +``` + +This will abort the timer and *reject* with a `RuntimeException`. + +### TimeoutException + +The `TimeoutException` extends PHP's built-in `RuntimeException`. + +The `getTimeout()` method can be used to get the timeout value in seconds. + +## Install + +The recommended way to install this library is [through Composer](https://getcomposer.org). +[New to Composer?](https://getcomposer.org/doc/00-intro.md) + +This project follows [SemVer](http://semver.org/). +This will install the latest supported version: + +```bash +$ composer require react/promise-timer:^1.2.1 +``` + +See also the [CHANGELOG](CHANGELOG.md) for details about version upgrades. + +This project aims to run on any platform and thus does not require any PHP +extensions and supports running on legacy PHP 5.3 through current PHP 7+ and +HHVM. +It's *highly recommended to use PHP 7+* for this project. + +## Tests + +To run the test suite, you first need to clone this repo and then install all +dependencies [through Composer](https://getcomposer.org): + +```bash +$ composer install +``` + +To run the test suite, go to the project root and run: + +```bash +$ php vendor/bin/phpunit +``` + +## License + +MIT, see [LICENSE file](LICENSE). diff --git a/assets/php/vendor/react/promise-timer/composer.json b/assets/php/vendor/react/promise-timer/composer.json new file mode 100644 index 0000000..e425dc6 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/composer.json @@ -0,0 +1,28 @@ +{ + "name": "react/promise-timer", + "description": "A trivial implementation of timeouts for Promises, built on top of ReactPHP.", + "keywords": ["Promise", "timeout", "timer", "event-loop", "ReactPHP", "async"], + "homepage": "https://github.com/react/promise-timer", + "license": "MIT", + "authors": [ + { + "name": "Christian Lück", + "email": "christian@lueck.tv" + } + ], + "autoload": { + "psr-4": { "React\\Promise\\Timer\\": "src/" }, + "files": [ "src/functions.php" ] + }, + "autoload-dev": { + "psr-4": { "React\\Tests\\Promise\\Timer\\": "tests/" } + }, + "require": { + "php": ">=5.3", + "react/event-loop": "^1.0 || ^0.5 || ^0.4 || ^0.3.5", + "react/promise": "~2.1|~1.2" + }, + "require-dev": { + "phpunit/phpunit": "^6.4 || ^5.7 || ^4.8.35" + } +} diff --git a/assets/php/vendor/react/promise-timer/phpunit.xml.dist b/assets/php/vendor/react/promise-timer/phpunit.xml.dist new file mode 100644 index 0000000..bb79fba --- /dev/null +++ b/assets/php/vendor/react/promise-timer/phpunit.xml.dist @@ -0,0 +1,19 @@ +<?xml version="1.0" encoding="UTF-8"?> + +<phpunit bootstrap="vendor/autoload.php" + colors="true" + convertErrorsToExceptions="true" + convertNoticesToExceptions="true" + convertWarningsToExceptions="true" +> + <testsuites> + <testsuite name="Promise Timer Test Suite"> + <directory>./tests/</directory> + </testsuite> + </testsuites> + <filter> + <whitelist> + <directory>./src/</directory> + </whitelist> + </filter> +</phpunit>
\ No newline at end of file diff --git a/assets/php/vendor/react/promise-timer/src/TimeoutException.php b/assets/php/vendor/react/promise-timer/src/TimeoutException.php new file mode 100644 index 0000000..18ea72f --- /dev/null +++ b/assets/php/vendor/react/promise-timer/src/TimeoutException.php @@ -0,0 +1,22 @@ +<?php + +namespace React\Promise\Timer; + +use RuntimeException; + +class TimeoutException extends RuntimeException +{ + private $timeout; + + public function __construct($timeout, $message = null, $code = null, $previous = null) + { + parent::__construct($message, $code, $previous); + + $this->timeout = $timeout; + } + + public function getTimeout() + { + return $this->timeout; + } +} diff --git a/assets/php/vendor/react/promise-timer/src/functions.php b/assets/php/vendor/react/promise-timer/src/functions.php new file mode 100644 index 0000000..6ad9867 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/src/functions.php @@ -0,0 +1,70 @@ +<?php + +namespace React\Promise\Timer; + +use React\Promise\CancellablePromiseInterface; +use React\EventLoop\LoopInterface; +use React\Promise\PromiseInterface; +use React\Promise\Promise; + +function timeout(PromiseInterface $promise, $time, LoopInterface $loop) +{ + // cancelling this promise will only try to cancel the input promise, + // thus leaving responsibility to the input promise. + $canceller = null; + if ($promise instanceof CancellablePromiseInterface) { + $canceller = array($promise, 'cancel'); + } + + return new Promise(function ($resolve, $reject) use ($loop, $time, $promise) { + $timer = null; + $promise->then(function ($v) use (&$timer, $loop, $resolve) { + if ($timer) { + $loop->cancelTimer($timer); + } + $timer = false; + $resolve($v); + }, function ($v) use (&$timer, $loop, $reject) { + if ($timer) { + $loop->cancelTimer($timer); + } + $timer = false; + $reject($v); + }); + + // promise already resolved => no need to start timer + if ($timer === false) { + return; + } + + // start timeout timer which will cancel the input promise + $timer = $loop->addTimer($time, function () use ($time, $promise, $reject) { + $reject(new TimeoutException($time, 'Timed out after ' . $time . ' seconds')); + + if ($promise instanceof CancellablePromiseInterface) { + $promise->cancel(); + } + }); + }, $canceller); +} + +function resolve($time, LoopInterface $loop) +{ + return new Promise(function ($resolve) use ($loop, $time, &$timer) { + // resolve the promise when the timer fires in $time seconds + $timer = $loop->addTimer($time, function () use ($time, $resolve) { + $resolve($time); + }); + }, function ($resolveUnused, $reject) use (&$timer, $loop) { + // cancelling this promise will cancel the timer and reject + $loop->cancelTimer($timer); + $reject(new \RuntimeException('Timer cancelled')); + }); +} + +function reject($time, LoopInterface $loop) +{ + return resolve($time, $loop)->then(function ($time) { + throw new TimeoutException($time, 'Timer expired after ' . $time . ' seconds'); + }); +} diff --git a/assets/php/vendor/react/promise-timer/tests/CallableStub.php b/assets/php/vendor/react/promise-timer/tests/CallableStub.php new file mode 100644 index 0000000..a391aa5 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/tests/CallableStub.php @@ -0,0 +1,10 @@ +<?php + +namespace React\Tests\Promise\Timer; + +class CallableStub +{ + public function __invoke() + { + } +} diff --git a/assets/php/vendor/react/promise-timer/tests/FunctionRejectTest.php b/assets/php/vendor/react/promise-timer/tests/FunctionRejectTest.php new file mode 100644 index 0000000..6153fcc --- /dev/null +++ b/assets/php/vendor/react/promise-timer/tests/FunctionRejectTest.php @@ -0,0 +1,49 @@ +<?php + +namespace React\Tests\Promise\Timer; + +use React\Promise\Timer; + +class FunctionRejectTest extends TestCase +{ + public function testPromiseIsPendingWithoutRunningLoop() + { + $promise = Timer\reject(0.01, $this->loop); + + $this->expectPromisePending($promise); + } + + public function testPromiseExpiredIsPendingWithoutRunningLoop() + { + $promise = Timer\reject(-1, $this->loop); + + $this->expectPromisePending($promise); + } + + public function testPromiseWillBeRejectedOnTimeout() + { + $promise = Timer\reject(0.01, $this->loop); + + $this->loop->run(); + + $this->expectPromiseRejected($promise); + } + + public function testPromiseExpiredWillBeRejectedOnTimeout() + { + $promise = Timer\reject(-1, $this->loop); + + $this->loop->run(); + + $this->expectPromiseRejected($promise); + } + + public function testCancelingPromiseWillRejectTimer() + { + $promise = Timer\reject(0.01, $this->loop); + + $promise->cancel(); + + $this->expectPromiseRejected($promise); + } +} diff --git a/assets/php/vendor/react/promise-timer/tests/FunctionResolveTest.php b/assets/php/vendor/react/promise-timer/tests/FunctionResolveTest.php new file mode 100644 index 0000000..0bfdc21 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/tests/FunctionResolveTest.php @@ -0,0 +1,71 @@ +<?php + +namespace React\Tests\Promise\Timer; + +use React\Promise\Timer; + +class FunctionResolveTest extends TestCase +{ + public function testPromiseIsPendingWithoutRunningLoop() + { + $promise = Timer\resolve(0.01, $this->loop); + + $this->expectPromisePending($promise); + } + + public function testPromiseExpiredIsPendingWithoutRunningLoop() + { + $promise = Timer\resolve(-1, $this->loop); + + $this->expectPromisePending($promise); + } + + public function testPromiseWillBeResolvedOnTimeout() + { + $promise = Timer\resolve(0.01, $this->loop); + + $this->loop->run(); + + $this->expectPromiseResolved($promise); + } + + public function testPromiseExpiredWillBeResolvedOnTimeout() + { + $promise = Timer\resolve(-1, $this->loop); + + $this->loop->run(); + + $this->expectPromiseResolved($promise); + } + + public function testWillStartLoopTimer() + { + $loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock(); + $loop->expects($this->once())->method('addTimer')->with($this->equalTo(0.01)); + + Timer\resolve(0.01, $loop); + } + + public function testCancellingPromiseWillCancelLoopTimer() + { + $loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock(); + + $timer = $this->getMockBuilder(interface_exists('React\EventLoop\TimerInterface') ? 'React\EventLoop\TimerInterface' : 'React\EventLoop\Timer\TimerInterface')->getMock(); + $loop->expects($this->once())->method('addTimer')->will($this->returnValue($timer)); + + $promise = Timer\resolve(0.01, $loop); + + $loop->expects($this->once())->method('cancelTimer')->with($this->equalTo($timer)); + + $promise->cancel(); + } + + public function testCancelingPromiseWillRejectTimer() + { + $promise = Timer\resolve(0.01, $this->loop); + + $promise->cancel(); + + $this->expectPromiseRejected($promise); + } +} diff --git a/assets/php/vendor/react/promise-timer/tests/FunctionTimeoutTest.php b/assets/php/vendor/react/promise-timer/tests/FunctionTimeoutTest.php new file mode 100644 index 0000000..aaca2da --- /dev/null +++ b/assets/php/vendor/react/promise-timer/tests/FunctionTimeoutTest.php @@ -0,0 +1,169 @@ +<?php + +namespace React\Tests\Promise\Timer; + +use React\Promise\Timer; +use React\Promise; + +class FunctionTimerTest extends TestCase +{ + public function testResolvedWillResolveRightAway() + { + $promise = Promise\resolve(); + + $promise = Timer\timeout($promise, 3, $this->loop); + + $this->expectPromiseResolved($promise); + } + + public function testResolvedExpiredWillResolveRightAway() + { + $promise = Promise\resolve(); + + $promise = Timer\timeout($promise, -1, $this->loop); + + $this->expectPromiseResolved($promise); + } + + public function testResolvedWillNotStartTimer() + { + $promise = Promise\resolve(); + + Timer\timeout($promise, 3, $this->loop); + + $time = microtime(true); + $this->loop->run(); + $time = microtime(true) - $time; + + $this->assertLessThan(0.5, $time); + } + + public function testRejectedWillRejectRightAway() + { + $promise = Promise\reject(); + + $promise = Timer\timeout($promise, 3, $this->loop); + + $this->expectPromiseRejected($promise); + } + + public function testRejectedWillNotStartTimer() + { + $promise = Promise\reject(); + + Timer\timeout($promise, 3, $this->loop); + + $time = microtime(true); + $this->loop->run(); + $time = microtime(true) - $time; + + $this->assertLessThan(0.5, $time); + } + + public function testPendingWillRejectOnTimeout() + { + $promise = $this->getMockBuilder('React\Promise\PromiseInterface')->getMock(); + + $promise = Timer\timeout($promise, 0.01, $this->loop); + + $this->loop->run(); + + $this->expectPromiseRejected($promise); + } + + public function testPendingCancellableWillBeCancelledOnTimeout() + { + $promise = $this->getMockBuilder('React\Promise\CancellablePromiseInterface')->getMock(); + $promise->expects($this->once())->method('cancel'); + + Timer\timeout($promise, 0.01, $this->loop); + + $this->loop->run(); + } + + public function testCancelTimeoutWithoutCancellationhandlerWillNotCancelTimerAndWillNotReject() + { + $promise = new \React\Promise\Promise(function () { }); + + $loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock(); + + $timer = $this->getMockBuilder('React\EventLoop\Timer\TimerInterface')->getMock(); + $loop->expects($this->once())->method('addTimer')->will($this->returnValue($timer)); + $loop->expects($this->never())->method('cancelTimer'); + + $timeout = Timer\timeout($promise, 0.01, $loop); + + $timeout->cancel(); + + $this->expectPromisePending($timeout); + } + + public function testResolvedPromiseWillNotStartTimer() + { + $promise = new \React\Promise\Promise(function ($resolve) { $resolve(true); }); + + $loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock(); + $loop->expects($this->never())->method('addTimer'); + + $timeout = Timer\timeout($promise, 0.01, $loop); + + $this->expectPromiseResolved($timeout); + } + + public function testRejectedPromiseWillNotStartTimer() + { + $promise = Promise\reject(new \RuntimeException()); + + $loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock(); + $loop->expects($this->never())->method('addTimer'); + + $timeout = Timer\timeout($promise, 0.01, $loop); + + $this->expectPromiseRejected($timeout); + } + + public function testCancelTimeoutWillCancelGivenPromise() + { + $promise = new \React\Promise\Promise(function () { }, $this->expectCallableOnce()); + + $timeout = Timer\timeout($promise, 0.01, $this->loop); + + $timeout->cancel(); + } + + public function testCancelGivenPromiseWillReject() + { + $promise = new \React\Promise\Promise(function () { }, function ($resolve, $reject) { $reject(); }); + + $timeout = Timer\timeout($promise, 0.01, $this->loop); + + $promise->cancel(); + + $this->expectPromiseRejected($promise); + $this->expectPromiseRejected($timeout); + } + + public function testCancelTimeoutWillRejectIfGivenPromiseWillReject() + { + $promise = new \React\Promise\Promise(function () { }, function ($resolve, $reject) { $reject(); }); + + $timeout = Timer\timeout($promise, 0.01, $this->loop); + + $timeout->cancel(); + + $this->expectPromiseRejected($promise); + $this->expectPromiseRejected($timeout); + } + + public function testCancelTimeoutWillResolveIfGivenPromiseWillResolve() + { + $promise = new \React\Promise\Promise(function () { }, function ($resolve, $reject) { $resolve(); }); + + $timeout = Timer\timeout($promise, 0.01, $this->loop); + + $timeout->cancel(); + + $this->expectPromiseResolved($promise); + $this->expectPromiseResolved($timeout); + } +} diff --git a/assets/php/vendor/react/promise-timer/tests/TestCase.php b/assets/php/vendor/react/promise-timer/tests/TestCase.php new file mode 100644 index 0000000..9d8d49a --- /dev/null +++ b/assets/php/vendor/react/promise-timer/tests/TestCase.php @@ -0,0 +1,61 @@ +<?php + +namespace React\Tests\Promise\Timer; + +use PHPUnit\Framework\TestCase as BaseTestCase; +use React\EventLoop\Factory; + +class TestCase extends BaseTestCase +{ + protected $loop; + + public function setUp() + { + $this->loop = Factory::create(); + } + + protected function expectCallableOnce() + { + $mock = $this->createCallableMock(); + + $mock + ->expects($this->once()) + ->method('__invoke'); + + return $mock; + } + + protected function expectCallableNever() + { + $mock = $this->createCallableMock(); + + $mock + ->expects($this->never()) + ->method('__invoke'); + + return $mock; + } + + /** + * @link https://github.com/reactphp/react/blob/master/tests/React/Tests/Socket/TestCase.php (taken from reactphp/react) + */ + protected function createCallableMock() + { + return $this->getMockBuilder('React\Tests\Promise\Timer\CallableStub')->getMock(); + } + + protected function expectPromiseRejected($promise) + { + return $promise->then($this->expectCallableNever(), $this->expectCallableOnce()); + } + + protected function expectPromiseResolved($promise) + { + return $promise->then($this->expectCallableOnce(), $this->expectCallableNever()); + } + + protected function expectPromisePending($promise) + { + return $promise->then($this->expectCallableNever(), $this->expectCallableNever()); + } +} diff --git a/assets/php/vendor/react/promise-timer/tests/TimeoutExceptionTest.php b/assets/php/vendor/react/promise-timer/tests/TimeoutExceptionTest.php new file mode 100644 index 0000000..e9bedd9 --- /dev/null +++ b/assets/php/vendor/react/promise-timer/tests/TimeoutExceptionTest.php @@ -0,0 +1,15 @@ +<?php + +namespace React\Tests\Promise\Timer; + +use React\Promise\Timer\TimeoutException; + +class TimeoutExceptionTest extends TestCase +{ + public function testAccessTimeout() + { + $e = new TimeoutException(10); + + $this->assertEquals(10, $e->getTimeout()); + } +} |