PHP Request::setFormat方法代碼示例

 /**
  * Tests the getContentType() method when a priority format is found.
  *
  * @dataProvider priorityFormatProvider
  * @covers ::getContentType
  */
 public function testAPriorityFormatIsFound($priority, $format)
 {
     $request = new Request();
     $request->setFormat($format['format'], $format['mime_type']);
     $request->headers->set('Accept', sprintf('%s,application/json', $format['mime_type']));
     $this->assertSame($priority, $this->contentNegotiation->getContentType($request));
 }

 /**
  * {@inheritdoc}
  */
 public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
 {
     foreach ($this->formats as $format => $mime_type) {
         $request->setFormat($format, $mime_type);
     }
     $request->setRequestFormat($this->negotiator->getContentType($request));
     return $this->app->handle($request, $type, $catch);
 }

 /**
  * {@inheritdoc}
  */
 public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
 {
     // Register available mime types.
     foreach ($this->formats as $format => $mime_type) {
         $request->setFormat($format, $mime_type);
     }
     // Determine the request format using the negotiator.
     $request->setRequestFormat($this->getContentType($request));
     return $this->app->handle($request, $type, $catch);
 }

 /**
  * @return void
  */
 public function testOnKernelRequest()
 {
     $server = array('HTTP_ACCEPT' => 'application/vnd.com.swisscom.translation+json');
     $request = new Request(array(), array(), array(), array(), array(), $server);
     $request->setFormat('json', 'application/json');
     $eventDouble = $this->getMockBuilder('\\Graviton\\RestBundle\\Event\\RestEvent')->disableOriginalConstructor()->setMethods(array('getRequest'))->getMock();
     $eventDouble->expects($this->once())->method('getRequest')->willReturn($request);
     $containerDouble = $this->getMockBuilder('\\Symfony\\Component\\DependencyInjection\\Container')->disableOriginalConstructor()->setMethods(array('getParameter'))->getMock();
     $containerDouble->expects($this->once())->method('getParameter')->with($this->equalTo('graviton.rest.special_mimetypes'))->willReturn(array('json' => array('application/vnd.com.swisscom.translation+json')));
     $listener = new SpecialMimetypeRequestListener($containerDouble);
     $listener->onKernelRequest($eventDouble);
     $this->assertEquals('json', $request->getFormat('application/vnd.com.swisscom.translation+json'));
 }

 public function testActionWithUncatchableException()
 {
     $serializerException = $this->prophesize(ExceptionInterface::class);
     $serializerException->willExtend(\Exception::class);
     $flattenException = FlattenException::create($serializerException->reveal());
     $serializer = $this->prophesize(SerializerInterface::class);
     $serializer->serialize($flattenException, 'jsonproblem')->willReturn();
     $exceptionAction = new ExceptionAction($serializer->reveal(), ['jsonproblem' => ['application/problem+json'], 'jsonld' => ['application/ld+json']]);
     $request = new Request();
     $request->setFormat('jsonproblem', 'application/problem+json');
     $expected = new Response('', Response::HTTP_INTERNAL_SERVER_ERROR, ['Content-Type' => 'application/problem+json; charset=utf-8', 'X-Content-Type-Options' => 'nosniff', 'X-Frame-Options' => 'deny']);
     $this->assertEquals($expected, $exceptionAction($flattenException, $request));
 }

 public function testContentNegotiation()
 {
     $eventProphecy = $this->prophesize(GetResponseEvent::class);
     $request = new Request([], [], ['_api_resource_class' => 'Foo', '_api_collection_operation_name' => 'post'], [], [], [], '{}');
     $request->setMethod(Request::METHOD_POST);
     $request->headers->set('Content-Type', 'text/xml');
     $request->setFormat('xml', 'text/xml');
     // Workaround to avoid weird behaviors
     $eventProphecy->getRequest()->willReturn($request)->shouldBeCalled();
     $serializerProphecy = $this->prophesize(SerializerInterface::class);
     $serializerProphecy->deserialize('{}', 'Foo', 'xml', [])->willReturn(new \stdClass())->shouldBeCalled();
     $serializerContextBuilderProphecy = $this->prophesize(SerializerContextBuilderInterface::class);
     $serializerContextBuilderProphecy->createFromRequest(Argument::type(Request::class), false, Argument::type('array'))->willReturn([])->shouldBeCalled();
     $listener = new DeserializeListener($serializerProphecy->reveal(), $serializerContextBuilderProphecy->reveal(), ['jsonld' => ['application/ld+json'], 'xml' => ['text/xml']]);
     $listener->onKernelRequest($eventProphecy->reveal());
 }

 /**
  * Tests the live preview output for json output.
  */
 public function testLivePreview()
 {
     // We set up a request so it looks like an request in the live preview.
     $request = new Request();
     $request->setFormat('drupal_ajax', 'application/vnd.drupal-ajax');
     $request->headers->set('Accept', 'application/vnd.drupal-ajax');
     /** @var \Symfony\Component\HttpFoundation\RequestStack $request_stack */
     $request_stack = \Drupal::service('request_stack');
     $request_stack->push($request);
     $view = Views::getView('test_serializer_display_entity');
     $view->setDisplay('rest_export_1');
     $this->executeView($view);
     // Get the serializer service.
     $serializer = $this->container->get('serializer');
     $entities = array();
     foreach ($view->result as $row) {
         $entities[] = $row->_entity;
     }
     $expected = $serializer->serialize($entities, 'json');
     $view->live_preview = TRUE;
     $build = $view->preview();
     $rendered_json = $build['#plain_text'];
     $this->assertTrue(!isset($build['#markup']) && $rendered_json == $expected, 'Ensure the previewed json is escaped.');
     $view->destroy();
     $expected = $serializer->serialize($entities, 'xml');
     // Change the request format to xml.
     $view->setDisplay('rest_export_1');
     $view->getDisplay()->setOption('style', array('type' => 'serializer', 'options' => array('uses_fields' => FALSE, 'formats' => array('xml' => 'xml'))));
     $this->executeView($view);
     $build = $view->preview();
     $rendered_xml = $build['#plain_text'];
     $this->assertEqual($rendered_xml, $expected, 'Ensure we preview xml when we change the request format.');
 }

 /**
  * @covers Symfony\Component\HttpFoundation\Request::getFormat
  * @covers Symfony\Component\HttpFoundation\Request::setFormat
  * @dataProvider getFormatToMimeTypeMapProvider
  */
 public function testGetFormatFromMimeType($format, $mimeTypes)
 {
     $request = new Request();
     foreach ($mimeTypes as $mime) {
         $this->assertEquals($format, $request->getFormat($mime));
     }
     $request->setFormat($format, $mimeTypes);
     foreach ($mimeTypes as $mime) {
         $this->assertEquals($format, $request->getFormat($mime));
     }
 }

 public function testGetFormatWithCustomMimeType()
 {
     $request = new Request();
     $request->setFormat('custom', 'application/vnd.foo.api;myversion=2.3');
     $this->assertEquals('custom', $request->getFormat('application/vnd.foo.api;myversion=2.3'));
 }

 /**
  * Tests the live preview output for json output.
  */
 public function testLivePreview()
 {
     // We set up a request so it looks like an request in the live preview.
     $request = new Request();
     $request->setFormat('drupal_ajax', 'application/vnd.drupal-ajax');
     $request->headers->set('Accept', 'application/vnd.drupal-ajax');
     /** @var \Symfony\Component\HttpFoundation\RequestStack $request_stack */
     $request_stack = \Drupal::service('request_stack');
     $request_stack->push($request);
     $view = Views::getView('test_serializer_display_entity');
     $view->setDisplay('rest_export_1');
     $this->executeView($view);
     // Get the serializer service.
     $serializer = $this->container->get('serializer');
     $entities = array();
     foreach ($view->result as $row) {
         $entities[] = $row->_entity;
     }
     $expected = String::checkPlain($serializer->serialize($entities, 'json'));
     $view->live_preview = TRUE;
     $build = $view->preview();
     $rendered_json = $build['#markup'];
     $this->assertEqual($rendered_json, $expected, 'Ensure the previewed json is escaped.');
 }

 private function parseJsonRequest(Request $request)
 {
     $request->setFormat('json', 'application/json');
     if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
         $data = json_decode($request->getContent(), true);
         $request->request->replace(is_array($data) ? $data : array());
     }
 }

 /**
  * Adds API formats to the HttpFoundation Request.
  *
  * @param Request $request
  * @param array   $formats
  */
 private function addRequestFormats(Request $request, array $formats)
 {
     foreach ($formats as $format => $mimeTypes) {
         $request->setFormat($format, $mimeTypes);
     }
 }

 /**
  * This before middleware validates that the request body is in a format
  * that the application understands.
  *
  * @param Request $request
  * @throws UnsupportedMediaTypeHttpException
  */
 public function validateRequestContentType(Request $request, Application $app)
 {
     // Define the "form" format so we can use it for validation
     $request->setFormat("form", array("application/x-www-form-urlencoded", "multipart/form-data"));
     $format = $request->getContentType();
     if (strlen($request->getContent()) > 0 && !in_array($format, $app["conneg.requestFormats"])) {
         // The request has a body but it is not a supported media type
         throw new UnsupportedMediaTypeHttpException();
     }
 }