PHP Middleware::history方法代码示例

 public function testSend()
 {
     $container = [];
     $history = Middleware::history($container);
     $mockResponseData = json_encode(['ok' => true, 'foo' => 'bar']);
     $mock = new MockHandler([new Response(200, [], $mockResponseData)]);
     $stack = HandlerStack::create($mock);
     $stack->push($history);
     $client = new Client(['handler' => $stack]);
     $mockPayload = new MockPayload();
     $foo = 'who:(search+query+OR+other+search+query)';
     $mockPayload->setFoo($foo);
     $apiClient = new ApiClient(self::API_KEY, $client);
     $payloadResponse = $apiClient->send($mockPayload);
     $transaction = array_pop($container);
     // Assert response is of type MockPayloadResponse
     $this->assertInstanceOf('Colada\\Europeana\\Tests\\Test\\Payload\\MockPayloadResponse', $payloadResponse);
     // Assert if the responses match up.
     $transaction['response']->getBody();
     $this->assertEquals($mockResponseData, $transaction['response']->getBody());
     // Assert if the URL is unfuddled.
     $expectedRequestUri = sprintf('http://europeana.eu/api/v2/mock.json?foo=%s&wskey=%s', $foo, self::API_KEY);
     $requestUri = $transaction['request']->getUri();
     $this->assertEquals($expectedRequestUri, $requestUri);
 }

 /**
  * @covers ::send
  * @covers ::buildRequest
  * @covers ::getGzippedBody
  * @covers ::getAuthorization
  */
 public function testSend()
 {
     $container = array();
     $history = Middleware::history($container);
     $mockHandler = new MockHandler(array(new Response(200, array(), 'Everything OK')));
     $stack = HandlerStack::create($mockHandler);
     $stack->push($history);
     // $stack->push($mockHandler);
     $http = new GuzzleAdapter(new GuzzleClient(array('handler' => $stack)));
     $client = new Client('aaaaa', 'bbbbb', $http);
     $message = new Message('http://www.example.com/', $client);
     $message->set('foo', 'bar');
     // Call send() and ensure the right response was returned (which we set up above)
     $response = $message->send();
     $this->assertEquals(200, $response->getStatusCode());
     $this->assertEquals('Everything OK', $response->getBody());
     // Ensure the request has everything that should be there
     $this->assertCount(1, $container);
     $request = $container[0]['request'];
     $this->assertEquals('POST', $request->getMethod());
     $this->assertEquals('http://www.example.com/', (string) $request->getUri());
     $this->assertEquals('gzip', $request->getHeaderLine('Content-Encoding'));
     $this->assertEquals('application/json', $request->getHeaderLine('Content-Type'));
     $this->assertEquals('2Isi0VhuV8oniANJzAZVBEZ3DSAKmP0hQrVh3jbUNaQ=', $request->getHeaderLine('Authorization'));
     $this->assertEquals('H4sIAAAAAAAAA6tWSsvPV7JSSkosUqoFAO/1K/4NAAAA', base64_encode((string) $request->getBody()));
 }

 public function __construct($email, $password, SessionStorageInterface $sessionStorage = null, $env = 'prod', $debug = false)
 {
     if (!in_array($env, ['test', 'prod'], true)) {
         throw new InvalidArgumentException("Environment must be one of: prod, test");
     }
     if (null === $sessionStorage) {
         if (php_sapi_name() == "cli") {
             $sessionStorage = new MemorySessionStorage();
         } else {
             $sessionStorage = new NativeSessionStorage();
         }
     }
     $this->sessionStorage = $sessionStorage;
     $this->email = $email;
     $this->password = $password;
     $params = ['base_uri' => $this->{$env . 'Url'}];
     if ($debug) {
         $this->transactionHistory = [];
         $history = Middleware::history($this->transactionHistory);
         $stack = HandlerStack::create();
         $stack->push($history);
         $params['handler'] = $stack;
     }
     $this->client = new Client($params);
 }

 public function testBasicClient()
 {
     $mock = new MockHandler([new Response(200, ['X-Foo' => 'Bar'], "{\"foo\":\"bar\"}")]);
     $container = [];
     $history = Middleware::history($container);
     $stack = HandlerStack::create($mock);
     $stack->push($history);
     $http_client = new Client(['handler' => $stack]);
     $client = new BuuyersClient('u', 'p');
     $client->setClient($http_client);
     $client->companies->getCompany(1);
     foreach ($container as $transaction) {
         $basic = $transaction['request']->getHeaders()['Authorization'][0];
         $this->assertTrue($basic == "Basic dTpw");
         $method = $transaction['request']->getMethod();
         $this->assertEquals($method, 'GET');
         //> GET
         if ($transaction['response']) {
             $statusCode = $transaction['response']->getStatusCode();
             $this->assertEquals(200, $statusCode);
             //> 200, 200
         } elseif ($transaction['error']) {
             echo $transaction['error'];
             //> exception
         }
     }
 }

 /**
  * Test validation of Cas tickets.
  *
  * @covers ::__construct
  * @covers ::validateTicket
  * @covers ::validateVersion1
  * @covers ::validateVersion2
  * @covers ::verifyProxyChain
  * @covers ::parseAllowedProxyChains
  * @covers ::parseServerProxyChain
  *
  * @dataProvider validateTicketDataProvider
  */
 public function testValidateTicket($version, $ticket, $username, $response, $is_proxy, $can_be_proxied, $proxy_chains, $ssl_verification)
 {
     $mock = new MockHandler([new Response(200, array(), $response)]);
     $handler = HandlerStack::create($mock);
     $container = [];
     $history = Middleware::history($container);
     $handler->push($history);
     $httpClient = new Client(['handler' => $handler]);
     $casHelper = $this->getMockBuilder('\\Drupal\\cas\\Service\\CasHelper')->disableOriginalConstructor()->getMock();
     $casValidator = new CasValidator($httpClient, $casHelper);
     $casHelper->expects($this->any())->method('getCasProtocolVersion')->will($this->returnValue($version));
     $casHelper->expects($this->once())->method('getSslVerificationMethod')->willReturn($ssl_verification);
     $casHelper->expects($this->any())->method('getCertificateAuthorityPem')->will($this->returnValue('foo'));
     $casHelper->expects($this->any())->method('isProxy')->will($this->returnValue($is_proxy));
     $casHelper->expects($this->any())->method('canBeProxied')->will($this->returnValue($can_be_proxied));
     $casHelper->expects($this->any())->method('getProxyChains')->will($this->returnValue($proxy_chains));
     $property_bag = $casValidator->validateTicket($version, $ticket, array());
     // Test that we sent the correct ssl option to the http client.
     foreach ($container as $transaction) {
         switch ($ssl_verification) {
             case CasHelper::CA_CUSTOM:
                 $this->assertEquals('foo', $transaction['options']['verify']);
                 break;
             case CasHelper::CA_NONE:
                 $this->assertEquals(FALSE, $transaction['options']['verify']);
                 break;
             default:
                 $this->assertEquals(TRUE, $transaction['options']['verify']);
         }
     }
     $this->assertEquals($username, $property_bag->getUsername());
 }

 public function testSend()
 {
     $self = $this;
     $mockRequestData = ['foo' => 'bar', 'token' => self::TOKEN];
     $mockResponseData = ['ok' => true, 'foo' => 'bar'];
     $handler = HandlerStack::create(new MockHandler([new Response(200, [], json_encode($mockResponseData))]));
     $historyContainer = [];
     $history = Middleware::history($historyContainer);
     $handler->push($history);
     $apiClient = new ApiClient(self::TOKEN, new Client(['handler' => $handler]));
     $apiClient->addRequestListener(function (RequestEvent $event) use(&$eventsDispatched, $mockRequestData, $self) {
         $eventsDispatched[ApiClient::EVENT_REQUEST] = true;
         $self->assertEquals($mockRequestData, $event->getRawPayload());
     });
     $apiClient->addResponseListener(function (ResponseEvent $event) use(&$eventsDispatched, $mockResponseData, $self) {
         $eventsDispatched[ApiClient::EVENT_RESPONSE] = true;
         $self->assertEquals($mockResponseData, $event->getRawPayloadResponse());
     });
     $mockPayload = new MockPayload();
     $mockPayload->setFoo('bar');
     $apiClient->send($mockPayload);
     $transaction = $historyContainer[0];
     $requestUrl = (string) $transaction['request']->getUri();
     $requestContentType = $transaction['request']->getHeader('content-type')[0];
     parse_str($transaction['request']->getBody(), $requestBody);
     $responseBody = json_decode($transaction['response']->getBody(), true);
     $this->assertEquals(ApiClient::API_BASE_URL . 'mock', $requestUrl);
     $this->assertEquals('application/x-www-form-urlencoded', $requestContentType);
     $this->assertEquals($mockRequestData, $requestBody);
     $this->assertEquals($mockResponseData, $responseBody);
     $this->assertArrayHasKey(ApiClient::EVENT_REQUEST, $eventsDispatched);
     $this->assertArrayHasKey(ApiClient::EVENT_RESPONSE, $eventsDispatched);
 }

 /**
  * Get the client for making calls
  *
  * @return Client
  */
 public function getHttpClient()
 {
     if ($this->client == null) {
         $handler = HandlerStack::create();
         if ($this->mode == 'record') {
             $history = Middleware::history($this->callList);
             $handler->push($history);
         } elseif ($this->mode == 'playback') {
             $recordings = $this->getRecordings();
             $playList = $recordings;
             $mockedResponses = [];
             foreach ($playList as $item) {
                 $mockedResponses[] = new Response($item['statusCode'], $item['headers'], $item['body']);
             }
             $mockHandler = new MockHandler($mockedResponses);
             $handler = HandlerStack::create($mockHandler);
         }
         $this->client = new Client(['handler' => $handler]);
         if (!$this->shutdownRegistered) {
             register_shutdown_function(array($this, 'endRecord'));
             $this->shutdownRegistered = true;
         }
     }
     return $this->client;
 }

 public function testDetailArray()
 {
     $mock = new MockHandler([new Response(200, ['Content-Type' => 'application/json'], '{
                 "id": "main",
                 "authorizedFor": "Myself",
                 "creator": {
                     "id": "1234",
                     "description": "me@keboola.com"
                 },
                 "created": "2016-01-31 00:13:30",
                 "#data": "KBC::ComponentProjectEncrypted==F2LdyHQB45lJHtf",
                 "oauthVersion": "2.0",
                 "appKey": "1234",
                 "#appSecret": "KBC::ComponentEncrypted==/5fEM59+3+59+5+"
             }')]);
     // Add the history middleware to the handler stack.
     $container = [];
     $history = Middleware::history($container);
     $stack = HandlerStack::create($mock);
     $stack->push($history);
     $cred = new Credentials('some-token', ['handler' => $stack, 'url' => 'https://syrup.keboola.com/oauth-v2/']);
     $cred->enableReturnArrays(true);
     $result = $cred->getDetail('wr-dropbox', 'credentials-id');
     $this->assertInternalType('array', $result);
     $this->assertCount(8, $result);
     $this->assertArrayHasKey('#data', $result);
     $this->assertArrayHasKey('#appSecret', $result);
     /** @var Request $request */
     $request = $container[0]['request'];
     $this->assertEquals("https://syrup.keboola.com/oauth-v2/credentials/wr-dropbox/credentials-id", $request->getUri()->__toString());
     $this->assertEquals("GET", $request->getMethod());
     $this->assertEquals("some-token", $request->getHeader("x-storageapi-token")[0]);
 }

 /**
  * Get Guzzle with mock response and request history stored in container
  *
  * @param array $container
  * @param Response[] $responses
  * @return Client
  */
 public function getMockHttpClientWithHistoryAndResponses(&$container, $responses)
 {
     $mock = new MockHandler($responses);
     $stack = HandlerStack::create($mock);
     $history = Middleware::history($container);
     $stack->push($history);
     return new Client(['handler' => $stack]);
 }

 /**
  * @param null|string $response
  * @return GuzzleClient
  * @see ClientTest::getGuzzle()
  * @link https://github.com/FriendsOfPHP/Goutte/blob/master/Goutte/Tests/ClientTest.php
  */
 protected function getGuzzle($response)
 {
     $handlerStack = HandlerStack::create(new MockHandler([new GuzzleResponse(200, [], $response)]));
     $history = [];
     $handlerStack->push(Middleware::history($history));
     $guzzle = new GuzzleClient(['redirect.disable' => true, 'base_uri' => '', 'handler' => $handlerStack]);
     return $guzzle;
 }

 public static function buildMockedClient(array &$container, array $responses)
 {
     $history = Middleware::history($container);
     $mock = new MockHandler($responses);
     $handler = HandlerStack::create($mock);
     $handler->push($history);
     return new Client(['handler' => $handler]);
 }

 public function setUp()
 {
     $this->context = new Context(['keys' => ['pda' => 'secret'], 'algorithm' => 'hmac-sha256', 'headers' => ['(request-target)', 'date']]);
     $stack = new HandlerStack();
     $stack->setHandler(new MockHandler([new Response(200, ['Content-Length' => 0])]));
     $stack->push(GuzzleHttpSignatures::middlewareFromContext($this->context));
     $stack->push(Middleware::history($this->history));
     $this->client = new Client(['handler' => $stack]);
 }

 public static function setUpBeforeClass()
 {
     $mock = new MockHandler([new Response(200, [], "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><CityResponse>    <ResultCount>618</ResultCount>    <Cities>        <City>            <RcAbbreviation>PINEHURST</RcAbbreviation>            <Name>ABERDEEN</Name>        </City>        <City>            <RcAbbreviation>JULIAN</RcAbbreviation>            <Name>ADVANCE</Name>        </City>    </Cities></CityResponse>"), new Response(200, [], "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><RateCenters>    <ResultCount>652</ResultCount>    <RateCenters>        <RateCenter>            <Abbreviation>AGOURA</Abbreviation>            <Name>AGOURA</Name>        </RateCenter>        <RateCenter>            <Abbreviation>ALAMITOS</Abbreviation>            <Name>ALAMITOS</Name>        </RateCenter>    </RateCenters></RateCenters>")]);
     self::$container = [];
     $history = Middleware::history(self::$container);
     $handler = HandlerStack::create($mock);
     $handler->push($history);
     self::$client = new Iris\Client("test", "test", array('url' => 'https://api.test.inetwork.com/v1.0', 'handler' => $handler));
 }

 protected function setUp()
 {
     $mock = new MockHandler([new Response(200, ["X-Foo" => "Bar"], "It worked!")]);
     $stack = HandlerStack::create($mock);
     $history = Middleware::history($this->container);
     $stack->push($history);
     $client = new Client(["handler" => $stack]);
     $this->object = new GuzzleTransport($client);
 }

 /**
  * @before
  */
 public function initClient()
 {
     $this->requests = [];
     $stack = HandlerStack::create();
     $stack->push(Middleware::history($this->requests));
     $this->client = new Client(['handler' => $stack]);
     $this->api = new Mailchimp($this->client, getenv('MAILCHIMP_API_KEY'));
     $this->faker = Factory::create();
 }