OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	10/04/2024 04:46:13 AM	rwxr-xr-x
📄 AbstractConfigurationProviderTest.php	3.42 KB	08/14/2024 07:57:51 AM	rw-r--r--
📁 Api	-	08/14/2024 08:08:06 AM	rwxr-xr-x
📁 Arn	-	08/14/2024 08:01:03 AM	rwxr-xr-x
📁 Auth	-	08/14/2024 07:59:04 AM	rwxr-xr-x
📄 AwsClientTest.php	29.67 KB	08/14/2024 07:57:51 AM	rw-r--r--
📁 Build	-	08/14/2024 08:01:04 AM	rwxr-xr-x
📄 ClientResolverTest.php	55.74 KB	08/14/2024 07:57:51 AM	rw-r--r--
📁 ClientSideMonitoring	-	08/14/2024 07:59:04 AM	rwxr-xr-x
📁 CloudFront	-	08/14/2024 08:01:04 AM	rwxr-xr-x
📁 CloudSearchDomain	-	08/14/2024 07:59:05 AM	rwxr-xr-x
📁 CloudTrail	-	08/14/2024 07:59:05 AM	rwxr-xr-x
📁 CloudWatchLogs	-	08/14/2024 07:59:05 AM	rwxr-xr-x
📁 CognitoIdentity	-	08/14/2024 07:59:05 AM	rwxr-xr-x
📁 CognitoSync	-	08/14/2024 07:59:05 AM	rwxr-xr-x
📄 CommandPoolTest.php	5.8 KB	08/14/2024 07:57:51 AM	rw-r--r--
📄 CommandTest.php	3.28 KB	08/14/2024 07:57:51 AM	rw-r--r--
📄 ConfigurationResolverTest.php	12.35 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Credentials	-	08/14/2024 08:07:59 AM	rwxr-xr-x
📁 Crypto	-	08/14/2024 08:01:04 AM	rwxr-xr-x
📁 DefaultsMode	-	08/14/2024 07:59:06 AM	rwxr-xr-x
📁 DocDb	-	08/14/2024 07:59:06 AM	rwxr-xr-x
📄 DoctrineCacheAdapterTest.php	1.23 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 DynamoDb	-	08/14/2024 07:59:07 AM	rwxr-xr-x
📁 Ec2	-	08/14/2024 07:59:07 AM	rwxr-xr-x
📁 ElasticLoadBalancingV2	-	08/14/2024 07:59:07 AM	rwxr-xr-x
📁 Endpoint	-	08/14/2024 08:01:05 AM	rwxr-xr-x
📁 EndpointDiscovery	-	08/14/2024 08:08:07 AM	rwxr-xr-x
📄 EndpointParameterMiddlewareTest.php	9.21 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 EndpointV2	-	08/14/2024 08:01:06 AM	rwxr-xr-x
📁 EventBridge	-	08/14/2024 07:59:08 AM	rwxr-xr-x
📁 Exception	-	08/14/2024 07:59:08 AM	rwxr-xr-x
📄 FunctionsTest.php	14.33 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Glacier	-	08/14/2024 07:59:09 AM	rwxr-xr-x
📁 Handler	-	08/14/2024 08:01:06 AM	rwxr-xr-x
📄 HandlerListTest.php	7.16 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 HasMonitoringEventsTraitTest.php	895 bytes	08/14/2024 07:57:52 AM	rw-r--r--
📄 HashingStreamTest.php	1.41 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 HistoryTest.php	4.2 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 IdempotencyTokenMiddlewareTest.php	2.76 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Identity	-	08/14/2024 08:01:07 AM	rwxr-xr-x
📄 InputValidationMiddlewareTest.php	5.62 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Integ	-	08/14/2024 07:59:09 AM	rwxr-xr-x
📄 JsonCompilerTest.php	730 bytes	08/14/2024 07:57:52 AM	rw-r--r--
📁 Lambda	-	08/14/2024 07:59:09 AM	rwxr-xr-x
📁 LexModelsV2	-	08/14/2024 07:59:09 AM	rwxr-xr-x
📄 LruArrayCacheTest.php	1.59 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 MachineLearning	-	08/14/2024 07:59:10 AM	rwxr-xr-x
📄 MiddlewareTest.php	16.08 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 MockHandlerTest.php	3.79 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 MultiRegionClientTest.php	5.41 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Multipart	-	08/14/2024 07:59:10 AM	rwxr-xr-x
📁 Neptune	-	08/14/2024 07:59:10 AM	rwxr-xr-x
📄 PerformanceContext.php	8.2 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 PhpHashTest.php	1.33 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Polly	-	08/14/2024 07:59:10 AM	rwxr-xr-x
📄 PresignUrlMiddlewareTest.php	3.95 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 Psr16CacheAdapterTest.php	1.84 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 PsrCacheAdapterTest.php	2.64 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 QueryCompatibleInputMiddlewareTest.php	9.1 KB	08/14/2024 07:57:52 AM	rw-r--r--
📁 Rds	-	08/14/2024 07:59:10 AM	rwxr-xr-x
📁 RequestCompression	-	08/14/2024 08:01:07 AM	rwxr-xr-x
📄 ResultPaginatorTest.php	16.21 KB	08/14/2024 07:57:52 AM	rw-r--r--
📄 ResultTest.php	1.38 KB	08/14/2024 07:57:53 AM	rw-r--r--
📁 Retry	-	08/14/2024 07:59:11 AM	rwxr-xr-x
📄 RetryMiddlewareTest.php	24.57 KB	08/14/2024 07:57:53 AM	rw-r--r--
📄 RetryMiddlewareV2Test.php	40.33 KB	08/14/2024 07:57:53 AM	rw-r--r--
📁 Route53	-	08/14/2024 07:59:11 AM	rwxr-xr-x
📁 S3	-	08/14/2024 08:08:07 AM	rwxr-xr-x
📁 S3Control	-	08/14/2024 07:59:12 AM	rwxr-xr-x
📁 Script	-	08/14/2024 07:59:12 AM	rwxr-xr-x
📄 SdkTest.php	2.37 KB	08/14/2024 07:57:53 AM	rw-r--r--
📁 Ses	-	08/14/2024 07:59:12 AM	rwxr-xr-x
📁 Signature	-	08/14/2024 07:59:13 AM	rwxr-xr-x
📁 Sqs	-	08/14/2024 07:59:13 AM	rwxr-xr-x
📁 Ssm	-	08/14/2024 07:59:13 AM	rwxr-xr-x
📄 StreamRequestPayloadMiddlewareTest.php	10.1 KB	08/14/2024 07:57:53 AM	rw-r--r--
📁 Sts	-	08/14/2024 08:01:08 AM	rwxr-xr-x
📄 TestServiceTrait.php	3.78 KB	08/14/2024 07:57:53 AM	rw-r--r--
📁 Token	-	08/14/2024 07:59:13 AM	rwxr-xr-x
📄 TraceMiddlewareTest.php	16.16 KB	08/14/2024 07:57:53 AM	rw-r--r--
📄 UsesServiceTrait.php	4.37 KB	08/14/2024 07:57:53 AM	rw-r--r--
📄 WaiterTest.php	12.63 KB	08/14/2024 07:57:53 AM	rw-r--r--
📄 WrappedHttpHandlerTest.php	13.8 KB	08/14/2024 07:57:53 AM	rw-r--r--
📁 bootstrap	-	08/14/2024 07:59:04 AM	rwxr-xr-x
📄 bootstrap.php	1.53 KB	08/14/2024 07:57:51 AM	rw-r--r--
📁 fixtures	-	08/14/2024 08:08:07 AM	rwxr-xr-x
📁 static	-	08/14/2024 07:59:13 AM	rwxr-xr-x

