php Zend-Diactoros-ServerRequestFactory类(方法)实例源码

public function testIsNotExcluded()
 {
     $request = ServerRequestFactory::fromGlobals();
     $request = $request->withHeader('X-Forwarded', '80.80.80.80');
     $excluder = new IP($this->excludedIPs, ['10.10.10.10']);
     self::assertFalse($excluder->isExcluded($request));
 }

/**
  * Handles the request and returns a response.
  *
  * @param  \Psr\Http\Message\ServerRequestInterface|null $request
  * @param  \Psr\Http\Message\ResponseInterface|null      $response
  *
  * @return \Psr\Http\Message\ResponseInterface
  */
 public function handle(ServerRequestInterface $request = null, ResponseInterface $response = null)
 {
     $request = $request ?: ServerRequestFactory::fromGlobals();
     $response = $response ?: new Response();
     $this->emit(Event::REQUEST_RECEIVED, $request, $response);
     return $this->dispatchThroughMiddleware($request, $response);
 }

/**
  * @test
  */
 public function tagsListIsReturnedIfCorrectShortCodeIsProvided()
 {
     $shortCode = 'abc123';
     $this->shortUrlService->setTagsByShortCode($shortCode, [])->willReturn(new ShortUrl())->shouldBeCalledTimes(1);
     $response = $this->action->__invoke(ServerRequestFactory::fromGlobals()->withAttribute('shortCode', 'abc123')->withParsedBody(['tags' => []]), new Response());
     $this->assertEquals(200, $response->getStatusCode());
 }

/**
  * @test
  */
 public function invalidApiKeyReturnsErrorResponse()
 {
     $this->apiKeyService->getByKey('foo')->willReturn((new ApiKey())->setEnabled(false))->shouldBeCalledTimes(1);
     $request = ServerRequestFactory::fromGlobals()->withParsedBody(['apiKey' => 'foo']);
     $response = $this->action->__invoke($request, new Response());
     $this->assertEquals(401, $response->getStatusCode());
 }

/**
  * @test
  */
 public function datesAreReadFromQuery()
 {
     $shortCode = 'abc123';
     $this->visitsTracker->info($shortCode, new DateRange(null, new \DateTime('2016-01-01 00:00:00')))->willReturn([])->shouldBeCalledTimes(1);
     $response = $this->action->__invoke(ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode)->withQueryParams(['endDate' => '2016-01-01 00:00:00']), new Response());
     $this->assertEquals(200, $response->getStatusCode());
 }

/**
  * Get the request from server.
  *
  * @return RequestInterface Server request
  */
 public function getRequest()
 {
     if (!isset($this->request)) {
         $this->request = ServerRequestFactory::fromGlobals();
     }
     return $this->request;
 }

/**
  * @test
  */
 public function anExceptionsReturnsErrorResponse()
 {
     $page = 3;
     $this->service->listShortUrls($page, null, [], null)->willThrow(\Exception::class)->shouldBeCalledTimes(1);
     $response = $this->action->__invoke(ServerRequestFactory::fromGlobals()->withQueryParams(['page' => $page]), new Response());
     $this->assertEquals(500, $response->getStatusCode());
 }

/**
  * Get Request
  *
  * @param array $routeVariables Route Variables
  *
  * @return HttpMessages_CraftRequest Request
  */
 public function getRequest(array $routeVariables = [])
 {
     $route = craft()->httpMessages_routes->getRoute($routeVariables);
     $serverRequest = \Zend\Diactoros\ServerRequestFactory::fromGlobals();
     $request = HttpMessages_RequestFactory::fromRequest($serverRequest);
     return $request->withRoute($route);
 }

public function testOversizedResponse()
 {
     $expectedClass = 'NetworkJs\\Response\\OversizedResponse';
     $moduleName = 'download';
     $this->assertInstanceOf($expectedClass, ResponseFactory::fromValues($moduleName, 10, 5));
     $this->assertInstanceOf($expectedClass, ResponseFactory::fromRequest(ServerRequestFactory::fromGlobals(null, ['module' => $moduleName, 'size' => 10]), 5));
 }

/**
  * @test
  */
 public function nonRestPathsAreNotProcessed()
 {
     $request = ServerRequestFactory::fromGlobals()->withUri(new Uri('/non-rest'));
     $test = $this;
     $this->middleware->__invoke($request, new Response(), function ($req) use($request, $test) {
         $test->assertSame($request, $req);
     });
 }

