PHP Client::expects方法代码示例

 /**
  * Tests retrieving a dog
  */
 public function testFetchDog()
 {
     // init vars
     $apiKey = 'this-is-another-api-key';
     // request expectations
     $tag = GiphyProvider::TYPE_DOG;
     $request = ['query' => ['api_key' => $apiKey, 'tag' => $tag]];
     // response expectations
     $id = 23457;
     $imageUrl = 'this-is-another-test-image-url';
     $imageWidth = 200;
     $imageHeight = 400;
     $response = new ResponseFake();
     $response->setBody(['data' => ['id' => $id, 'image_url' => $imageUrl, 'image_width' => $imageWidth, 'image_height' => $imageHeight]]);
     // init client
     $this->client->expects($this->any())->method('get')->with($this->anything(), $this->equalTo($request))->will($this->returnValue($response));
     // get the cat
     $provider = new GiphyProvider($this->client, $apiKey);
     $animal = $provider->fetchDog();
     // assert an animal with expected data is returned
     $this->assertInstanceOf('TimeInc\\CatsVsDogsBundle\\Document\\Dog', $animal);
     $this->assertEquals($id, $animal->getId());
     $this->assertEquals($imageUrl, $animal->getImageSrc());
     $this->assertEquals($imageWidth, $animal->getWidth());
     $this->assertEquals($imageHeight, $animal->getHeight());
 }

 /**
  * @test
  */
 public function canRemoveAValidCore()
 {
     $core = new Core('testcore', 'typo3', 'english', '4.8', 1);
     $responseMock = $this->getMock(Response::class, array('getBody', 'getStatusCode'), array(), '', false);
     $responseMock->expects($this->any())->method('getStatusCode')->will($this->returnValue(204));
     $expectedDeleteEndpoint = 'https://myendpoint.com/api/solr_cores/1.json?api_token=foo&secret_token=bar';
     $this->httpClientMock->expects($this->once())->method('delete')->with($expectedDeleteEndpoint)->will($this->returnValue($responseMock));
     $result = $this->coreRestStorageBackend->remove($core);
     $this->assertTrue($result);
 }

 public function testSendCachedWithCacheReturnsCache()
 {
     $cacheKey = 'CACHE_KEY';
     $body = 'BODY';
     $this->cachedRequestMock->expects($this->any())->method('getCacheKey')->willReturn($cacheKey);
     $this->cachedRequestMock->expects($this->never())->method('getCacheFor');
     $this->guzzleClientMock->expects($this->never())->method('send');
     $this->memcacheMock->expects($this->once())->method('get')->with($cacheKey)->willReturn($body);
     $this->memcacheMock->expects($this->never())->method('set');
     $client = new ClientCached($this->guzzleClientMock, $this->memcacheMock);
     $this->assertSame($body, $client->sendCached($this->cachedRequestMock));
 }

 public function testSendPostRequestReturnsZboziApiResponse()
 {
     $this->loggerMock->expects(self::once())->method('log');
     $requestUrl = 'someUrl';
     $requestBody = ['autoMarkDelivered' => true];
     $headers = [RequestMaker::HEADER_API_SECRET => $this->apiSecret, RequestMaker::HEADER_PARTNER_TOKEN => $this->partnerToken];
     $request = new \GuzzleHttp\Message\Request('POST', $requestUrl, $headers);
     $responseData = ['expectedDeliveryDate' => '2012-01-01'];
     $this->httpClientMock->expects(self::once())->method('createRequest')->with('POST', $requestUrl)->willReturn($request);
     $this->httpClientMock->expects(self::once())->method('send')->willReturn($this->createFutureResponse(200, json_encode($responseData)));
     $requestMaker = $this->createRequestMaker();
     $response = $requestMaker->sendPostRequest($requestUrl, $requestBody);
     $this->assertInstanceOf('SlevomatZboziApi\\Response\\ZboziApiResponse', $response);
     $this->assertSame(200, $response->getStatusCode());
     $this->assertSame($responseData, $response->getBody());
 }

 /**
  * @covers \jones\novaposhta\http\Client::execute
  * @expectedException \jones\novaposhta\http\ClientException
  * @expectedExceptionMessage Exception thrown by Guzzle client and has response
  */
 public function testExecuteWithClientExceptionAndHasResponse()
 {
     $message = 'Exception thrown by Guzzle client and has response';
     /** @var \GuzzleHttp\Psr7\Request $request */
     $request = $this->getMockBuilder(GuzzleRequest::class)->disableOriginalConstructor()->getMock();
     $exception = new ClientException($message, $request, $this->response);
     $this->guzzleClient->expects(static::once())->method('post')->willThrowException($exception);
     $this->response->expects(static::never())->method('getBody');
     $this->client->execute($this->request, ConverterInterface::FORMAT_XML, Request::API_URL_XML);
 }

 public function testSendPostRequestWorksWithoutLogger()
 {
     $this->loggerMock = null;
     $this->httpClientMock->expects(self::once())->method('send')->with($this->callback(function (\GuzzleHttp\Psr7\Request $subject) {
         return $subject->getMethod() === 'POST' && $subject->getUri()->getPath() === 'someUrl';
     }))->willReturn(new \GuzzleHttp\Psr7\Response(200, [], '{"someData":8}'));
     $requestMaker = $this->createRequestMaker();
     $requestMaker->sendPostRequest('someUrl');
     $this->assertTrue(true);
 }

 /**
  * Test to ensure message is able to be sent correctly
  */
 public function testEnsureMessageCanBeSent()
 {
     // Set up the data fixture
     $fh = fopen('tests/Mocking/API/Fixtures/send-data.txt', 'r');
     $response = fread($fh, 4096);
     fclose($fh);
     $channel = 'C04C8KJRC';
     $text = 'This is a test';
     $url = self::BASEURL . 'chat.postMessage';
     $bodyParam = ['body' => ['token' => $this->token, 'channel' => $channel, 'text' => $text]];
     $this->client->expects($this->once())->method('post')->with($url, $bodyParam)->will($this->returnValue($this->response));
     $this->response->expects($this->once())->method('getBody')->will($this->returnValue($response));
     $slack = new Slack($this->client, $this->token);
     $result = $slack->sendMessage($text, $channel);
     $arrayResponse = json_decode($result, true);
     $this->assertTrue($arrayResponse['ok']);
     $this->assertEquals($arrayResponse['channel'], $channel);
     $this->assertEquals($arrayResponse['message']['text'], $text);
 }

 /**
  * @covers ::setTimeout
  */
 public function testSetTimeout()
 {
     $this->internalClient->expects($this->once())->method('setDefaultOption')->with('timeout', 4);
     $this->client->setTimeout('4');
 }

 /**
  * @test
  */
 public function getShouldConfigureHeaders()
 {
     $client = new Client($this->httpClient);
     $this->httpClient->expects($this->once())->method('get')->with('/test?name=Test', ['verify' => false])->willReturn($this->response);
     $this->assertInstanceOf('SimpleXMLElement', $client->get('/test?name=Test'));
 }

 /**
  * @param string $url
  * @param \GuzzleHttp\Psr7\Response $response
  * @param string $filePath
  * @param array|int $result
  * @dataProvider getToSinkDataProvider
  */
 public function testGetToSink($url, $response, $filePath, $result)
 {
     $this->clientMock->expects($this->once())->method('get')->with($url, [RequestOptions::SINK => $filePath])->willReturn($response);
     $this->assertEquals($result, $this->httpMock->getToSink($url, $filePath));
 }