Editing: RetryMiddlewareTest.php

<?php
namespace Aws\Test;

use Aws\Command;
use Aws\CommandInterface;
use Aws\Exception\AwsException;
use Aws\MockHandler;
use Aws\Result;
use Aws\ResultInterface;
use Aws\RetryMiddleware;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Promise\RejectedPromise;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;
use Psr\Http\Message\RequestInterface;
use Yoast\PHPUnitPolyfills\TestCases\TestCase;

/**
 * @covers Aws\RetryMiddleware
 */
class RetryMiddlewareTest extends TestCase
{
    public function testAddRetryHeader()
    {
        $nextHandler = function (CommandInterface $command, RequestInterface $request) {
            $this->assertTrue($request->hasHeader('aws-sdk-retry'));
            return new RejectedPromise(
                new AwsException('e', $command, ['connection_error' => true])
            );
        };
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            [RetryMiddleware::class, 'exponentialDelay'],
            $nextHandler,
            true
        );

try {
            $retryMW(new Command('SomeCommand'), new Request('GET', ''))->wait();
            $this->fail();
        } catch (AwsException $e) { }
    }

public function testDeciderRetriesWhenStatusCodeMatches()
    {
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $result = new Result(['@metadata' => ['statusCode' => '500']]);
        $this->assertTrue($decider(0, $command, $request, $result, null));
        $result = new Result(['@metadata' => ['statusCode' => '503']]);
        $this->assertTrue($decider(0, $command, $request, $result, null));
    }