/**
  * {@inheritdoc}
  */
 public function setUp()
 {
     $this->request = ServerRequestFactory::fromGlobals();
     $this->response = new Response();
     $this->callback = function ($request, $response) {
         return $response;
     };
 }

public static function createRequest(RequestInterface $request)
 {
     $psrRequest = ServerRequestFactory::fromGlobals()->withUri($request->getUri())->withMethod($request->getMethod())->withBody($request->getBody());
     foreach ($request->getHeaders() as $name => $values) {
         $psrRequest = $psrRequest->withHeader($name, $values);
     }
     return $psrRequest;
 }

/**
  * @test
  */
 public function to_applies_filters()
 {
     $applied = false;
     $this->proxy->forward(ServerRequestFactory::fromGlobals())->filter(function ($request, $response) use(&$applied) {
         $applied = true;
     })->to('http://www.example.com');
     $this->assertTrue($applied);
 }

/**
  * @test
  */
 public function aGenericExceptionWillReturnError()
 {
     $this->urlShortener->urlToShortCode(Argument::type(Uri::class), Argument::type('array'))->willThrow(\Exception::class)->shouldBeCalledTimes(1);
     $request = ServerRequestFactory::fromGlobals()->withParsedBody(['longUrl' => 'http://www.domain.com/foo/bar']);
     $response = $this->action->__invoke($request, new Response());
     $this->assertEquals(500, $response->getStatusCode());
     $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::UNKNOWN_ERROR) > 0);
 }

public function testNamedRoutes()
 {
     $routes = new RouteCollection(new HttpMessageStrategy());
     $routes->addRoute('GET', '/user/{id}', function () {
     })->setName('UserProfile');
     $builder = new UrlBuilder(ServerRequestFactory::fromGlobals($this->fakeServerParams()), $routes);
     $this->assertEquals('/site/user/23', $builder->createByName('UserProfile', ['id' => 23]));
 }

/**
  *
  */
 public function __construct()
 {
     parent::__construct();
     $this->_middleware = new \ArrayObject();
     $this->_routeMap = new RouteMap();
     $this->_request = ServerRequestFactory::fromGlobals();
     $this->_response = new Response();
 }

/**
  * Test missing routes not being caught.
  *
  * @expectedException \Cake\Routing\Exception\MissingRouteException
  */
 public function testMissingRouteNotCaught()
 {
     $request = ServerRequestFactory::fromGlobals(['REQUEST_URI' => '/missing']);
     $response = new Response();
     $next = function ($req, $res) {
     };
     $middleware = new RoutingMiddleware();
     $middleware($request, $response, $next);
 }

public function register()
 {
     $this->forge->singleton(['routing', Routing::class], function () {
         $routing = new Routing(new HttpRequest(ServerRequestFactory::fromGlobals()), new HttpResponse(new Response()));
         $routing->makeDispatcher(HTTP . "routes.php");
         return $routing;
     });
     $this->provides += [Routing::class];
 }

/**
  * Initial setup of DI\ContainerBuilder.
  *
  * @param bool $annotation annotation usage.
  *
  * @return DI\ContainerBuilder
  */
 protected static function initialSetupContainerBuilder($annotation)
 {
     $builder = new DI\ContainerBuilder();
     $builder->useAnnotations($annotation);
     $builder->addDefinitions(['request' => ServerRequestFactory::fromGlobals(), 'response' => DI\object(Response::class), 'http_flow_event' => DI\object(ZendHttpFlowEvent::class)->constructor('bootstrap', DI\get('request'), DI\get('response')), 'event_manager' => DI\object(ZendEvmProxy::class), 'dispatcher' => DI\factory(function ($container) {
         return new Dispatcher($container->get('router'), $container);
     })]);
     return $builder;
 }

/**
  * @test
  */
 public function unexpectedExceptionWillReturnError()
 {
     $shortCode = 'abc123';
     $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(\Exception::class)->shouldBeCalledTimes(1);
     $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
     $response = $this->action->__invoke($request, new Response());
     $this->assertEquals(500, $response->getStatusCode());
     $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::UNKNOWN_ERROR) > 0);
 }