Exemplo n.º 1
0
 /**
  * Checks if the given value is valid according to the property validators
  * Note: a value of NULL or empty string ('') is considered valid
  *
  * @param mixed $object The value that should be validated
  * @return void
  * @api
  */
 protected function isValid($object)
 {
     $messages = new \TYPO3\FLOW3\Error\Result();
     foreach ($this->propertyValidators as $propertyName => $validators) {
         $propertyValue = $this->getPropertyValue($object, $propertyName);
         $this->checkProperty($propertyValue, $validators, $messages->forProperty($propertyName));
     }
     $this->result = $messages;
     return;
 }
Exemplo n.º 2
0
 /**
  * @test
  */
 public function mergeShouldMergeTwoResults()
 {
     $notice1 = $this->getMockMessage('Notice');
     $notice2 = $this->getMockMessage('Notice');
     $notice3 = $this->getMockMessage('Notice');
     $warning1 = $this->getMockMessage('Warning');
     $warning2 = $this->getMockMessage('Warning');
     $warning3 = $this->getMockMessage('Warning');
     $error1 = $this->getMockMessage('Error');
     $error2 = $this->getMockMessage('Error');
     $error3 = $this->getMockMessage('Error');
     $otherResult = new \TYPO3\FLOW3\Error\Result();
     $otherResult->addNotice($notice1);
     $otherResult->forProperty('foo.bar')->addNotice($notice2);
     $this->result->forProperty('foo')->addNotice($notice3);
     $otherResult->addWarning($warning1);
     $this->result->addWarning($warning2);
     $this->result->addWarning($warning3);
     $otherResult->forProperty('foo')->addError($error1);
     $otherResult->forProperty('foo')->addError($error2);
     $otherResult->addError($error3);
     $this->result->merge($otherResult);
     $this->assertSame(array($notice1), $this->result->getNotices(), 'Notices are not merged correctly without recursion');
     $this->assertSame(array($notice3), $this->result->forProperty('foo')->getNotices(), 'Original sub-notices are overridden.');
     $this->assertSame(array($notice2), $this->result->forProperty('foo')->forProperty('bar')->getNotices(), 'Sub-notices are not copied.');
     $this->assertSame(array($warning2, $warning3, $warning1), $this->result->getWarnings());
     $this->assertSame(array($error3), $this->result->getErrors());
     $this->assertSame(array($error1, $error2), $this->result->forProperty('foo')->getErrors());
 }
