PHP Validator::check方法代码示例

 public function validate($data)
 {
     $data = json_decode(json_encode($data));
     $this->validator->check($data, (object) ['$ref' => $this->getSchemaPath()]);
     $result = false;
     if ($this->validator->isValid()) {
         return new ValidationResult(true, '');
     }
     $messages = array_map(function ($error) {
         return sprintf("[%s] %s.", $error['property'], $error['message']);
     }, $this->validator->getErrors());
     return new ValidationResult($result, trim(implode(' ', $messages)));
 }

 protected function doValidation(Response $response)
 {
     $data = json_decode($response->getBody());
     if ($data === null) {
         throw new ValidationFailedException("The given JSON data can not be validated (last error: '" . $this->json_errors[json_last_error()] . "').");
     } else {
         $error = false;
         $messageParts = array();
         foreach ($this->jsonSchemaFiles as $jsonSchemaFile) {
             $factory = new Factory(null, null, Constraint::CHECK_MODE_TYPE_CAST | Constraint::CHECK_MODE_COERCE);
             $validator = new Validator($factory);
             $jsonSchemaObject = (object) json_decode(file_get_contents($jsonSchemaFile['jsonschemafileurl']));
             $validator->check($data, $jsonSchemaObject);
             if (!$validator->isValid()) {
                 $error = true;
                 $errorMessage = '';
                 foreach ($validator->getErrors() as $error) {
                     $errorMessage = $errorMessage . sprintf("[%s] %s\n", $error['property'], $error['message']);
                 }
                 $messageParts[] = $jsonSchemaFile['jsonschemafilename'] . ' - ' . $jsonSchemaFile['jsonschemafileurl'] . '(last error: ' . $errorMessage . ').';
             }
         }
         if ($error == true) {
             $message = 'JSON file (' . (string) $response->getUri() . ')  does not validate against the following JSON Schema files: ' . implode(", ", $messageParts);
             throw new ValidationFailedException($message);
         }
     }
 }

 public function parseSingleSchema($schemeSpec)
 {
     if ($schemeSpec === null) {
         throw new ParseException('scheme must not be empty');
     }
     if (!is_string($schemeSpec)) {
         throw new ParseException('scheme must be a string');
     }
     $schemaJson = json_decode($schemeSpec);
     if (json_last_error() == JSON_ERROR_NONE) {
         $schemeUri = $schemaJson->{'$schema'};
         $retriever = new \JsonSchema\Uri\UriRetriever();
         $scheme = $retriever->retrieve($schemeUri);
         $validator = new Validator();
         $validator->check($schemaJson, $scheme);
         if ($validator->isValid()) {
             $arrayScheme = json_decode($schemeSpec, true);
             unset($arrayScheme['$schema']);
             return $arrayScheme;
         } else {
             foreach ($validator->getErrors() as $error) {
                 echo sprintf("[%s] %s\n", $error['property'], $error['message']);
             }
         }
     }
 }

 /**
  * @param string $schemaName
  */
 protected function assertJsonResponse($response, $statusCode = Response::HTTP_OK, $schemaName = null)
 {
     // Assert HTTP response status code
     $this->assertEquals($statusCode, $response->getStatusCode(), $response->getContent());
     $content = $response->getContent();
     $data = null;
     if ($content) {
         // Assert response is JSON content-type (unless response content is empty)
         $this->assertTrue($response->headers->contains('Content-Type', 'application/json'), $response->headers);
         // Parse the response body
         $data = json_decode($response->getContent());
     }
     // Validate JSON data with given schema
     if (null !== $schemaName) {
         $schemaUri = 'file://' . realpath(__DIR__ . '/../Resources/json_schemas/' . $schemaName . '.json');
         $retriever = new JsonSchema\Uri\UriRetriever();
         $schema = $retriever->retrieve($schemaUri);
         $validator = new JsonSchema\Validator();
         $validator->check($data, $schema);
         if (!$validator->isValid()) {
             $errorMessage = 'JSON response does not validate the schema';
             foreach ($validator->getErrors() as $error) {
                 $errorMessage .= sprintf("\n[%s] %s", $error['property'], $error['message']);
             }
             $this->fail($errorMessage);
         }
     }
     return $data;
 }

 /**
  * Merge the given config on to "configurable" (either a GeneratorInterface
  * or a RendererInterface) instance's default config and validate it
  * according to the "configurable" instance's JSON schema.
  *
  * @param ConfigurableInterface $configurable
  * @param array $reportConfig
  *
  * @return array
  */
 private function mergeAndValidateConfig(ConfigurableInterface $configurable, array $reportConfig)
 {
     $reportConfig = array_replace_recursive($configurable->getDefaultConfig(), $reportConfig);
     // not sure if there is a better way to convert the schema array to objects
     // as expected by the validator.
     $validationConfig = json_decode(json_encode($reportConfig));
     $schema = $configurable->getSchema();
     if (!is_array($schema)) {
         throw new \InvalidArgumentException(sprintf('Configurable class "%s" must return the JSON schema as an array', get_class($configurable)));
     }
     // convert the schema to a \stdClass
     $schema = json_decode(json_encode($schema));
     // json_encode encodes an array instead of an object if the schema
     // is empty. JSON schema requires an object.
     if (empty($schema)) {
         $schema = new \stdClass();
     }
     $this->validator->check($validationConfig, $schema);
     if (!$this->validator->isValid()) {
         $errorString = array();
         foreach ($this->validator->getErrors() as $error) {
             $errorString[] = sprintf('[%s] %s', $error['property'], $error['message']);
         }
         throw new \InvalidArgumentException(sprintf('Invalid JSON: %s%s', PHP_EOL . PHP_EOL . PHP_EOL, implode(PHP_EOL, $errorString)));
     }
     return $reportConfig;
 }

 /**
  * @param \stdClass $responseBody
  *
  * @return Validator
  */
 protected function getValidator($responseBody)
 {
     $responseSchema = $this->schemaManager->getResponseSchema($this->path, $this->httpMethod, $this->httpCode);
     $validator = new Validator();
     $validator->check($responseBody, $responseSchema);
     return $validator;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $path = $input->getArgument('path');
     if (!$path) {
         $path = getcwd() . DIRECTORY_SEPARATOR . 'resolver.json';
     }
     if (!is_file($path)) {
         $output->writeln(sprintf('<error>The file "%s" does not exists.</error>', $path));
         return 1;
     }
     // Get the schema and data as objects:
     $schema = json_decode(file_get_contents(__DIR__ . '/../../resources/schema.json'));
     $data = json_decode(file_get_contents($path));
     // Validate:
     $validator = new Validator();
     $validator->check($data, $schema);
     if ($validator->isValid()) {
         $output->writeln($path . ' is valid');
         return 0;
     }
     $output->writeln(sprintf('<error>The file "%s" contains errors.</error>', $path));
     foreach ($validator->getErrors() as $error) {
         if ($error['property']) {
             $output->writeln(sprintf('- %s: %s', $error['property'], $error['message']));
         } else {
             $output->writeln(sprintf('- %s', $error['message']));
         }
     }
     return 1;
 }

 /**
  * Check data against a given entity type from the schema
  *
  * @param array|object $data Data from the API. Associative arrays will be reparsed into objects
  * @param string $entity Entity type, from the schema
  */
 protected function checkEntityAgainstSchema($data, $entity)
 {
     $absolute_ref = self::SCHEMA_BASE . 'definitions/' . $entity;
     $schema = $this->retriever->retrieve($absolute_ref);
     if (is_array($data)) {
         // Data was decoded as an array instead of an object, reencode for
         // schema checking
         $data = json_decode(json_encode($data));
     }
     $validator = new Validator(Validator::CHECK_MODE_NORMAL, $this->retriever);
     $validator->check($data, $schema);
     if (!$validator->isValid()) {
         $message = "JSON does not validate against schema:\n";
         $i = 0;
         foreach ($validator->getErrors() as $error) {
             $i++;
             $message .= $i . ') ';
             if (!empty($error['property'])) {
                 $message .= sprintf("[%s] %s\n", $error['property'], $error['message']);
             } else {
                 $message .= $error['message'] . "\n";
             }
         }
         $this->fail($message);
     }
 }

 /**
  * Validates JSON data against a schema.
  *
  * The schema may be passed as file path or as object returned from
  * `json_decode($schemaFile)`.
  *
  * @param mixed              $data   The decoded JSON data
  * @param string|object|null $schema The schema file or object. If `null`,
  *                                   the validator will look for a `$schema`
  *                                   property
  *
  * @return string[] The errors found during validation. Returns an empty
  *                  array if no errors were found
  *
  * @throws InvalidSchemaException If the schema is invalid
  */
 public function validate($data, $schema = null)
 {
     if (null === $schema && isset($data->{'$schema'})) {
         $schema = $data->{'$schema'};
     }
     if (is_string($schema)) {
         $schema = $this->loadSchema($schema);
     } elseif (is_object($schema)) {
         $this->assertSchemaValid($schema);
     } else {
         throw new InvalidSchemaException(sprintf('The schema must be given as string, object or in the "$schema" ' . 'property of the JSON data. Got: %s', is_object($schema) ? get_class($schema) : gettype($schema)));
     }
     $this->validator->reset();
     try {
         $this->validator->check($data, $schema);
     } catch (InvalidArgumentException $e) {
         throw new InvalidSchemaException(sprintf('The schema is invalid: %s', $e->getMessage()), 0, $e);
     }
     $errors = array();
     if (!$this->validator->isValid()) {
         $errors = (array) $this->validator->getErrors();
         foreach ($errors as $key => $error) {
             $prefix = $error['property'] ? $error['property'] . ': ' : '';
             $errors[$key] = $prefix . $error['message'];
         }
     }
     return $errors;
 }

 /**
  * @param $jsonStr
  * @return Validator
  */
 private static function initValidator($jsonStr)
 {
     /** @var $this JsonValidatableTrait */
     $validator = new Validator();
     $data = json_decode($jsonStr);
     $schema = static::jsonViceVersa(static::getJsonSchema());
     $validator->check($data, $schema);
     return $validator;
 }

 /**
  * @dataProvider getValidTests
  */
 public function testValidCases($input, $schema, $checkMode = Validator::CHECK_MODE_NORMAL)
 {
     $schema = json_decode($schema);
     $refResolver = new RefResolver(new UriRetriever());
     $refResolver->resolve($schema);
     $validator = new Validator($checkMode);
     $validator->check(json_decode($input), $schema);
     $this->assertTrue($validator->isValid(), print_r($validator->getErrors(), true));
 }

 /**
  * @inheritdoc
  */
 protected function additionalFailureDescription($other)
 {
     $other = $this->forceToObject($other);
     $validator = new Validator();
     $validator->check($other, $this->schema);
     return implode("\n", array_map(function ($error) {
         return $error['message'];
     }, $validator->getErrors()));
 }

 private function check($json)
 {
     $schema = json_decode(file_get_contents(__DIR__ . '/../../../../res/composer-schema.json'));
     $validator = new Validator();
     $validator->check(json_decode($json), $schema);
     if (!$validator->isValid()) {
         return $validator->getErrors();
     }
     return true;
 }

 public function validateSchema($json, $schema)
 {
     $validator = new Validator();
     $validator->check(json_decode($json), json_decode($schema));
     if ($validator->isValid()) {
         return true;
     } else {
         return $validator->getErrors();
     }
 }

 public static function GetTestFiles()
 {
     $dir = dirname(dirname(__DIR__));
     $retriever = new UriRetriever();
     $schema = $retriever->retrieve('file://' . realpath($dir . '/schema/tests.json'));
     return new CallbackFilterIterator(new DirectoryIterator($dir . '/tests'), function (SplFileInfo $file) use($schema) {
         $validator = new Validator();
         return $file->isFile() && $file->isReadable() && preg_match('/\\.json$/', $file->getBasename()) && $validator->check($schema, json_decode(file_get_contents($file->getRealPath()))) == null && $validator->isValid();
     });
 }