public function testDeciderRetriesWhenConnectionError()
    {
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $err = new AwsException('e', $command, ['connection_error' => true]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, ['connection_error' => false]);
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function testDeciderIgnoresNonAwsExceptions()
    {
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $err = new \Exception('e');
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function testDeciderIgnoresPHPError()
    {
        if (interface_exists('Throwable', false)) {
            $decider = RetryMiddleware::createDefaultDecider();
            $command = new Command('foo');
            $request = new Request('GET', 'http://www.example.com');
            $err = new \Error('e');
            $this->assertFalse($decider(0, $command, $request, null, $err));
        }
    }

public function testDeciderRetriesWhenCurlErrorCodeMatches()
    {
        if (!extension_loaded('curl')) {
            $this->markTestSkipped('Test skipped on no cURL extension');
        }
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $version = \Aws\guzzle_major_version();
        if ($version === 6 || $version === 7) {
            $previous = new RequestException(
                'test',
                $request,
                null,
                null,
                ['errno' => CURLE_RECV_ERROR]
            );
        } elseif ($version === 5) {
            $previous = new RequestException(
                'cURL error ' . CURLE_RECV_ERROR . ': test',
                new \GuzzleHttp\Message\Request('GET', 'http://www.example.com')
            );
        }
        $err = new AwsException(
            'e',
            $command,
            ['connection_error' => false],
            $previous
        );
        $this->assertTrue($decider(0, $command, $request, null, $err));
    }

public function testDeciderRetriesForCustomCurlErrors()
    {
        if (!extension_loaded('curl')) {
            $this->markTestSkipped('Test skipped on no cURL extension');
        }
        $decider = RetryMiddleware::createDefaultDecider(
            3,
            ['curl_errors' => [CURLE_BAD_CONTENT_ENCODING]]
        );
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $version = \Aws\guzzle_major_version();

// Custom error passed in to decider config should result in a retry
        if ($version === 6 || $version === 7) {
            $previous = new RequestException(
                'test',
                $request,
                null,
                null,
                ['errno' => CURLE_BAD_CONTENT_ENCODING]
            );
        } elseif ($version === 5) {
            $previous = new RequestException(
                'cURL error ' . CURLE_BAD_CONTENT_ENCODING . ': test',
                new \GuzzleHttp\Message\Request('GET', 'http://www.example.com')
            );
        }
        $err = new AwsException(
            'e',
            $command,
            ['connection_error' => false],
            $previous
        );
        $this->assertTrue($decider(0, $command, $request, null, $err));

// Error not passed in to decider config should result in no retry
        if ($version === 6 || $version === 7) {
            $previous = new RequestException(
                'test',
                $request,
                null,
                null,
                ['errno' => CURLE_ABORTED_BY_CALLBACK]
            );
        } elseif ($version === 5) {
            $previous = new RequestException(
                'cURL error ' . CURLE_ABORTED_BY_CALLBACK . ': test',
                new \GuzzleHttp\Message\Request('GET', 'http://www.example.com')
            );
        }
        $err = new AwsException(
            'e',
            $command,
            ['connection_error' => false],
            $previous
        );
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function awsErrorCodeProvider()
    {
        $command = new Command('foo');
        return [
            [new AwsException('e', $command, ['code' => 'RequestLimitExceeded'])],
            [new AwsException('e', $command, ['code' => 'Throttling'])],
            [new AwsException('e', $command, ['code' => 'ThrottlingException'])],
            [new AwsException('e', $command, ['code' => 'ProvisionedThroughputExceededException'])],
            [new AwsException('e', $command, ['code' => 'RequestThrottled'])],
            [new AwsException('e', $command, ['code' => 'BandwidthLimitExceeded'])],
            [new AwsException('e', $command, ['code' => 'RequestThrottledException'])],
            [new AwsException('e', $command, ['code' => 'TooManyRequestsException'])],
            [new AwsException('e', $command, ['code' => 'IDPCommunicationError'])],
            [new AwsException('e', $command, ['code' => 'EC2ThrottledException'])],
        ];
    }
    /**
    * @param $err
    *
    * @dataProvider awsErrorCodeProvider
    */
    public function testDeciderRetriesWhenAwsErrorCodeMatches($err)
    {
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');

$this->assertTrue($decider(0, $command, $request, null, $err));
    }

public function testDeciderRetriesWhenExceptionStatusCodeMatches()
    {
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $err = new AwsException('e', $command, ['response' => new Response(500)]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, ['response' => new Response(502)]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, ['response' => new Response(503)]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, ['response' => new Response(504)]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, ['response' => new Response(403)]);
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function testDeciderRetriesForCustomErrorCodes()
    {
        $decider = RetryMiddleware::createDefaultDecider(
            3,
            ['error_codes' => ['CustomRetryableException']]
        );
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $err = new AwsException('e', $command, [
            'code' => 'CustomRetryableException'
        ]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, [
            'code' => 'CustomNonRetryableException'
        ]);
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function testDeciderRetriesForCustomStatusCodes()
    {
        $decider = RetryMiddleware::createDefaultDecider(
            3,
            ['status_codes' => [400]]
        );
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $err = new AwsException('e', $command, ['response' => new Response(400)]);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $err = new AwsException('e', $command, ['response' => new Response(401)]);
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function testDeciderDoesNotRetryAfterMaxAttempts()
    {
        $decider = RetryMiddleware::createDefaultDecider();
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $err = new AwsException('e', $command, ['code' => 'RequestLimitExceeded']);
        $this->assertTrue($decider(0, $command, $request, null, $err));
        $this->assertFalse($decider(3, $command, $request, null, $err));
    }

public function testDelaysExponentially()
    {
        $this->assertLessThanOrEqual(100, RetryMiddleware::exponentialDelay(0));
        $this->assertLessThanOrEqual(200, RetryMiddleware::exponentialDelay(1));
        $this->assertLessThanOrEqual(400, RetryMiddleware::exponentialDelay(2));
        $this->assertLessThanOrEqual(800, RetryMiddleware::exponentialDelay(3));
        $this->assertLessThanOrEqual(20000, RetryMiddleware::exponentialDelay(10));
    }

public function testDelaysWithSomeRandomness()
    {
        $maxDelay = 100 * pow(2, 5);
        $values = array_map(function () {
            return RetryMiddleware::exponentialDelay(5);
        }, range(1, 200));

$this->assertGreaterThan(1, count(array_unique($values)));
        foreach ($values as $value) {
            $this->assertGreaterThanOrEqual(0, $value);
            $this->assertLessThanOrEqual($maxDelay, $value);
        }
    }

public function testRetriesWhenResultMatches()
    {
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $res1 = new Result(['@metadata' => ['statusCode' => '503']]);
        $res2 = new Result(['@metadata' => ['statusCode' => '200']]);
        $mock = new MockHandler(
            [
                function ($command, $request) use ($res1) {
                    $this->assertArrayNotHasKey('delay', $command['@http']);
                    return $res1;
                },
                function ($command, $request) use ($res2) {
                    $this->assertLessThanOrEqual(100, $command['@http']['delay']);
                    return $res2;
                },
            ],
            function () use (&$called) { $called[] = func_get_args(); }
        );

$wrapped = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider(),
            [RetryMiddleware::class, 'exponentialDelay'],
            $mock
        );

$result = $wrapped($command, $request)->wait();
        $this->assertSame($res2, $result);
        $this->assertCount(2, $called);
        $this->assertSame([$res1], $called[0]);
        $this->assertSame([$res2], $called[1]);
    }

public function testRetriesWhenExceptionMatches()
    {
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $mock = new MockHandler(
            [
                function ($command, $request) {
                    $this->assertArrayNotHasKey('delay', $command['@http']);
                    return new AwsException('foo', $command, [
                        'connection_error' => true
                    ]);
                },
                function ($command, $request) {
                    $this->assertLessThanOrEqual(100, $command['@http']['delay']);
                    return new Result();
                },
            ],
            function () use (&$called) { $called[] = func_get_args(); },
            function () use (&$called) { $called[] = func_get_args(); }
        );

$wrapped = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider(),
            [RetryMiddleware::class, 'exponentialDelay'],
            $mock
        );

$result = $wrapped($command, $request)->wait();
        $this->assertInstanceOf(ResultInterface::class, $result);
        $this->assertCount(2, $called);
        $this->assertInstanceOf(AwsException::class, $called[0][0]);
        $this->assertInstanceOf(ResultInterface::class, $called[1][0]);
    }

public function testForwardRejectionWhenExceptionDoesNotMatch()
    {
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $mock = new MockHandler(
            [
                function ($command, $request) {
                    $this->assertArrayNotHasKey('delay', $command['@http']);
                    return new AwsException('foo', $command);
                }
            ],
            function () use (&$called) { $called[] = func_get_args(); },
            function () use (&$called) { $called[] = func_get_args(); }
        );

$wrapped = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider(),
            [RetryMiddleware::class, 'exponentialDelay'],
            $mock
        );

try {
            $wrapped($command, $request)->wait();
            $this->fail();
        } catch (AwsException $e) {
            $this->assertCount(1, $called);
            $this->assertStringContainsString('foo', $e->getMessage());
        }
    }

public function testForwardValueWhenResultDoesNotMatch()
    {
        $command = new Command('foo');
        $request = new Request('GET', 'http://www.example.com');
        $res1 = new Result();
        $mock = new MockHandler(
            [$res1],
            function () use (&$called) { $called[] = func_get_args(); },
            function () use (&$called) { $called[] = func_get_args(); }
        );

$wrapped = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider(),
            [RetryMiddleware::class, 'exponentialDelay'],
            $mock
        );

$result = $wrapped($command, $request)->wait();
        $this->assertSame($res1, $result);
        $this->assertCount(1, $called);
    }

public function testRetriesCanBeDisabledOnACommand()
    {
        $decider = RetryMiddleware::createDefaultDecider($retries = 3);
        $command = new Command('foo', ['@retries' => 0]);
        $request = new Request('GET', 'http://www.example.com');
        $err = new AwsException('e', $command, ['connection_error' => true]);
        $this->assertFalse($decider(0, $command, $request, null, $err));
    }

public function testResultReportsTheNumberOfRetries()
    {
        $handler = new MockHandler([
            new Result(['@metadata' => ['statusCode' => '503']]),
            new Result(['@metadata' => ['statusCode' => '503']]),
            new Result(['@metadata' => ['statusCode' => '200']]),
        ]);
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            [RetryMiddleware::class, 'exponentialDelay'],
            $handler,
            true
        );

$result = $retryMW(new Command('SomeCommand'), new Request('GET', ''))
            ->wait();
        $this->assertArrayHasKey('retries_attempted', $result['@metadata']['transferStats']);
        $this->assertSame(2, $result['@metadata']['transferStats']['retries_attempted']);
    }

public function testExceptionReportsTheNumberOfRetries()
    {
        $nextHandler = function (CommandInterface $command) {
            return new RejectedPromise(
                new AwsException('e', $command, ['connection_error' => true])
            );
        };
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            [RetryMiddleware::class, 'exponentialDelay'],
            $nextHandler,
            true
        );

try {
            $retryMW(new Command('SomeCommand'), new Request('GET', ''))->wait();
            $this->fail();
        } catch (AwsException $e) {
            $this->assertSame(3, $e->getTransferInfo('retries_attempted'));
        }
    }