Exemplo n.º 3
0
 /**
  * Validate a dictionary value with the given schema
  *
  * The following properties are handled in given $schema:
  * - properties : array of keys and schemas that have to validate
  * - formatProperties : dictionary of schemas, the schemas are used to validate all keys that match the string-format
  * - patternProperties : dictionary of schemas, the schemas are used to validate all keys that match the string-pattern
  * - additionalProperties : if FALSE is given all additionalProperties are forbidden, if a schema is given all additional properties have to match the schema
  *
  * @param mixed $value
  * @param array $schema
  * @return \TYPO3\FLOW3\Error\Result
  */
 protected function validateDictionaryType($value, array $schema)
 {
     $result = new \TYPO3\FLOW3\Error\Result();
     if (is_array($value) === FALSE || $this->isDictionary($value) === FALSE) {
         $result->addError($this->createError('type=dictionary', 'type=' . gettype($value)));
         return $result;
     }
     $propertyKeysToHandle = array_keys($value);
     if (isset($schema['properties'])) {
         foreach ($schema['properties'] as $propertyName => $propertySchema) {
             if (array_key_exists($propertyName, $value)) {
                 $propertyValue = $value[$propertyName];
                 $subresult = $this->validate($propertyValue, $propertySchema);
                 if ($subresult->hasErrors()) {
                     $result->forProperty($propertyName)->merge($subresult);
                 }
                 $propertyKeysToHandle = array_diff($propertyKeysToHandle, array($propertyName));
             } else {
                 // is subproperty required
                 if (is_array($propertySchema) && $this->isSchema($propertySchema) && isset($propertySchema['required']) && $propertySchema['required'] == TRUE) {
                     $result->addError($this->createError('Property ' . $propertyName . ' is required'));
                 }
             }
         }
     }
     if (isset($schema['patternProperties']) && count($propertyKeysToHandle) > 0 && $this->isDictionary($schema['patternProperties'])) {
         foreach (array_values($propertyKeysToHandle) as $propertyKey) {
             foreach ($schema['patternProperties'] as $propertyPattern => $propertySchema) {
                 $keyResult = $this->validateStringType($propertyKey, array('pattern' => $propertyPattern));
                 if ($keyResult->hasErrors() === FALSE) {
                     $subresult = $this->validate($value[$propertyKey], $propertySchema);
                     if ($subresult->hasErrors()) {
                         $result->forProperty($propertyKey)->merge($subresult);
                     }
                     $propertyKeysToHandle = array_diff($propertyKeysToHandle, array($propertyKey));
                 }
             }
         }
     }
     if (isset($schema['formatProperties']) && count($propertyKeysToHandle) > 0 && $this->isDictionary($schema['formatProperties'])) {
         foreach (array_values($propertyKeysToHandle) as $propertyKey) {
             foreach ($schema['formatProperties'] as $propertyPattern => $propertySchema) {
                 $keyResult = $this->validateStringType($propertyKey, array('format' => $propertyPattern));
                 if ($keyResult->hasErrors() === FALSE) {
                     $subresult = $this->validate($value[$propertyKey], $propertySchema);
                     if ($subresult->hasErrors()) {
                         $result->forProperty($propertyKey)->merge($subresult);
                     }
                     $propertyKeysToHandle = array_diff($propertyKeysToHandle, array($propertyKey));
                 }
             }
         }
     }
     if (isset($schema['additionalProperties']) && count($propertyKeysToHandle) > 0) {
         if ($schema['additionalProperties'] === FALSE) {
             foreach ($propertyKeysToHandle as $propertyKey) {
                 $result->forProperty($propertyKey)->addError($this->createError('This property is not allowed here, check the spelling if you think it belongs here.'));
             }
         } else {
             foreach ($propertyKeysToHandle as $propertyKey) {
                 $subresult = $this->validate($value[$propertyKey], $schema['additionalProperties']);
                 if ($subresult->hasErrors()) {
                     $result->forProperty($propertyKey)->merge($subresult);
                 }
             }
         }
     }
     return $result;
 }
 /**
  * Validate the given configuration
  *
  * ./flow3 configuration:validate --type Settings --path TYPO3.FLOW3.persistence
  *
  * The schemas are searched in the path "Resources/Private/Schema" of all
  * active Packages. The schema-filenames must match the pattern
  * __type__.__path__.schema.yaml. The type and/or the path can also be
  * expressed as subdirectories of Resources/Private/Schema. So
  * Settings/TYPO3/FLOW3.persistence.schema.yaml will match the same pathes
  * like Settings.TYPO3.FLOW3.persistence.schema.yaml or
  * Settings/TYPO3.FLOW3/persistence.schema.yaml
  *
  * @param string $type Configuration type to validate
  * @param string $path path to the subconfiguration separated by "." like "TYPO3.FLOW3"
  * @return void
  */
 public function validateCommand($type = NULL, $path = NULL)
 {
     $availableConfigurationTypes = $this->configurationManager->getAvailableConfigurationTypes();
     if (in_array($type, $availableConfigurationTypes) === FALSE) {
         if ($type !== NULL) {
             $this->outputLine('<b>Configuration type "%s" was not found!</b>', array($type));
             $this->outputLine();
         }
         $this->outputLine('<b>Available configuration types:</b>');
         foreach ($availableConfigurationTypes as $availableConfigurationType) {
             $this->outputLine('  ' . $availableConfigurationType);
         }
         $this->outputLine();
         $this->outputLine('Hint: <b>%s configuration:validate --type <configurationType></b>', array($this->getFlow3InvocationString()));
         $this->outputLine('      validates the configuration of the specified type.');
         return;
     }
     $configuration = $this->configurationManager->getConfiguration($type);
     $this->outputLine('<b>Validating configuration for type: "' . $type . '"' . ($path !== NULL ? ' and path: "' . $path . '"' : '') . '</b>');
     // find schema files for the given type and path
     $schemaFileInfos = array();
     $activePackages = $this->packageManager->getActivePackages();
     foreach ($activePackages as $package) {
         $packageKey = $package->getPackageKey();
         $packageSchemaPath = \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($package->getResourcesPath(), 'Private/Schema'));
         if (is_dir($packageSchemaPath)) {
             $packageSchemaFiles = \TYPO3\FLOW3\Utility\Files::readDirectoryRecursively($packageSchemaPath, '.schema.yaml');
             foreach ($packageSchemaFiles as $schemaFile) {
                 $schemaName = substr($schemaFile, strlen($packageSchemaPath) + 1, -strlen('.schema.yaml'));
                 $schemaNameParts = explode('.', str_replace('/', '.', $schemaName), 2);
                 $schemaType = $schemaNameParts[0];
                 $schemaPath = isset($schemaNameParts[1]) ? $schemaNameParts[1] : NULL;
                 if ($schemaType === $type && ($path === NULL || strpos($schemaPath, $path) === 0)) {
                     $schemaFileInfos[] = array('file' => $schemaFile, 'name' => $schemaName, 'path' => $schemaPath, 'packageKey' => $packageKey);
                 }
             }
         }
     }
     $this->outputLine();
     if (count($schemaFileInfos) > 0) {
         $this->outputLine('%s schema files were found:', array(count($schemaFileInfos)));
         $result = new \TYPO3\FLOW3\Error\Result();
         foreach ($schemaFileInfos as $schemaFileInfo) {
             if ($schemaFileInfo['path'] !== NULL) {
                 $data = \TYPO3\FLOW3\Utility\Arrays::getValueByPath($configuration, $schemaFileInfo['path']);
             } else {
                 $data = $configuration;
             }
             if (empty($data)) {
                 $result->forProperty($schemaFileInfo['path'])->addError(new \TYPO3\FLOW3\Error\Error('configuration in path ' . $schemaFileInfo['path'] . ' is empty'));
                 $this->outputLine(' - package: "' . $schemaFileInfo['packageKey'] . '" schema: "' . $schemaFileInfo['name'] . '" -> <b>configuration is empty</b>');
             } else {
                 $parsedSchema = \Symfony\Component\Yaml\Yaml::parse($schemaFileInfo['file']);
                 $schemaResult = $this->schemaValidator->validate($data, $parsedSchema);
                 if ($schemaResult->hasErrors()) {
                     $this->outputLine(' - package:"' . $schemaFileInfo['packageKey'] . '" schema:"' . $schemaFileInfo['name'] . '" -> <b>' . count($schemaResult->getFlattenedErrors()) . ' errors</b>');
                 } else {
                     $this->outputLine(' - package:"' . $schemaFileInfo['packageKey'] . '" schema:"' . $schemaFileInfo['name'] . '" -> <b>is valid</b>');
                 }
                 if ($schemaFileInfo['path'] !== NULL) {
                     $result->forProperty($schemaFileInfo['path'])->merge($schemaResult);
                 } else {
                     $result->merge($schemaResult);
                 }
             }
         }
     } else {
         $this->outputLine('No matching schema-files were found!');
         return;
     }
     $this->outputLine();
     if ($result->hasErrors()) {
         $errors = $result->getFlattenedErrors();
         $this->outputLine('<b>%s errors were found:</b>', array(count($errors)));
         foreach ($errors as $path => $pathErrors) {
             foreach ($pathErrors as $error) {
                 $this->outputLine(' - %s -> %s', array($path, $error->render()));
             }
         }
     } else {
         $this->outputLine('<b>The configuration is valid!</b>');
     }
 }
Exemplo n.º 5
0
 /**
  * Get all property mapping / validation errors
  *
  * @return \TYPO3\FLOW3\Error\Result
  */
 public function getValidationResults()
 {
     $results = new \TYPO3\FLOW3\Error\Result();
     foreach ($this as $argument) {
         $argumentValidationResults = $argument->getValidationResults();
         if ($argumentValidationResults === NULL) {
             continue;
         }
         $results->forProperty($argument->getName())->merge($argumentValidationResults);
     }
     return $results;
 }