public function testResultReportsTotalRetryDelay()
    {
        $handler = new MockHandler([
            new Result(['@metadata' => ['statusCode' => '503']]),
            new Result(['@metadata' => ['statusCode' => '503']]),
            new Result(['@metadata' => ['statusCode' => '200']]),
        ]);
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            function () { return 100; },
            $handler,
            true
        );

$result = $retryMW(new Command('SomeCommand'), new Request('GET', ''))
            ->wait();
        $this->assertArrayHasKey('total_retry_delay', $result['@metadata']['transferStats']);
        $this->assertSame(200, $result['@metadata']['transferStats']['total_retry_delay']);
    }

public function testExceptionReportsTotalRetryDelay()
    {
        $nextHandler = function (CommandInterface $command) {
            return new RejectedPromise(
                new AwsException('e', $command, ['connection_error' => true])
            );
        };
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            function () { return 100; },
            $nextHandler,
            true
        );

try {
            $retryMW(new Command('SomeCommand'), new Request('GET', ''))->wait();
            $this->fail();
        } catch (AwsException $e) {
            $this->assertSame(300, $e->getTransferInfo('total_retry_delay'));
        }
    }

public function testReportsHttpStatsForEachRequest()
    {
        $handler = new MockHandler([
            new Result(['@metadata' => [
                'statusCode' => '503',
                'transferStats' => ['http' => [['foo' => 'bar']]]
            ]]),
            new Result(['@metadata' => [
                'statusCode' => '503',
                'transferStats' => ['http' => [['baz' => 'quux']]]
            ]]),
            new Result(['@metadata' => [
                'statusCode' => '200',
                'transferStats' => ['http' => [['fizz' => 'buzz']]]
            ]]),
        ]);
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            [RetryMiddleware::class, 'exponentialDelay'],
            $handler,
            true
        );

$result = $retryMW(new Command('SomeCommand'), new Request('GET', ''))
            ->wait();
        $httpStats = $result['@metadata']['transferStats']['http'];
        $this->assertCount(3, $httpStats);
        $this->assertSame([
            ['foo' => 'bar'],
            ['baz' => 'quux'],
            ['fizz' => 'buzz'],
        ], $httpStats);
    }

public function testReportsHttpStatsForEachException()
    {
        $command = new Command('TestCommand');
        $response = new Response(500);

$handler = new MockHandler([
            new AwsException(
                'Test Exception',
                $command,
                [
                    'response' => $response,
                    'transfer_stats' => [
                        'starttransfer_time' => 5,
                        'appconnect_time' => 4
                    ]
                ]
            ),
            new AwsException(
                'Test Exception',
                $command,
                [
                    'response' => $response,
                    'transfer_stats' => [
                        'starttransfer_time' => 10,
                        'appconnect_time' => 8
                    ]
                ]
            ),
            new AwsException(
                'Test Exception',
                $command,
                [
                    'response' => $response,
                    'transfer_stats' => [
                        'starttransfer_time' => 15,
                        'appconnect_time' => 12
                    ]
                ]
            ),
            new AwsException(
                'Test Exception',
                $command,
                [
                    'response' => $response,
                    'transfer_stats' => [
                        'starttransfer_time' => 20,
                        'appconnect_time' => 16
                    ]
                ]
            )
        ]);
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            [RetryMiddleware::class, 'exponentialDelay'],
            $handler,
            true
        );

try {
            $retryMW(new Command('SomeCommand'), new Request('GET', ''))
                ->wait();
            $this->fail('This command should have produced an AwsException.');
        } catch (AwsException $e) {
            $stats= $e->getTransferInfo();
            $this->assertEquals(
                [
                    [
                        'starttransfer_time' => 5,
                        'appconnect_time' => 4
                    ],
                    [
                        'starttransfer_time' => 10,
                        'appconnect_time' => 8
                    ],
                    [
                        'starttransfer_time' => 15,
                        'appconnect_time' => 12
                    ],
                    [
                        'starttransfer_time' => 20,
                        'appconnect_time' => 16
                    ],
                ],
                $stats['http']
            );
        }
    }

public function testReportsHttpStatsForEachRequestEvenIfRetryStatsDisabled()
    {
        $handler = new MockHandler([
            new Result(['@metadata' => [
                'statusCode' => '503',
                'transferStats' => ['http' => [['foo' => 'bar']]]
            ]]),
            new Result(['@metadata' => [
                'statusCode' => '503',
                'transferStats' => ['http' => [['baz' => 'quux']]]
            ]]),
            new Result(['@metadata' => [
                'statusCode' => '200',
                'transferStats' => ['http' => [['fizz' => 'buzz']]]
            ]]),
        ]);
        $retryMW = new RetryMiddleware(
            RetryMiddleware::createDefaultDecider($retries = 3),
            [RetryMiddleware::class, 'exponentialDelay'],
            $handler,
            false
        );