tonyair/silverstripe-framework
1
0
Fork 0
mirror of https://github.com/silverstripe/silverstripe-framework synced 2024-10-22 14:05:37 +02:00
Code Issues Projects Releases Wiki Activity

NEW Validate DBFields

Browse Source
This commit is contained in:
Steve Boyd 2024-10-09 19:46:00 +13:00
parent 7f11bf3587
commit d772268406
74 changed files with 2889 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
_config/model.yml
View File

@ -20,6 +20,8 @@ SilverStripe\Core\Injector\Injector:
class: SilverStripe\ORM\FieldType\DBDecimal
Double:
class: SilverStripe\ORM\FieldType\DBDouble
Email:
class: SilverStripe\ORM\FieldType\DBEmail
Enum:
class: SilverStripe\ORM\FieldType\DBEnum
Float:
@ -36,6 +38,8 @@ SilverStripe\Core\Injector\Injector:
class: SilverStripe\ORM\FieldType\DBHTMLVarchar
Int:
class: SilverStripe\ORM\FieldType\DBInt
IP:
class: SilverStripe\ORM\FieldType\DBIp
BigInt:
class: SilverStripe\ORM\FieldType\DBBigInt
Locale:
@ -58,6 +62,8 @@ SilverStripe\Core\Injector\Injector:
class: SilverStripe\ORM\FieldType\DBText
Time:
class: SilverStripe\ORM\FieldType\DBTime
URL:
class: SilverStripe\ORM\FieldType\DBUrl
Varchar:
class: SilverStripe\ORM\FieldType\DBVarchar
Year:

1
composer.json
View File

@ -47,6 +47,7 @@
"symfony/dom-crawler": "^7.0",
"symfony/filesystem": "^7.0",
"symfony/http-foundation": "^7.0",
"symfony/intl": "^7.0",
"symfony/mailer": "^7.0",
"symfony/mime": "^7.0",
"symfony/translation": "^7.0",

4
src/Core/Validation/ConstraintValidator.php
View File

@ -35,9 +35,9 @@ class ConstraintValidator
/** @var ConstraintViolationInterface $violation */
foreach ($violations as $violation) {
if ($fieldName) {
$result->addFieldError($fieldName, $violation->getMessage());
$result->addFieldError($fieldName, $violation->getMessage(), value: $value);
} else {
$result->addError($violation->getMessage());
$result->addError($violation->getMessage(), value: $value);
}
}

48
src/Core/Validation/FieldValidation/AbstractSymfonyFieldValidator.php Normal file
View File

@ -0,0 +1,48 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\ConstraintValidator;
use SilverStripe\Core\Validation\FieldValidation\StringFieldValidator;
/**
* Abstract class for validators that use Symfony constraints
*/
abstract class AbstractSymfonyFieldValidator extends StringFieldValidator
{
protected function validateValue(): ValidationResult
{
$result = parent::validateValue();
if (!$result->isValid()) {
return $result;
}
$constraintClass = $this->getConstraintClass();
$args = [
...$this->getContraintNamedArgs(),
'message' => $this->getMessage(),
];
$constraint = new $constraintClass(...$args);
$validationResult = ConstraintValidator::validate($this->value, $constraint, $this->name);
return $result->combineAnd($validationResult);
}
/**
* The symfony constraint class to use
*/
abstract protected function getConstraintClass(): string;
/**
* The named args to pass to the constraint
* Defined named args as assoc array keys
*/
protected function getContraintNamedArgs(): array
{
return [];
}
/**
* The message to use when the value is invalid
*/
abstract protected function getMessage(): string;
}

37
src/Core/Validation/FieldValidation/BigIntFieldValidator.php Normal file
View File

@ -0,0 +1,37 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\FieldValidation\IntFieldValidator;
class BigIntFieldValidator extends IntFieldValidator
{
/**
* The minimum value for a signed 64-bit integer.
* Defined as string instead of int otherwise will end up as a float
* on 64-bit systems if defined as an int
*/
private const MIN_64_BIT_INT = '-9223372036854775808';
/**
* The maximum value for a signed 64-bit integer.
*/
private const MAX_64_BIT_INT = '9223372036854775807';
public function __construct(
string $name,
mixed $value,
bool $skipIfNull,
?int $minValue = null,
?int $maxValue = null
) {
if (is_null($minValue)) {
// Casting the string const to an int will properly return an int on 64-bit systems
$minValue = (int) BigIntFieldValidator::MIN_64_BIT_INT;
}
if (is_null($maxValue)) {
$maxValue = (int) BigIntFieldValidator::MAX_64_BIT_INT;
}
parent::__construct($name, $value, $skipIfNull, $minValue, $maxValue);
}
}

23
src/Core/Validation/FieldValidation/BooleanIntFieldValidator.php Normal file
View File

@ -0,0 +1,23 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
/**
* Validates value is boolean stored as an integer i.e. 1 or 0
* true and false are not valid values
*/
class BooleanIntFieldValidator extends FieldValidator
{
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
if ($this->value !== 1 && $this->value !== 0) {
$message = _t(__CLASS__ . '.INVALID', 'Invalid value');
$result->addFieldError($this->name, $message, value: $this->value);
}
return $result;
}
}

37
src/Core/Validation/FieldValidation/CompositeFieldValidator.php Normal file
View File

@ -0,0 +1,37 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use InvalidArgumentException;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
use SilverStripe\Core\Validation\FieldValidation\FieldValidationInterface;
class CompositeFieldValidator extends FieldValidator
{
public function __construct(string $name, mixed $value, bool $skipIfNull)
{
parent::__construct($name, $value, $skipIfNull);
if (!is_iterable($value)) {
if (is_null($value) && $skipIfNull) {
$value = [];
} else {
throw new InvalidArgumentException('Value must be iterable');
}
}
foreach ($value as $child) {
if (!is_a($child, FieldValidationInterface::class)) {
throw new InvalidArgumentException('Child is not a' . FieldValidationInterface::class);
}
}
}
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
foreach ($this->value as $child) {
$result->combineAnd($child->validate());
}
return $result;
}
}

35
src/Core/Validation/FieldValidation/DateFieldValidator.php Normal file
View File

@ -0,0 +1,35 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
use SilverStripe\Core\Validation\ValidationResult;
/**
* Validates that a value is a valid date, which means that it follows the equivalent formats:
* - PHP date format Y-m-d
* - SO format y-MM-dd i.e. DBDate::ISO_DATE
*/
class DateFieldValidator extends FieldValidator
{
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
// Not using symfony/validator because it was allowing d-m-Y format strings
$date = date_parse_from_format($this->getFormat(), $this->value ?? '');
if ($date === false || $date['error_count'] > 0 || $date['warning_count'] > 0) {
$result->addFieldError($this->name, $this->getMessage());
}
return $result;
}
protected function getFormat(): string
{
return 'Y-m-d';
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid date');
}
}

23
src/Core/Validation/FieldValidation/DatetimeFieldValidator.php Normal file
View File

@ -0,0 +1,23 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\FieldValidation\DateFieldValidator;
/**
* Validates that a value is a valid date/time, which means that it follows the equivalent formats:
* - PHP date format Y-m-d H:i:s
* - ISO format 'y-MM-dd HH:mm:ss' i.e. DBDateTime::ISO_DATETIME
*/
class DatetimeFieldValidator extends DateFieldValidator
{
protected function getFormat(): string
{
return 'Y-m-d H:i:s';
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid date/time');
}
}

61
src/Core/Validation/FieldValidation/DecimalFieldValidator.php Normal file
View File

@ -0,0 +1,61 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\NumericFieldValidator;
class DecimalFieldValidator extends NumericFieldValidator
{
/**
* Whole number size e.g. For Decimal(9,2) this would be 9
*/
private int $wholeSize;
/**
* Decimal size e.g. For Decimal(5,2) this would be 2
*/
private int $decimalSize;
public function __construct(string $name, mixed $value, bool $skipIfNull, int $wholeSize, int $decimalSize)
{
parent::__construct($name, $value, $skipIfNull);
$this->wholeSize = $wholeSize;
$this->decimalSize = $decimalSize;
}
protected function validateValue(): ValidationResult
{
$result = parent::validateValue();
if (!$result->isValid()) {
return $result;
}
// Example of how digits are stored in the database
// Decimal(5,2) is allowed a total of 5 digits, and will always round to 2 decimal places
// This means it has a maximum 3 digits before the decimal point
//
// Valid
// 123.99
// 999.99
// -999.99
// 123.999 - will round to 124.00
//
// Not valid
// 1234.9 - 4 digits the before the decimal point
// 999.999 - would be rounted to 10000000.00 which exceeds the 9 digits
// Convert to absolute value - any the minus sign is not counted
$absValue = abs($this->value);
// Round to the decimal size which is what the database will do
$rounded = round($absValue, $this->decimalSize);
// Get formatted as a string, which will right pad with zeros to the decimal size
$rounded = number_format($rounded, $this->decimalSize, thousands_separator: '');
// Count this number of digits - the minus 1 is for the decimal point
$digitCount = strlen((string) $rounded) - 1;
if ($digitCount > $this->wholeSize) {
$message = _t(__CLASS__ . '.TOOLARGE', 'Number is too large');
$result->addFieldError($this->name, $message, value: $this->value);
}
return $result;
}
}

19
src/Core/Validation/FieldValidation/EmailFieldValidator.php Normal file
View File

@ -0,0 +1,19 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use Symfony\Component\Validator\Constraints;
use SilverStripe\Core\Validation\FieldValidation\AbstractSymfonyFieldValidator;
class EmailFieldValidator extends AbstractSymfonyFieldValidator
{
protected function getConstraintClass(): string
{
return Constraints\Email::class;
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid email address');
}
}

27
src/Core/Validation/FieldValidation/EnumFieldValidator.php Normal file
View File

@ -0,0 +1,27 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
class EnumFieldValidator extends FieldValidator
{
protected array $allowedValues;
public function __construct(string $name, mixed $value, bool $skipIfNull, array $allowedValues)
{
parent::__construct($name, $value, $skipIfNull);
$this->allowedValues = $allowedValues;
}
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
if (!in_array($this->value, $this->allowedValues, true)) {
$message = _t(__CLASS__ . '.NOTALLOWED', 'Not an allowed value');
$result->addFieldError($this->name, $message, value: $this->value);
}
return $result;
}
}

14
src/Core/Validation/FieldValidation/FieldValidationInterface.php Normal file
View File

@ -0,0 +1,14 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationInterface;
interface FieldValidationInterface extends ValidationInterface
{
public function getName(): string;
public function getValueForValidation(): mixed;
public function getSkipValidationIfNull(): bool;
}

44
src/Core/Validation/FieldValidation/FieldValidator.php Normal file
View File

@ -0,0 +1,44 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\ValidationInterface;
/**
* Abstract class that can be used as a validator for FormFields and DBFields
*/
abstract class FieldValidator implements ValidationInterface
{
protected string $name;
protected mixed $value;
private bool $skipIfNull;
public function __construct(string $name, mixed $value, bool $skipIfNull)
{
$this->name = $name;
$this->value = $value;
$this->skipIfNull = $skipIfNull;
}
/**
* Validate the value
*/
public function validate(): ValidationResult
{
$result = ValidationResult::create();
if (is_null($this->value) && $this->skipIfNull) {
return $result;
}
$validationResult = $this->validateValue($result);
if (!$validationResult->isValid()) {
$result->combineAnd($validationResult);
}
return $result;
}
/**
* Inner validatation method that that is implemented by subclasses
*/
abstract protected function validateValue(): ValidationResult;
}

143
src/Core/Validation/FieldValidation/FieldValidatorsTrait.php Normal file
View File

@ -0,0 +1,143 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use RuntimeException;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Validation\FieldValidation\FieldValidationInterface;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Forms\FormField;
trait FieldValidatorsTrait
{
/**
* FieldValidators configuration for the field, which is either a FormField or DBField
*
* Each item in the array can be one of the following
* a) MyFieldValidator::class,
* b) MyFieldValidator::class => [null, 'getMyArg'],
* c) MyFieldValidator::class => null,
*
* a) Will create a FieldValidator and pass the name and value of the field as args to the constructor
* b) Will create a FieldValidator and pass the name, value, make a pass additional args, calling each
* non-null value on the field e.g. it will skip the first arg and call $field->getMyArg() for the second arg
* c) Will disable a previously set FieldValidator. This is useful to disable a FieldValidator that was set
* on a parent class
*
* You may only have a single instance of a FieldValidator class per field
*/
private static array $field_validators = [];
/**
* Used by FieldValidator to skip validation if the field is null
*/
protected bool $skipValidationIfNull = false;
/**
* Get whether this field should skip validation if it is null
* There is intentionally no setter for this
*/
public function getSkipValidationIfNull(): bool
{
return $this->skipValidationIfNull;
}
/**
* Get the value of this field for field validation
* Override this method in your class to return the value you want to validate
* If it's different from what's normally returned in getValue();
*/
public function getValueForValidation(): mixed
{
return $this->getValue();
}
/**
* Validate this field
*/
public function validate(): ValidationResult
{
$result = ValidationResult::create();
$fieldValidators = $this->getFieldValidators();
foreach ($fieldValidators as $fieldValidator) {
$validationResult = $fieldValidator->validate();
if (!$validationResult->isValid()) {
$result->combineAnd($validationResult);
}
}
return $result;
}
/**
* Get FieldValidators based on `field_validators` configuration
*/
private function getFieldValidators(): array
{
$fieldValidators = [];
// Used to disable a validator that was previously set with an int index
$disabledClasses = [];
$interface = FieldValidationInterface::class;
// temporary check, will make FormField implement FieldValidationInterface in a future PR
$tmp = FormField::class;
if (!is_a($this, $interface) && !is_a($this, $tmp)) {
$class = get_class($this);
throw new RuntimeException("Class $class does not implement interface $interface");
}
/** @var FieldValidationInterface|Configurable $this */
$name = $this->getName();
$value = $this->getValueForValidation();
$skipIfNull = $this->getSkipValidationIfNull();
// Field name is required for FieldValidators when called ValidationResult::addFieldMessage()
if ($name === '') {
throw new RuntimeException('Field name is blank');
}
$classes = [];
$config = $this->config()->get('field_validators');
foreach ($config as $indexOrClass => $classOrArgCallsOrDisable) {
$class = '';
$argCalls = [];
$disable = false;
if (is_int($indexOrClass)) {
$class = $classOrArgCallsOrDisable;
} else {
$class = $indexOrClass;
$argCalls = $classOrArgCallsOrDisable;
$disable = $classOrArgCallsOrDisable === null;
}
if ($disable) {
$disabledClasses[$class] = true;
continue;
} else {
if (isset($disabledClasses[$class])) {
unset($disabledClasses[$class]);
}
}
if (!is_a($class, FieldValidator::class, true)) {
throw new RuntimeException("Class $class is not a FieldValidator");
}
if (!is_array($argCalls)) {
throw new RuntimeException("argCalls for FieldValidator $class is not an array");
}
$classes[$class] = $argCalls;
}
foreach (array_keys($disabledClasses) as $class) {
unset($classes[$class]);
}
foreach ($classes as $class => $argCalls) {
$args = [$name, $value, $skipIfNull];
foreach ($argCalls as $i => $argCall) {
if (!is_string($argCall) && !is_null($argCall)) {
throw new RuntimeException("argCall $i for FieldValidator $class is not a string or null");
}
if ($argCall) {
$args[] = call_user_func([$this, $argCall]);
} else {
$args[] = null;
}
}
$fieldValidators[$class] = Injector::inst()->createWithArgs($class, $args);
}
return array_values($fieldValidators);
}
}

47
src/Core/Validation/FieldValidation/IntFieldValidator.php Normal file
View File

@ -0,0 +1,47 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\NumericFieldValidator;
class IntFieldValidator extends NumericFieldValidator
{
/**
* The minimum value for a signed 32-bit integer.
* Defined as string instead of int because be cast to a float
* on 32-bit systems if defined as an int
*/
private const MIN_32_BIT_INT = '-2147483648';
/**
* The maximum value for a signed 32-bit integer.
*/
private const MAX_32_BIT_INT = '2147483647';
public function __construct(
string $name,
mixed $value,
bool $skipIfNull,
?int $minValue = null,
?int $maxValue = null
) {
if (is_null($minValue)) {
$minValue = (int) IntFieldValidator::MIN_32_BIT_INT;
}
if (is_null($maxValue)) {
$maxValue = (int) IntFieldValidator::MAX_32_BIT_INT;
}
parent::__construct($name, $value, $skipIfNull, $minValue, $maxValue);
}
protected function validateValue(): ValidationResult
{
$result = parent::validateValue();
if (!is_int($this->value)) {
$message = _t(__CLASS__ . '.NOTINT', 'Not an integer');
$result->addFieldError($this->name, $message, value: $this->value);
}
return $result;
}
}

30
src/Core/Validation/FieldValidation/IpFieldValidator.php Normal file
View File

@ -0,0 +1,30 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use Symfony\Component\Validator\Constraints;
use SilverStripe\Core\Validation\FieldValidation\AbstractSymfonyFieldValidator;
/**
* Validator for IP addresses. Accepts both IPv4 and IPv6.
*/
class IpFieldValidator extends AbstractSymfonyFieldValidator
{
protected function getConstraintClass(): string
{
return Constraints\Ip::class;
}
protected function getContraintNamedArgs(): array
{
return [
// Allow both IPv4 and IPv6
'version' => Constraints\Ip::ALL,
];
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid IP address');
}
}

22
src/Core/Validation/FieldValidation/LocaleFieldValidator.php Normal file
View File

@ -0,0 +1,22 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use Symfony\Component\Validator\Constraints;
use SilverStripe\Core\Validation\FieldValidation\AbstractSymfonyFieldValidator;
/**
* Validates that a value is a valid locale, e.g. de, de_DE)
*/
class LocaleFieldValidator extends AbstractSymfonyFieldValidator
{
protected function getConstraintClass(): string
{
return Constraints\Locale::class;
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid locale');
}
}

31
src/Core/Validation/FieldValidation/MultiEnumFieldValidator.php Normal file
View File

@ -0,0 +1,31 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use InvalidArgumentException;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\EnumFieldValidator;
class MultiEnumFieldValidator extends EnumFieldValidator
{
public function __construct(string $name, mixed $value, bool $skipIfNull, array $allowedValues)
{
if (!is_array($value)) {
throw new InvalidArgumentException('Value must be an array');
}
parent::__construct($name, $value, $skipIfNull, $allowedValues);
}
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
foreach ($this->value as $value) {
if (!in_array($value, $this->allowedValues, true)) {
$message = _t(__CLASS__ . '.NOTALLOWED', 'Not an allowed value');
$result->addFieldError($this->name, $message, value: $value);
break;
}
}
return $result;
}
}

49
src/Core/Validation/FieldValidation/NumericFieldValidator.php Normal file
View File

@ -0,0 +1,49 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
class NumericFieldValidator extends FieldValidator
{
/**
* Minimum size of the number
*/
private ?int $minValue;
/**
* Maximum size of the number
*/
private ?int $maxValue;
public function __construct(
string $name,
mixed $value,
bool $skipIfNull,
?int $minValue = null,
?int $maxValue = null
) {
$this->minValue = $minValue;
$this->maxValue = $maxValue;
parent::__construct($name, $value, $skipIfNull);
}
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
if (!is_numeric($this->value) || is_string($this->value)) {
// Must be a numeric value, though not as a numeric string
$message = _t(__CLASS__ . '.NOTNUMERIC', 'Must be a number');
$result->addFieldError($this->name, $message, value: $this->value);
return $result;
} elseif (isset($this->minValue) && $this->value < $this->minValue) {
$message = _t(__CLASS__ . '.TOOSMALL', 'Value is too small');
$result->addFieldError($this->name, $message, value: $this->value);
} elseif (isset($this->maxValue) && $this->value > $this->maxValue) {
$message = _t(__CLASS__ . '.TOOLARGE', 'Value is too large');
$result->addFieldError($this->name, $message, value: $this->value);
}
return $result;
}
}

70
src/Core/Validation/FieldValidation/StringFieldValidator.php Normal file
View File

@ -0,0 +1,70 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use InvalidArgumentException;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
/**
* Validates that a value is a string and optionally checks its multi-byte length.
*/
class StringFieldValidator extends FieldValidator
{
/**
* The minimum length of the string
*/
private ?int $minLength;
/**
* The maximum length of the string
*/
private ?int $maxLength;
public function __construct(
string $name,
mixed $value,
bool $skipIfNull,
?int $minLength = null,
?int $maxLength = null
) {
parent::__construct($name, $value, $skipIfNull);
if ($minLength && $minLength < 0) {
throw new InvalidArgumentException('minLength must be greater than or equal to 0');
}
$this->minLength = $minLength;
$this->maxLength = $maxLength;
}
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
if (!is_string($this->value)) {
$message = _t(__CLASS__ . '.INVALID', 'Must be a string');
$result->addFieldError($this->name, $message, value: $this->value);
return $result;
}
// Blank strings are valid, even if there's a minLength requirement
if ($this->value === '') {
return $result;
}
$len = mb_strlen($this->value);
if (!is_null($this->minLength) && $len < $this->minLength) {
$message = _t(
__CLASS__ . '.TOOSHORT',
'Must have at least {minLength} characters',
['minLength' => $this->minLength]
);
$result->addFieldError($this->name, $message, value: $this->value);
}
if (!is_null($this->maxLength) && $len > $this->maxLength) {
$message = _t(
__CLASS__ . '.TOOLONG',
'Can not have more than {maxLength} characters',
['maxLength' => $this->maxLength]
);
$result->addFieldError($this->name, $message, value: $this->value);
}
return $result;
}
}

23
src/Core/Validation/FieldValidation/TimeFieldValidator.php Normal file
View File

@ -0,0 +1,23 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\FieldValidation\DateFieldValidator;
/**
* Validates that a value is a valid time, which means that it follows the equivalent formats:
* - PHP date format H:i:s
* - ISO format 'HH:mm:ss' i.e. DBTime::ISO_TIME
*/
class TimeFieldValidator extends DateFieldValidator
{
protected function getFormat(): string
{
return 'H:i:s';
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid time');
}
}

19
src/Core/Validation/FieldValidation/UrlFieldValidator.php Normal file
View File

@ -0,0 +1,19 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use Symfony\Component\Validator\Constraints;
use SilverStripe\Core\Validation\FieldValidation\AbstractSymfonyFieldValidator;
class UrlFieldValidator extends AbstractSymfonyFieldValidator
{
protected function getConstraintClass(): string
{
return Constraints\Url::class;
}
protected function getMessage(): string
{
return _t(__CLASS__ . '.INVALID', 'Invalid URL');
}
}

42
src/Core/Validation/FieldValidation/YearFieldValidator.php Normal file
View File

@ -0,0 +1,42 @@
<?php
namespace SilverStripe\Core\Validation\FieldValidation;
use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
/**
* Validates that a value is a valid year greater than 1901, which is the minimum year in MySQL
*
* Years must be a four digit number greater than 1901, or be between 0 or 99
* 0 is used to represent a null value which will be stored as 0000 in MySQL
* '00' and '0000' are special valid years that may also be used to represent 2000 and null respectively
*
* Both string and integer values are accepted
*
* https://dev.mysql.com/doc/refman/8.0/en/year.html
*/
class YearFieldValidator extends FieldValidator
{
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
if ($this->value === '00' || $this->value === '0000') {
return $result;
}
if (!is_int($this->value) && !(is_string($this->value))
|| !preg_match('#^\d+$#', (string) $this->value)
) {
$message = _t(__CLASS__ . '.INVALID', 'Must be an integer or integer string');
$result->addFieldError($this->name, $message, value: $this->value);
return $result;
}
$int = (int) $this->value;
if ($int < 0 || ($int > 99 && $int < 1901) || $int > 2155) {
$message = _t(__CLASS__ . '.INVALID', 'Invalid year');
$result->addFieldError($this->name, $message, value: $this->value);
return $result;
}
return $result;
}
}

10
src/Core/Validation/ValidationInterface.php Normal file
View File

@ -0,0 +1,10 @@
<?php
namespace SilverStripe\Core\Validation;
use SilverStripe\Core\Validation\ValidationResult;
interface ValidationInterface
{
public function validate(): ValidationResult;
}

43
src/Core/Validation/ValidationResult.php
View File

@ -46,6 +46,11 @@ class ValidationResult
*/
const CAST_TEXT = 'text';
/**
* Default value of $value parameter
*/
private const VALUE_UNSET = '_VALUE_UNSET_';
/**
* Is the result valid or not.
* Note that there can be non-error messages in the list.
@ -71,11 +76,17 @@ class ValidationResult
* This can be usedful for ensuring no duplicate messages
* @param string|bool $cast Cast type; One of the CAST_ constant definitions.
* Bool values will be treated as plain text flag.
* @param mixed $value The value that failed validation
* @return $this
*/
public function addError($message, $messageType = ValidationResult::TYPE_ERROR, $code = null, $cast = ValidationResult::CAST_TEXT)
{
return $this->addFieldError(null, $message, $messageType, $code, $cast);
public function addError(
$message,
$messageType = ValidationResult::TYPE_ERROR,
$code = null,
$cast = ValidationResult::CAST_TEXT,
$value = ValidationResult::VALUE_UNSET,
) {
return $this->addFieldError(null, $message, $messageType, $code, $cast, $value);
}
/**
@ -89,6 +100,7 @@ class ValidationResult
* This can be usedful for ensuring no duplicate messages
* @param string|bool $cast Cast type; One of the CAST_ constant definitions.
* Bool values will be treated as plain text flag.
* @param mixed $value The value that failed validation
* @return $this
*/
public function addFieldError(
@ -96,10 +108,11 @@ class ValidationResult
$message,
$messageType = ValidationResult::TYPE_ERROR,
$code = null,
$cast = ValidationResult::CAST_TEXT
$cast = ValidationResult::CAST_TEXT,
$value = ValidationResult::VALUE_UNSET,
) {
$this->isValid = false;
return $this->addFieldMessage($fieldName, $message, $messageType, $code, $cast);
return $this->addFieldMessage($fieldName, $message, $messageType, $code, $cast, $value);
}
/**
@ -112,11 +125,17 @@ class ValidationResult
* This can be usedful for ensuring no duplicate messages
* @param string|bool $cast Cast type; One of the CAST_ constant definitions.
* Bool values will be treated as plain text flag.
* @param mixed $value The value that failed validation
* @return $this
*/
public function addMessage($message, $messageType = ValidationResult::TYPE_ERROR, $code = null, $cast = ValidationResult::CAST_TEXT)
{
return $this->addFieldMessage(null, $message, $messageType, $code, $cast);
public function addMessage(
$message,
$messageType = ValidationResult::TYPE_ERROR,
$code = null,
$cast = ValidationResult::CAST_TEXT,
$value = ValidationResult::VALUE_UNSET,
) {
return $this->addFieldMessage(null, $message, $messageType, $code, $cast, $value);
}
/**
@ -130,6 +149,7 @@ class ValidationResult
* This can be usedful for ensuring no duplicate messages
* @param string|bool $cast Cast type; One of the CAST_ constant definitions.
* Bool values will be treated as plain text flag.
* @param mixed $value The value that failed validation
* @return $this
*/
public function addFieldMessage(
@ -137,7 +157,8 @@ class ValidationResult
$message,
$messageType = ValidationResult::TYPE_ERROR,
$code = null,
$cast = ValidationResult::CAST_TEXT
$cast = ValidationResult::CAST_TEXT,
$value = ValidationResult::VALUE_UNSET,
) {
if ($code && is_numeric($code)) {
throw new InvalidArgumentException("Don't use a numeric code '$code'. Use a string.");
@ -151,7 +172,9 @@ class ValidationResult
'messageType' => $messageType,
'messageCast' => $cast,
];
if ($value !== ValidationResult::VALUE_UNSET) {
$metadata['value'] = $value;
}
if ($code) {
$this->messages[$code] = $metadata;
} else {

4
src/Forms/CompositeField.php
View File

@ -119,10 +119,8 @@ class CompositeField extends FormField
* Returns the name (ID) for the element.
* If the CompositeField doesn't have a name, but we still want the ID/name to be set.
* This code generates the ID from the nested children.
*
* @return String $name
*/
public function getName()
public function getName(): string
{
if ($this->name) {
return $this->name;

28
src/Forms/EmailField.php
View File

@ -2,14 +2,17 @@
namespace SilverStripe\Forms;
use SilverStripe\Core\Validation\ConstraintValidator;
use Symfony\Component\Validator\Constraints\Email as EmailConstraint;
use SilverStripe\Core\Validation\FieldValidation\EmailValidator;
/**
* Text input field with validation for correct email format according to the relevant RFC.
*/
class EmailField extends TextField
{
private static array $field_validators = [
EmailValidator::class,
];
protected $inputType = 'email';
public function Type()
@ -17,27 +20,6 @@ class EmailField extends TextField
return 'email text';
}
/**
* Validates for RFC compliant email addresses.
*
* @param Validator $validator
*/
public function validate($validator)
{
$this->value = trim($this->value ?? '');
$message = _t('SilverStripe\\Forms\\EmailField.VALIDATION', 'Please enter an email address');
$result = ConstraintValidator::validate(
$this->value,
new EmailConstraint(message: $message, mode: EmailConstraint::VALIDATION_MODE_STRICT),
$this->getName()
);
$validator->getResult()->combineAnd($result);
$isValid = $result->isValid();
return $this->extendValidationResult($isValid, $validator);
}
public function getSchemaValidation()
{
$rules = parent::getSchemaValidation();

2
src/Forms/FieldGroup.php
View File

@ -106,7 +106,7 @@ class FieldGroup extends CompositeField
* In some cases the FieldGroup doesn't have a title, but we still want
* the ID / name to be set. This code, generates the ID from the nested children
*/
public function getName()
public function getName(): string
{
if ($this->name) {
return $this->name;

37
src/Forms/FormField.php
View File

@ -15,6 +15,7 @@ use SilverStripe\Core\Validation\ValidationResult;
use SilverStripe\View\AttributesHTML;
use SilverStripe\View\SSViewer;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\FieldValidatorsTrait;
/**
* Represents a field in a form.
@ -44,6 +45,7 @@ class FormField extends RequestHandler
{
use AttributesHTML;
use FormMessage;
use FieldValidatorsTrait;
/** @see $schemaDataType */
const SCHEMA_DATA_TYPE_STRING = 'String';
@ -424,12 +426,10 @@ class FormField extends RequestHandler
/**
* Returns the field name.
*
* @return string
*/
public function getName()
public function getName(): string
{
return $this->name;
return $this->name ?? '';
}
/**
@ -443,12 +443,20 @@ class FormField extends RequestHandler
}
/**
* Returns the field value.
* Alias of getValue()
*
* @see FormField::setSubmittedValue()
* @return mixed
*/
public function Value()
{
return $this->getValue();
}
/**
* Returns the field value.
*/
public function getValue(): mixed
{
return $this->value;
}
@ -1231,15 +1239,28 @@ class FormField extends RequestHandler
}
/**
* Abstract method each {@link FormField} subclass must implement, determines whether the field
* is valid or not based on the value.
* Subclasses can define an existing FieldValidatorClass to validate the FormField value
* They may also override this method to provide custom validation logic
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
return $this->extendValidationResult(true, $validator);
$isValid = true;
$result = ValidationResult::create();
$fieldValidators = $this->getFieldValidators();
foreach ($fieldValidators as $fieldValidator) {
$validationResult = $fieldValidator->validate();
if (!$validationResult->isValid()) {
$result->combineAnd($validationResult);
}
}
if (!$result->isValid()) {
$isValid = false;
$validator->getResult()->combineAnd($result);
}
return $this->extendValidationResult($isValid, $validator);
}
/**

2
src/Forms/SelectionGroup_Item.php
View File

@ -43,7 +43,7 @@ class SelectionGroup_Item extends CompositeField
return $this;
}
function getValue()
function getValue(): mixed
{
return $this->value;
}

31
src/Forms/TextField.php
View File

@ -2,6 +2,8 @@
namespace SilverStripe\Forms;
use SilverStripe\Core\Validation\FieldValidation\StringFieldValidator;
/**
* Text input field.
*/
@ -14,6 +16,10 @@ class TextField extends FormField implements TippableFieldInterface
protected $schemaDataType = FormField::SCHEMA_DATA_TYPE_TEXT;
private static array $field_validators = [
StringFieldValidator::class => [null, 'getMaxLength'],
];
/**
* @var Tip|null A tip to render beside the input
*/
@ -117,31 +123,6 @@ class TextField extends FormField implements TippableFieldInterface
return $data;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$result = true;
if (!is_null($this->maxLength) && mb_strlen($this->value ?? '') > $this->maxLength) {
$name = strip_tags($this->Title() ? $this->Title() : $this->getName());
$validator->validationError(
$this->name,
_t(
'SilverStripe\\Forms\\TextField.VALIDATEMAXLENGTH',
'The value for {name} must not exceed {maxLength} characters in length',
['name' => $name, 'maxLength' => $this->maxLength]
),
"validation"
);
$result = false;
}
return $this->extendValidationResult($result, $validator);
}
public function getSchemaValidation()
{
$rules = parent::getSchemaValidation();

12
src/ORM/DataObject.php
View File

@ -1230,6 +1230,15 @@ class DataObject extends ModelData implements DataObjectInterface, i18nEntityPro
public function validate()
{
$result = ValidationResult::create();
// Call DBField::validate() on every DBField
$specs = static::getSchema()->fieldSpecs(static::class);
foreach (array_keys($specs) as $fieldName) {
$dbField = $this->dbObject($fieldName);
$validationResult = $dbField->validate();
if (!$validationResult->isValid()) {
$result->combineAnd($validationResult);
}
}
$this->extend('updateValidate', $result);
return $result;
}
@ -3268,6 +3277,9 @@ class DataObject extends ModelData implements DataObjectInterface, i18nEntityPro
/** @var DBField $obj */
$table = $schema->tableName($class);
$obj = Injector::inst()->create($spec, $fieldName);
if (is_null($value)) {
$value = $obj->getDefaultValue();
}
$obj->setTable($table);
$obj->setValue($value, $this, false);
return $obj;

13
src/ORM/FieldType/DBBigInt.php
View File

@ -2,18 +2,24 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Validation\FieldValidation\IntFieldValidator;
use SilverStripe\Core\Validation\FieldValidation\BigIntFieldValidator;
use SilverStripe\ORM\DB;
/**
* Represents a signed 8 byte integer field. Do note PHP running as 32-bit might not work with Bigint properly, as it
* would convert the value to a float when queried from the database since the value is a 64-bit one.
*
* @package framework
* @subpackage model
* @see Int
* BigInt is always signed i.e. can be negative
* Their range is -9223372036854775808 to 9223372036854775807
*/
class DBBigInt extends DBInt
{
private static array $field_validators = [
// Remove parent validator and add BigIntValidator instead
IntFieldValidator::class => null,
BigIntFieldValidator::class,
];
public function requireField(): void
{
@ -24,7 +30,6 @@ class DBBigInt extends DBInt
'default' => $this->defaultVal,
'arrayValue' => $this->arrayValue
];
$values = ['type' => 'bigint', 'parts' => $parts];
DB::require_field($this->tableName, $this->name, $values);
}

28
src/ORM/FieldType/DBBoolean.php
View File

@ -2,6 +2,7 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Validation\FieldValidation\BooleanIntFieldValidator;
use SilverStripe\Forms\CheckboxField;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\FormField;
@ -9,13 +10,18 @@ use SilverStripe\ORM\DB;
use SilverStripe\Model\ModelData;
/**
* Represents a boolean field.
* Represents a boolean field
* Values are stored as a tinyint i.e. 1 or 0 and NOT as true or false
*/
class DBBoolean extends DBField
{
private static array $field_validators = [
BooleanIntFieldValidator::class,
];
public function __construct(?string $name = null, bool|int $defaultVal = 0)
{
$this->defaultVal = ($defaultVal) ? 1 : 0;
$this->setDefaultValue($defaultVal ? 1 : 0);
parent::__construct($name);
}
@ -34,6 +40,13 @@ class DBBoolean extends DBField
DB::require_field($this->tableName, $this->name, $values);
}
public function setValue(mixed $value, null|array|ModelData $record = null, bool $markChanged = true): static
{
parent::setValue($value);
$this->value = $this->convertBooleanLikeValueToTinyInt($value);
return $this;
}
public function Nice(): string
{
return ($this->value) ? _t(__CLASS__ . '.YESANSWER', 'Yes') : _t(__CLASS__ . '.NOANSWER', 'No');
@ -83,6 +96,11 @@ class DBBoolean extends DBField
}
public function prepValueForDB(mixed $value): array|int|null
{
return $this->convertBooleanLikeValueToTinyInt($value);
}
private function convertBooleanLikeValueToTinyInt(mixed $value): mixed
{
if (is_bool($value)) {
return $value ? 1 : 0;
@ -94,12 +112,16 @@ class DBBoolean extends DBField
switch (strtolower($value ?? '')) {
case 'false':
case 'f':
case '0':
return 0;
case 'true':
case 't':
case '1':
return 1;
}
}
return $value ? 1 : 0;
// Note that something like "lorem" will NOT be converted to 1
// instead it will throw a ValidationException in BooleanIntFieldValidator
return $value;
}
}

7
src/ORM/FieldType/DBComposite.php
View File

@ -8,6 +8,7 @@ use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DB;
use SilverStripe\ORM\Queries\SQLSelect;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\CompositeFieldValidator;
/**
* Extend this class when designing a {@link DBField} that doesn't have a 1-1 mapping with a database field.
@ -25,6 +26,12 @@ use SilverStripe\Model\ModelData;
*/
abstract class DBComposite extends DBField
{
private static array $field_validators = [
CompositeFieldValidator::class,
];
protected bool $skipValidationIfNull = true;
/**
* Similar to {@link DataObject::$db},
* holds an array of composite field names.

65
src/ORM/FieldType/DBDate.php
View File

@ -12,6 +12,7 @@ use SilverStripe\ORM\DB;
use SilverStripe\Security\Member;
use SilverStripe\Security\Security;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\DateFieldValidator;
/**
* Represents a date field.
@ -33,6 +34,7 @@ class DBDate extends DBField
{
/**
* Standard ISO format string for date in CLDR standard format
* This is equivalent to php date format "Y-m-d" e.g. 2024-08-31
*/
public const ISO_DATE = 'y-MM-dd';
@ -42,13 +44,16 @@ class DBDate extends DBField
*/
public const ISO_LOCALE = 'en_US';
private static array $field_validators = [
DateFieldValidator::class,
];
protected bool $skipValidationIfNull = true;
public function setValue(mixed $value, null|array|ModelData $record = null, bool $markChanged = true): static
{
$value = $this->parseDate($value);
if ($value === false) {
throw new InvalidArgumentException(
"Invalid date: '$value'. Use " . DBDate::ISO_DATE . " to prevent this error."
);
if ($value !== null) {
$value = $this->parseDate($value);
}
$this->value = $value;
return $this;
@ -58,15 +63,10 @@ class DBDate extends DBField
* Parse timestamp or iso8601-ish date into standard iso8601 format
*
* @param mixed $value
* @return string|null|false Formatted date, null if empty but valid, or false if invalid
* @return mixed Formatted date, or the original value if it couldn't be parsed
*/
protected function parseDate(mixed $value): string|null|false
{
// Skip empty values
if (empty($value) && !is_numeric($value)) {
return null;
}
// Determine value to parse
if (is_array($value)) {
$source = $value; // parse array
@ -74,19 +74,18 @@ class DBDate extends DBField
$source = $value; // parse timestamp
} else {
// Convert US date -> iso, fix y2k, etc
$value = $this->fixInputDate($value);
if (is_null($value)) {
return null;
}
$source = strtotime($value ?? ''); // convert string to timestamp
$fixedValue = $this->fixInputDate($value);
// convert string to timestamp
$source = strtotime($fixedValue ?? '');
}
if ($value === false) {
return false;
if (!$source) {
// Unable to parse date, keep as is so that the validator can catch it later
return $value;
}
// Format as iso8601
$formatter = $this->getInternalFormatter();
return $formatter->format($source);
$ret = $formatter->format($source);
return $ret;
}
/**
@ -560,20 +559,12 @@ class DBDate extends DBField
*/
protected function fixInputDate($value)
{
// split
[$year, $month, $day, $time] = $this->explodeDateString($value);
if ((int)$year === 0 && (int)$month === 0 && (int)$day === 0) {
return null;
if (!checkdate((int) $month, (int) $day, (int) $year)) {
// Keep invalid dates as they are so that the validator can catch them later
return $value;
}
// Validate date
if (!checkdate($month ?? 0, $day ?? 0, $year ?? 0)) {
throw new InvalidArgumentException(
"Invalid date: '$value'. Use " . DBDate::ISO_DATE . " to prevent this error."
);
}
// Convert to y-m-d
// Convert to Y-m-d
return sprintf('%d-%02d-%02d%s', $year, $month, $day, $time);
}
@ -591,11 +582,8 @@ class DBDate extends DBField
$value ?? '',
$matches
)) {
throw new InvalidArgumentException(
"Invalid date: '$value'. Use " . DBDate::ISO_DATE . " to prevent this error."
);
return [0, 0, 0, ''];
}
$parts = [
$matches['first'],
$matches['second'],
@ -605,11 +593,6 @@ class DBDate extends DBField
if ($parts[0] < 1000 && $parts[2] > 1000) {
$parts = array_reverse($parts ?? []);
}
if ($parts[0] < 1000 && (int)$parts[0] !== 0) {
throw new InvalidArgumentException(
"Invalid date: '$value'. Use " . DBDate::ISO_DATE . " to prevent this error."
);
}
$parts[] = $matches['time'];
return $parts;
}

11
src/ORM/FieldType/DBDatetime.php
View File

@ -13,6 +13,8 @@ use SilverStripe\Security\Member;
use SilverStripe\Security\Security;
use SilverStripe\View\TemplateGlobalProvider;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\DatetimeFieldValidator;
use SilverStripe\Core\Validation\FieldValidation\DateFieldValidator;
/**
* Represents a date-time field.
@ -39,6 +41,7 @@ class DBDatetime extends DBDate implements TemplateGlobalProvider
/**
* Standard ISO format string for date and time in CLDR standard format,
* with a whitespace separating date and time (common database representation, e.g. in MySQL).
* This is equivalent to php date format "Y-m-d H:i:s" e.g. 2024-08-31 09:30:00
*/
public const ISO_DATETIME = 'y-MM-dd HH:mm:ss';
@ -48,10 +51,16 @@ class DBDatetime extends DBDate implements TemplateGlobalProvider
*/
public const ISO_DATETIME_NORMALISED = 'y-MM-dd\'T\'HH:mm:ss';
private static array $field_validators = [
DatetimeFieldValidator::class,
// disable parent validator
DateFieldValidator::class => null,
];
/**
* Flag idicating if this field is considered immutable
* when this is enabled setting the value of this field will return a new field instance
* instead updatin the old one
* instead updating the old one
*/
protected bool $immutable = false;

17
src/ORM/FieldType/DBDecimal.php
View File

@ -2,6 +2,7 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Validation\FieldValidation\DecimalFieldValidator;
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\NumericField;
use SilverStripe\ORM\DB;
@ -12,6 +13,10 @@ use SilverStripe\Model\ModelData;
*/
class DBDecimal extends DBField
{
private static array $field_validators = [
DecimalFieldValidator::class => ['getWholeSize', 'getDecimalSize'],
];
/**
* Whole number size
*/
@ -35,7 +40,7 @@ class DBDecimal extends DBField
$this->wholeSize = is_int($wholeSize) ? $wholeSize : 9;
$this->decimalSize = is_int($decimalSize) ? $decimalSize : 2;
$this->defaultValue = number_format((float) $defaultValue, $this->decimalSize);
$this->setDefaultValue(round($defaultValue, $this->decimalSize));
parent::__construct($name);
}
@ -50,6 +55,16 @@ class DBDecimal extends DBField
return floor($this->value ?? 0.0);
}
public function getWholeSize(): int
{
return $this->wholeSize;
}
public function getDecimalSize(): int
{
return $this->decimalSize;
}
public function requireField(): void
{
$parts = [

29
src/ORM/FieldType/DBEmail.php Normal file
View File

@ -0,0 +1,29 @@
<?php
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Forms\EmailField;
use SilverStripe\ORM\FieldType\DBVarchar;
use SilverStripe\Core\Validation\FieldValidation\EmailFieldValidator;
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\NullableField;
class DBEmail extends DBVarchar
{
private static array $field_validators = [
EmailFieldValidator::class,
];
public function scaffoldFormField(?string $title = null, array $params = []): ?FormField
{
// Set field with appropriate size
$field = EmailField::create($this->name, $title);
$field->setMaxLength($this->getSize());
// Allow the user to select if it's null instead of automatically assuming empty string is
if (!$this->getNullifyEmpty()) {
return NullableField::create($field);
}
return $field;
}
}

7
src/ORM/FieldType/DBEnum.php
View File

@ -3,6 +3,7 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Validation\FieldValidation\EnumFieldValidator;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\SelectField;
@ -17,6 +18,12 @@ use SilverStripe\ORM\DB;
*/
class DBEnum extends DBString
{
private static array $field_validators = [
EnumFieldValidator::class => ['getEnum'],
];
protected bool $skipValidationIfNull = false;
/**
* List of enum values
*/

16
src/ORM/FieldType/DBField.php
View File

@ -10,6 +10,8 @@ use SilverStripe\Forms\TextField;
use SilverStripe\ORM\Filters\SearchFilter;
use SilverStripe\ORM\Queries\SQLSelect;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\FieldValidatorsTrait;
use SilverStripe\Core\Validation\FieldValidation\FieldValidationInterface;
/**
* Single field in the database.
@ -41,8 +43,9 @@ use SilverStripe\Model\ModelData;
* }
* </code>
*/
abstract class DBField extends ModelData implements DBIndexable
abstract class DBField extends ModelData implements DBIndexable, FieldValidationInterface
{
use FieldValidatorsTrait;
/**
* Raw value of this field
@ -99,12 +102,14 @@ abstract class DBField extends ModelData implements DBIndexable
'ProcessedRAW' => 'HTMLFragment',
];
private static array $field_validators = [];
/**
* Default value in the database.
* Might be overridden on DataObject-level, but still useful for setting defaults on
* already existing records after a db-build.
*/
protected mixed $defaultVal = null;
private mixed $defaultValue = null;
/**
* Provide the DBField name and an array of options, e.g. ['index' => true], or ['nullifyEmpty' => false]
@ -114,6 +119,7 @@ abstract class DBField extends ModelData implements DBIndexable
public function __construct(?string $name = null, array $options = [])
{
$this->name = $name;
$this->value = $this->getDefaultValue();
if ($options) {
if (!is_array($options)) {
@ -161,7 +167,7 @@ abstract class DBField extends ModelData implements DBIndexable
*
* If you try an alter the name a warning will be thrown.
*/
public function setName(?string $name): static
public function setName(string $name): static
{
if ($this->name && $this->name !== $name) {
user_error("DBField::setName() shouldn't be called once a DBField already has a name."
@ -214,7 +220,7 @@ abstract class DBField extends ModelData implements DBIndexable
*/
public function getDefaultValue(): mixed
{
return $this->defaultVal;
return $this->defaultValue;
}
/**
@ -222,7 +228,7 @@ abstract class DBField extends ModelData implements DBIndexable
*/
public function setDefaultValue(mixed $defaultValue): static
{
$this->defaultVal = $defaultValue;
$this->defaultValue = $defaultValue;
return $this;
}

2
src/ORM/FieldType/DBFloat.php
View File

@ -13,7 +13,7 @@ class DBFloat extends DBField
{
public function __construct(?string $name = null, float|int $defaultVal = 0)
{
$this->defaultVal = is_float($defaultVal) ? $defaultVal : (float) 0;
$this->setDefaultValue(is_float($defaultVal) ? $defaultVal : (float) 0);
parent::__construct($name);
}

38
src/ORM/FieldType/DBInt.php
View File

@ -2,32 +2,52 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Validation\FieldValidation\IntFieldValidator;
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\NumericField;
use SilverStripe\Model\List\ArrayList;
use SilverStripe\ORM\DB;
use SilverStripe\Model\List\SS_List;
use SilverStripe\Model\ArrayData;
use SilverStripe\Model\ModelData;
/**
* Represents a signed 32 bit integer field.
* Represents a signed 32 bit integer field
*
* Ints are always signed i.e. they can be negative
* Their range is -2147483648 to 2147483647
*/
class DBInt extends DBField
{
private static array $field_validators = [
IntFieldValidator::class
];
public function __construct(?string $name = null, int $defaultVal = 0)
{
$this->defaultVal = is_int($defaultVal) ? $defaultVal : 0;
$this->setDefaultValue($defaultVal);
parent::__construct($name);
}
/**
* Ensure int values are always returned.
* This is for mis-configured databases that return strings.
*/
public function getValue(): ?int
public function getField($fieldName): mixed
{
return (int) $this->value;
return $this->value;
}
public function setValue(mixed $value, null|array|ModelData $record = null, bool $markChanged = true): static
{
if (is_null($value)) {
// Convert null to 0 so that it will pass validation
// Will be converted to 0 in prepValueForDB(), which is called after validation
// Methods such as DataObject::dbObject() can set this to null e.g. when a value has
// not been explicity set on a new record.
$value = 0;
} elseif (is_string($value) && preg_match('/^-?\d+$/', $value)) {
// Cast int like strings as ints
$value = (int) $value;
}
$this->value = $value;
return $this;
}
/**

13
src/ORM/FieldType/DBIp.php Normal file
View File

@ -0,0 +1,13 @@
<?php
namespace SilverStripe\ORM\FieldType;
use SilverStripe\ORM\FieldType\DBVarchar;
use SilverStripe\Core\Validation\FieldValidation\IpFieldValidator;
class DBIp extends DBVarchar
{
private static array $field_validators = [
IpFieldValidator::class,
];
}

5
src/ORM/FieldType/DBLocale.php
View File

@ -2,6 +2,7 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Validation\FieldValidation\LocaleFieldValidator;
use SilverStripe\i18n\i18n;
/**
@ -9,6 +10,10 @@ use SilverStripe\i18n\i18n;
*/
class DBLocale extends DBVarchar
{
private static array $field_validators = [
LocaleFieldValidator::class,
];
public function __construct(?string $name = null, int $size = 16)
{
parent::__construct($name, $size);

14
src/ORM/FieldType/DBMultiEnum.php
View File

@ -3,6 +3,8 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Validation\FieldValidation\EnumFieldValidator;
use SilverStripe\Core\Validation\FieldValidation\MultiEnumFieldValidator;
use SilverStripe\Forms\CheckboxSetField;
use SilverStripe\Forms\MultiSelectField;
use SilverStripe\ORM\Connect\MySQLDatabase;
@ -13,6 +15,13 @@ use SilverStripe\ORM\DB;
*/
class DBMultiEnum extends DBEnum
{
private static array $field_validators = [
// disable parent field validator
EnumFieldValidator::class => null,
// enable multi enum field validator
MultiEnumFieldValidator::class => ['getEnum'],
];
public function __construct($name = null, $enum = null, $default = null)
{
// MultiEnum needs to take care of its own defaults
@ -34,6 +43,11 @@ class DBMultiEnum extends DBEnum
}
}
public function getValueForValidation(): array
{
return explode(',', (string) $this->value);
}
public function requireField(): void
{
$charset = Config::inst()->get(MySQLDatabase::class, 'charset');

6
src/ORM/FieldType/DBPolymorphicForeignKey.php
View File

@ -5,12 +5,18 @@ namespace SilverStripe\ORM\FieldType;
use SilverStripe\Forms\FormField;
use SilverStripe\ORM\DataObject;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\CompositeFieldValidator;
/**
* A special ForeignKey class that handles relations with arbitrary class types
*/
class DBPolymorphicForeignKey extends DBComposite
{
private static array $field_validators = [
// Disable parent field validator
CompositeFieldValidator::class => null,
];
private static bool $index = true;
private static array $composite_db = [

2
src/ORM/FieldType/DBString.php
View File

@ -16,6 +16,8 @@ abstract class DBString extends DBField
'Plain' => 'Text',
];
protected bool $skipValidationIfNull = true;
/**
* Set the default value for "nullify empty"
*

13
src/ORM/FieldType/DBTime.php
View File

@ -11,6 +11,7 @@ use SilverStripe\ORM\DB;
use SilverStripe\Security\Member;
use SilverStripe\Security\Security;
use SilverStripe\Model\ModelData;
use SilverStripe\Core\Validation\FieldValidation\TimeFieldValidator;
/**
* Represents a column in the database with the type 'Time'.
@ -26,17 +27,19 @@ class DBTime extends DBField
{
/**
* Standard ISO format string for time in CLDR standard format
* This is equivalent to php date format "H:i:s" e.g. 09:30:00
*/
public const ISO_TIME = 'HH:mm:ss';
private static array $field_validators = [
TimeFieldValidator::class,
];
protected bool $skipValidationIfNull = true;
public function setValue(mixed $value, null|array|ModelData $record = null, bool $markChanged = true): static
{
$value = $this->parseTime($value);
if ($value === false) {
throw new InvalidArgumentException(
'Invalid date passed. Use ' . $this->getISOFormat() . ' to prevent this error.'
);
}
$this->value = $value;
return $this;
}

22
src/ORM/FieldType/DBUrl.php Normal file
View File

@ -0,0 +1,22 @@
<?php
namespace SilverStripe\ORM\FieldType;
use SilverStripe\ORM\FieldType\DBVarchar;
use SilverStripe\Core\Validation\FieldValidation\UrlFieldValidator;
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\UrlField;
class DBUrl extends DBVarchar
{
private static array $field_validators = [
UrlFieldValidator::class,
];
public function scaffoldFormField(?string $title = null, array $params = []): ?FormField
{
$field = UrlField::create($this->name, $title);
$field->setMaxLength($this->getSize());
return $field;
}
}

5
src/ORM/FieldType/DBVarchar.php
View File

@ -8,6 +8,7 @@ use SilverStripe\Forms\NullableField;
use SilverStripe\Forms\TextField;
use SilverStripe\ORM\Connect\MySQLDatabase;
use SilverStripe\ORM\DB;
use SilverStripe\Core\Validation\FieldValidation\StringFieldValidator;
/**
* Class Varchar represents a variable-length string of up to 255 characters, designed to store raw text
@ -18,6 +19,10 @@ use SilverStripe\ORM\DB;
*/
class DBVarchar extends DBString
{
private static array $field_validators = [
StringFieldValidator::class => [null, 'getSize'],
];
private static array $casting = [
'Initial' => 'Text',
'URL' => 'Text',

16
src/ORM/FieldType/DBYear.php
View File

@ -2,15 +2,20 @@
namespace SilverStripe\ORM\FieldType;
use SilverStripe\Core\Validation\FieldValidation\YearFieldValidator;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\FormField;
use SilverStripe\ORM\DB;
/**
* Represents a single year field.
* Represents a single year field
*/
class DBYear extends DBField
{
private static $field_validators = [
YearFieldValidator::class,
];
public function requireField(): void
{
$parts = ['datatype' => 'year', 'precision' => 4, 'arrayValue' => $this->arrayValue];
@ -25,6 +30,11 @@ class DBYear extends DBField
return $selectBox;
}
public function nullValue(): ?int
{
return 0;
}
/**
* Returns a list of default options that can
* be used to populate a select box, or compare against
@ -40,7 +50,9 @@ class DBYear extends DBField
$start = (int)date('Y');
}
if (!$end) {
$end = 1900;
// 1901 is used as it's the lowest year supported by MySQL
// https://dev.mysql.com/doc/refman/8.0/en/year.html
$end = 1901;
}
$years = [];
for ($i = $start; $i >= $end; $i--) {

75
tests/php/Core/Validation/FieldValidation/BigIntFieldValidatorTest.php Normal file
View File

@ -0,0 +1,75 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\BigIntFieldValidator;
class BigIntFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-int' => [
'value' => 123,
'expected' => true,
],
'valid-zero' => [
'value' => 0,
'expected' => true,
],
'valid-negative-int' => [
'value' => -123,
'expected' => true,
],
'valid-max-int' => [
'value' => 9223372036854775807,
'expected' => true,
],
'valid-min-int' => [
'value' => '-9223372036854775808',
'expected' => true,
],
// Note: cannot test out of range values as they casting them to int
// will change the value to PHP_INT_MIN/PHP_INT_MAX
'invalid-string-int' => [
'value' => '123',
'expected' => false,
],
'invalid-float' => [
'value' => 123.45,
'expected' => false,
],
'invalid-array' => [
'value' => [123],
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
'invalid-true' => [
'value' => true,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
// On 64-bit systems, -9223372036854775808 will end up as a float
// however it works correctly when cast to an int
if ($value === '-9223372036854775808') {
$value = (int) $value;
}
$validator = new BigIntFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

72
tests/php/Core/Validation/FieldValidation/BooleanIntFieldValidatorTest.php Normal file
View File

@ -0,0 +1,72 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\BooleanIntFieldValidator;
class BooleanIntFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-int-1' => [
'value' => 1,
'expected' => true,
],
'valid-int-0' => [
'value' => 0,
'expected' => true,
],
'invvalid-true' => [
'value' => true,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'expected' => false,
],
'invalid-string-1' => [
'value' => '1',
'expected' => false,
],
'invalid-string-0' => [
'value' => '0',
'expected' => false,
],
'invalid-string-true' => [
'value' => 'true',
'expected' => false,
],
'invalid-string-false' => [
'value' => 'false',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
'invalid-string' => [
'value' => 'abc',
'expected' => false,
],
'invalid-int' => [
'value' => 123,
'expected' => false,
],
'invalid-array' => [
'value' => [],
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new BooleanIntFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

112
tests/php/Core/Validation/FieldValidation/CompositeFieldValidatorTest.php Normal file
View File

@ -0,0 +1,112 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use InvalidArgumentException;
use stdClass;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Core\Validation\FieldValidation\CompositeFieldValidator;
use SilverStripe\ORM\FieldType\DBBoolean;
use SilverStripe\ORM\FieldType\DBVarchar;
class CompositeFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid' => [
'valueBoolean' => true,
'valueString' => 'fish',
'valueIsNull' => false,
'skipIfNull' => false,
'exception' => null,
'expected' => true,
],
'valid-skip-null' => [
'valueBoolean' => true,
'valueString' => 'fish',
'valueIsNull' => true,
'skipIfNull' => true,
'exception' => null,
'expected' => true,
],
'exception-not-iterable' => [
'valueBoolean' => true,
'valueString' => 'not-iterable',
'valueIsNull' => false,
'skipIfNull' => false,
'exception' => InvalidArgumentException::class,
'expected' => true,
],
'exception-not-field-validator' => [
'valueBoolean' => true,
'valueString' => 'no-field-validation',
'valueIsNull' => false,
'skipIfNull' => false,
'exception' => InvalidArgumentException::class,
'expected' => true,
],
'exception-do-not-skip-null' => [
'valueBoolean' => true,
'valueString' => 'fish',
'valueIsNull' => true,
'skipIfNull' => false,
'exception' => InvalidArgumentException::class,
'expected' => true,
],
'invalid-bool-field' => [
'valueBoolean' => 'dog',
'valueString' => 'fish',
'valueIsNull' => false,
'skipIfNull' => false,
'exception' => null,
'expected' => false,
],
'invalid-string-field' => [
'valueBoolean' => true,
'valueString' => 456.789,
'valueIsNull' => false,
'skipIfNull' => false,
'exception' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(
mixed $valueBoolean,
mixed $valueString,
bool $valueIsNull,
bool $skipIfNull,
?string $exception,
bool $expected
): void {
if ($exception) {
$this->expectException($exception);
}
if ($valueIsNull) {
$iterable = null;
} else {
$booleanField = new DBBoolean('BooleanField');
$booleanField->setValue($valueBoolean);
if ($exception && $valueString === 'no-field-validation') {
$stringField = new stdClass();
} else {
$stringField = new DBVarchar('StringField');
$stringField->setValue($valueString);
}
if ($exception && $valueString === 'not-iterable') {
$iterable = 'banana';
} else {
$iterable = [$booleanField, $stringField];
}
}
$validator = new CompositeFieldValidator('MyField', $iterable, $skipIfNull);
$result = $validator->validate();
if (!$exception) {
$this->assertSame($expected, $result->isValid());
}
}
}

48
tests/php/Core/Validation/FieldValidation/DateFieldValidatorTest.php Normal file
View File

@ -0,0 +1,48 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\DateFieldValidator;
class DateFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid' => [
'value' => '2020-09-15',
'expected' => true,
],
'invalid' => [
'value' => '2020-02-30',
'expected' => false,
],
'invalid-wrong-format' => [
'value' => '15-09-2020',
'expected' => false,
],
'invalid-date-time' => [
'value' => '2020-09-15 13:34:56',
'expected' => false,
],
'invalid-time' => [
'value' => '13:34:56',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new DateFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

52
tests/php/Core/Validation/FieldValidation/DatetimeFieldValidatorTest.php Normal file
View File

@ -0,0 +1,52 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\DatetimeFieldValidator;
class DatetimeFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid' => [
'value' => '2020-09-15 13:34:56',
'expected' => true,
],
'invalid-date' => [
'value' => '2020-02-30 13:34:56',
'expected' => false,
],
'invalid-time' => [
'value' => '2020-02-15 13:99:56',
'expected' => false,
],
'invalid-wrong-format' => [
'value' => '15-09-2020 13:34:56',
'expected' => false,
],
'invalid-date-only' => [
'value' => '2020-09-15',
'expected' => false,
],
'invalid-time-only' => [
'value' => '13:34:56',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new DatetimeFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

138
tests/php/Core/Validation/FieldValidation/DecimalFieldValidatorTest.php Normal file
View File

@ -0,0 +1,138 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\DecimalFieldValidator;
class DecimalFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid' => [
'value' => 123.45,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-negative' => [
'value' => -123.45,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-zero' => [
'value' => 0,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-rounded-dp' => [
'value' => 123.456,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-rounded-up' => [
'value' => 123.999,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-int' => [
'value' => 123,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-negative-int' => [
'value' => -123,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-max' => [
'value' => 999.99,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'valid-max-negative' => [
'value' => -999.99,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => true,
],
'invalid-rounded-to-6-digts' => [
'value' => 999.999,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
'invalid-too-long' => [
'value' => 1234.56,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
'invalid-too-long-3dp' => [
'value' => 123.456,
'wholeSize' => 5,
'decimalSize' => 3,
'expected' => false,
],
'invalid-too-long-1dp' => [
'value' => 123.4,
'wholeSize' => 5,
'decimalSize' => 3,
'expected' => false,
],
'invalid-too-long-int' => [
'value' => 123,
'wholeSize' => 5,
'decimalSize' => 3,
'expected' => false,
],
'invalid-string' => [
'value' => '123.45',
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
'invalid-null' => [
'value' => null,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
'invalid-true' => [
'value' => true,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
'invalid-array' => [
'value' => [123.45],
'wholeSize' => 5,
'decimalSize' => 2,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, int $wholeSize, int $decimalSize, bool $expected): void
{
$validator = new DecimalFieldValidator('MyField', $value, false, $wholeSize, $decimalSize);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

37
tests/php/Core/Validation/FieldValidation/EmailFieldValidatorTest.php Normal file
View File

@ -0,0 +1,37 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\EmailFieldValidator;
class EmailFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
// Using symfony/validator for implementation so only smoke testing
return [
'valid' => [
'value' => 'test@example.com',
'expected' => true,
],
'invalid' => [
'value' => 'fish',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new EmailFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

54
tests/php/Core/Validation/FieldValidation/EnumFieldValidatorTest.php Normal file
View File

@ -0,0 +1,54 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\EnumFieldValidator;
class EnumFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-string' => [
'value' => 'cat',
'allowedValues' => ['cat', 'dog'],
'expected' => true,
],
'valid-int' => [
'value' => 123,
'allowedValues' => [123, 456],
'expected' => true,
],
'invalid' => [
'value' => 'fish',
'allowedValues' => ['cat', 'dog'],
'expected' => false,
],
'invalid-none' => [
'value' => '',
'allowedValues' => ['cat', 'dog'],
'expected' => false,
],
'invalid-null' => [
'value' => null,
'allowedValues' => ['cat', 'dog'],
'expected' => false,
],
'invalid-strict' => [
'value' => '123',
'allowedValues' => [123, 456],
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, array $allowedValues, bool $expected): void
{
$validator = new EnumFieldValidator('MyField', $value, false, $allowedValues);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

43
tests/php/Core/Validation/FieldValidation/FieldValidatorTest.php Normal file
View File

@ -0,0 +1,43 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
use SilverStripe\Core\Validation\ValidationResult;
class FieldValidatorTest extends SapphireTest
{
public static function provideSkipIfNull(): array
{
return [
'skip' => [
'skipIfNull' => true,
'expected' => true,
],
'not-skip' => [
'skipIfNull' => false,
'expected' => false,
],
];
}
#[DataProvider('provideSkipIfNull')]
public function testSkipIfNull(bool $skipIfNull, bool $expected): void
{
$value = null;
$validator = new class ('MyField', $value, $skipIfNull) extends FieldValidator {
protected function validateValue(): ValidationResult
{
$result = ValidationResult::create();
if ($this->value === null) {
$result->addFieldError('MyField', 'Disaster');
}
return $result;
}
};
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

76
tests/php/Core/Validation/FieldValidation/IntFieldValidatorTest.php Normal file
View File

@ -0,0 +1,76 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\IntFieldValidator;
class IntFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-int' => [
'value' => 123,
'expected' => true,
],
'valid-zero' => [
'value' => 0,
'expected' => true,
],
'valid-negative-int' => [
'value' => -123,
'expected' => true,
],
'valid-max-int' => [
'value' => 2147483647,
'expected' => true,
],
'valid-min-int' => [
'value' => -2147483648,
'expected' => true,
],
'invalid-out-of-bounds' => [
'value' => 2147483648,
'expected' => false,
],
'invalid-out-of-negative-bounds' => [
'value' => -2147483649,
'expected' => false,
],
'invalid-string-int' => [
'value' => '123',
'expected' => false,
],
'invalid-float' => [
'value' => 123.45,
'expected' => false,
],
'invalid-array' => [
'value' => [123],
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
'invalid-true' => [
'value' => true,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new IntFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

45
tests/php/Core/Validation/FieldValidation/IpFieldValidatorTest.php Normal file
View File

@ -0,0 +1,45 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\IpFieldValidator;
class IpFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
// Using symfony/validator for implementation so only smoke testing
return [
'valid-ipv4' => [
'value' => '127.0.0.1',
'expected' => true,
],
'valid-ipv6' => [
'value' => '0:0:0:0:0:0:0:1',
'expected' => true,
],
'valid-ipv6-short' => [
'value' => '::1',
'expected' => true,
],
'invalid' => [
'value' => '12345',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new IpFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

61
tests/php/Core/Validation/FieldValidation/LocaleFieldValidatorTest.php Normal file
View File

@ -0,0 +1,61 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\LocaleFieldValidator;
class LocaleFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
// Using symfony/validator for implementation so only smoke testing
return [
'valid' => [
'value' => 'de_DE',
'expected' => true,
],
'valid-dash' => [
'value' => 'de-DE',
'expected' => true,
],
'valid-short' => [
'value' => 'de',
'expected' => true,
],
'invalid' => [
'value' => 'zz_ZZ',
'expected' => false,
],
'invalid-dash' => [
'value' => 'zz-ZZ',
'expected' => false,
],
'invalid-short' => [
'value' => 'zz',
'expected' => false,
],
'invalid-dashes' => [
'value' => '-----',
'expected' => false,
],
'invalid-donut' => [
'value' => 'donut',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new LocaleFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

84
tests/php/Core/Validation/FieldValidation/MultiEnumFieldValidatorTest.php Normal file
View File

@ -0,0 +1,84 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use InvalidArgumentException;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\MultiEnumFieldValidator;
class MultiEnumFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-string' => [
'value' => ['cat'],
'allowedValues' => ['cat', 'dog'],
'exception' => false,
'expected' => true,
],
'valid-multi-string' => [
'value' => ['cat', 'dog'],
'allowedValues' => ['cat', 'dog'],
'exception' => false,
'expected' => true,
],
'valid-none' => [
'value' => [],
'allowedValues' => ['cat', 'dog'],
'exception' => false,
'expected' => true,
],
'valid-int' => [
'value' => [123],
'allowedValues' => [123, 456],
'exception' => false,
'expected' => true,
],
'exception-not-array' => [
'value' => 'cat,dog',
'allowedValues' => ['cat', 'dog'],
'exception' => true,
'expected' => false,
],
'invalid' => [
'value' => ['fish'],
'allowedValues' => ['cat', 'dog'],
'exception' => false,
'expected' => false,
],
'invalid-null' => [
'value' => [null],
'allowedValues' => ['cat', 'dog'],
'exception' => false,
'expected' => false,
],
'invalid-multi' => [
'value' => ['dog', 'fish'],
'allowedValues' => ['cat', 'dog'],
'exception' => false,
'expected' => false,
],
'invalid-strict' => [
'value' => ['123'],
'allowedValues' => [123, 456],
'exception' => false,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, array $allowedValues, bool $exception, bool $expected): void
{
if ($exception) {
$this->expectException(InvalidArgumentException::class);
}
$validator = new MultiEnumFieldValidator('MyField', $value, false, $allowedValues);
$result = $validator->validate();
if (!$exception) {
$this->assertSame($expected, $result->isValid());
}
}
}

80
tests/php/Core/Validation/FieldValidation/NumericFieldValidatorTest.php Normal file
View File

@ -0,0 +1,80 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\NumericFieldValidator;
class NumericFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-int' => [
'value' => 123,
'expected' => true,
],
'valid-zero' => [
'value' => 0,
'expected' => true,
],
'valid-negative-int' => [
'value' => -123,
'expected' => true,
],
'valid-float' => [
'value' => 123.45,
'expected' => true,
],
'valid-negative-float' => [
'value' => -123.45,
'expected' => true,
],
'valid-max-int' => [
'value' => PHP_INT_MAX,
'expected' => true,
],
'valid-min-int' => [
'value' => PHP_INT_MIN,
'expected' => true,
],
'valid-max-float' => [
'value' => PHP_FLOAT_MAX,
'expected' => true,
],
'valid-min-float' => [
'value' => PHP_FLOAT_MIN,
'expected' => true,
],
'invalid-string' => [
'value' => '123',
'expected' => false,
],
'invalid-array' => [
'value' => [123],
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
'invalid-true' => [
'value' => true,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new NumericFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

149
tests/php/Core/Validation/FieldValidation/StringFieldValidatorTest.php Normal file
View File

@ -0,0 +1,149 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use InvalidArgumentException;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\StringFieldValidator;
use SilverStripe\Dev\SapphireTest;
class StringFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-no-limit' => [
'value' => 'fish',
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => true,
],
'valid-blank' => [
'value' => '',
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => true,
],
'valid-blank-when-min' => [
'value' => '',
'minLength' => 5,
'maxLength' => null,
'exception' => false,
'expected' => true,
],
'valid-max' => [
'value' => 'fish',
'minLength' => 0,
'maxLength' => 4,
'exception' => false,
'expected' => true,
],
'valid-less-than-max-null-min' => [
'value' => 'fish',
'minLength' => null,
'maxLength' => 4,
'exception' => false,
'expected' => true,
],
'valid-less-than-max-unicode' => [
'value' => '☕☕☕☕',
'minLength' => 0,
'maxLength' => 4,
'exception' => false,
'expected' => true,
],
'exception-negative-min' => [
'value' => 'fish',
'minLength' => -1,
'maxLength' => null,
'exception' => true,
'expected' => false,
],
'invalid-below-min' => [
'value' => 'fish',
'minLength' => 5,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-below-min-unicode' => [
'value' => '☕☕☕☕',
'minLength' => 5,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-above-min' => [
'value' => 'fish',
'minLength' => 0,
'maxLength' => 3,
'exception' => false,
'expected' => false,
],
'invalid-above-min-unicode' => [
'value' => '☕☕☕☕',
'minLength' => 0,
'maxLength' => 3,
'exception' => false,
'expected' => false,
],
'invalid-int' => [
'value' => 123,
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-float' => [
'value' => 123.56,
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-true' => [
'value' => true,
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-null' => [
'value' => null,
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
'invalid-array' => [
'value' => ['fish'],
'minLength' => null,
'maxLength' => null,
'exception' => false,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, ?int $minLength, ?int $maxLength, bool $exception, bool $expected): void
{
if ($exception) {
$this->expectException(InvalidArgumentException::class);
}
$validator = new StringFieldValidator('MyField', $value, false, $minLength, $maxLength);
$result = $validator->validate();
if (!$exception) {
$this->assertSame($expected, $result->isValid());
}
}
}

48
tests/php/Core/Validation/FieldValidation/TimeFieldValidatorTest.php Normal file
View File

@ -0,0 +1,48 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\TimeFieldValidator;
class TimeFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid' => [
'value' => '13:34:56',
'expected' => true,
],
'invalid' => [
'value' => '13:99:56',
'expected' => false,
],
'invalid-wrong-format' => [
'value' => '13-34-56',
'expected' => false,
],
'invalid-date-time' => [
'value' => '2020-09-15 13:34:56',
'expected' => false,
],
'invalid-date' => [
'value' => '2020-09-15',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new TimeFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

45
tests/php/Core/Validation/FieldValidation/UrlFieldValidatorTest.php Normal file
View File

@ -0,0 +1,45 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\Validation\FieldValidation\UrlFieldValidator;
class UrlFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
// Using symfony/validator for implementation so only smoke testing
return [
'valid-https' => [
'value' => 'https://www.example.com',
'expected' => true,
],
'valid-http' => [
'value' => 'https://www.example.com',
'expected' => true,
],
'invalid-ftp' => [
'value' => 'ftp://www.example.com',
'expected' => false,
],
'invalid-no-scheme' => [
'value' => 'www.example.com',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new UrlFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

105
tests/php/Core/Validation/FieldValidation/YearFieldValidatorTest.php Normal file
View File

@ -0,0 +1,105 @@
<?php
namespace SilverStripe\Core\Tests\Validation\FieldValidation;
use InvalidArgumentException;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Core\Validation\FieldValidation\YearFieldValidator;
class YearFieldValidatorTest extends SapphireTest
{
public static function provideValidate(): array
{
return [
'valid-4-int' => [
'value' => 2024,
'expected' => true,
],
'valid-2-int' => [
'value' => 24,
'expected' => true,
],
'valid-0-int' => [
'value' => 0,
'expected' => true,
],
'valid-4-string' => [
'value' => '2024',
'expected' => true,
],
'valid-2-string' => [
'value' => '24',
'expected' => true,
],
'valid-0-string' => [
'value' => '0',
'expected' => true,
],
'valid-00-string' => [
'value' => '00',
'expected' => true,
],
'valid-0000-string' => [
'value' => '0000',
'expected' => true,
],
'invalid-4-int-low' => [
'value' => 1900,
'expected' => false,
],
'invalid-4-int-low' => [
'value' => 2156,
'expected' => false,
],
'invalid-4-string-low' => [
'value' => '1900',
'expected' => false,
],
'invalid-4-string-low' => [
'value' => '2156',
'expected' => false,
],
'invalid-int-negative' => [
'value' => -2024,
'expected' => false,
],
'invalid-string-negative' => [
'value' => '-2024',
'expected' => false,
],
'invalid-float' => [
'value' => 2024.0,
'expected' => false,
],
'invalid-string-float' => [
'value' => '2024.0',
'expected' => false,
],
'invalid-null' => [
'value' => null,
'expected' => false,
],
'invalid-true' => [
'value' => true,
'expected' => false,
],
'invalid-false' => [
'value' => false,
'expected' => false,
],
'invalid-array' => [
'value' => [],
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$validator = new YearFieldValidator('MyField', $value, false);
$result = $validator->validate();
$this->assertSame($expected, $result->isValid());
}
}

92
tests/php/ORM/DBFieldTest.php
View File

@ -30,6 +30,10 @@ use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\ORM\FieldType\DBYear;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\Core\ClassInfo;
use ReflectionClass;
use SilverStripe\Dev\TestOnly;
use SilverStripe\ORM\FieldType\DBComposite;
/**
* Tests for DBField objects.
@ -392,4 +396,92 @@ class DBFieldTest extends SapphireTest
$this->assertEquals('new value', $obj->getField('MyTestField'));
}
public function testDefaultValues(): void
{
$expectedBaseDefault = null;
$expectedDefaults = [
DBBoolean::class => 0,
DBDecimal::class => 0.0,
DBInt::class => 0,
DBFloat::class => 0.0,
];
$classes = ClassInfo::subclassesFor(DBField::class);
foreach ($classes as $class) {
if ($class instanceof TestOnly) {
continue;
}
$reflector = new ReflectionClass($class);
if ($reflector->isAbstract()) {
continue;
}
$expected = $expectedBaseDefault;
foreach ($expectedDefaults as $baseClass => $default) {
if ($class === $baseClass || is_subclass_of($class, $baseClass)) {
$expected = $default;
break;
}
}
$field = new $class('TestField');
$this->assertSame($expected, $field->getValue(), $class);
}
}
public function testValidIfNull(): void
{
$expectedIfNotListed = false;
// Has skipValidationIfNull = true
$willSkipValidation = [
DBComposite::class,
DBDate::class,
DBString::class,
DBTime::class,
];
// Subclass of something in $willSkipValidation, though has
// $skipValidationIfNull = false
$willNotSkipValidation = [
DBEnum::class,
];
$validWithNullValue = [
// nullValue() returns 0
DBBoolean::class,
DBFloat::class,
DBInt::class,
// sets valid value in setValue()
DBCurrency::class,
];
$classes = ClassInfo::subclassesFor(DBField::class);
foreach ($classes as $class) {
if (is_a($class, TestOnly::class, true)) {
continue;
}
$reflector = new ReflectionClass($class);
if ($reflector->isAbstract()) {
continue;
}
$expected = $expectedIfNotListed;
foreach ($willSkipValidation as $baseClass) {
if ($class === $baseClass || is_subclass_of($class, $baseClass)) {
$expected = true;
break;
}
}
foreach ($willNotSkipValidation as $baseClass) {
if ($class === $baseClass || is_subclass_of($class, $baseClass)) {
$expected = false;
break;
}
}
foreach ($validWithNullValue as $baseClass) {
if ($class === $baseClass || is_subclass_of($class, $baseClass)) {
$expected = true;
break;
}
}
$field = new $class('TestField');
$field->setValue(null);
$result = $field->validate();
$this->assertSame($expected, $result->isValid(), $class);
}
}
}

205
tests/php/ORM/DBFieldValidatorsTest.php Normal file
View File

@ -0,0 +1,205 @@
<?php
namespace SilverStripe\ORM\Tests;
use ReflectionMethod;
use SilverStripe\Dev\SapphireTest;
use PHPUnit\Framework\Attributes\DataProvider;
use SilverStripe\ORM\FieldType\DBBigInt;
use SilverStripe\ORM\FieldType\DBBoolean;
use SilverStripe\ORM\FieldType\DBClassName;
use SilverStripe\ORM\FieldType\DBComposite;
use SilverStripe\ORM\FieldType\DBCurrency;
use SilverStripe\ORM\FieldType\DBInt;
use SilverStripe\Core\Validation\FieldValidation\IntValidator;
use SilverStripe\Core\Validation\FieldValidation\BigIntValidator;
use SilverStripe\ORM\FieldType\DBDate;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\ORM\FieldType\DBDecimal;
use SilverStripe\ORM\FieldType\DBEmail;
use SilverStripe\ORM\FieldType\DBFloat;
use SilverStripe\ORM\FieldType\DBForeignKey;
use SilverStripe\ORM\FieldType\DBHTMLText;
use SilverStripe\ORM\FieldType\DBHTMLVarchar;
use SilverStripe\ORM\FieldType\DBIndexable;
use SilverStripe\ORM\FieldType\DBIp;
use SilverStripe\ORM\FieldType\DBLocale;
use SilverStripe\ORM\FieldType\DBMoney;
use SilverStripe\ORM\FieldType\DBMultiEnum;
use SilverStripe\ORM\FieldType\DBPercentage;
use SilverStripe\ORM\FieldType\DBPolymorphicForeignKey;
use SilverStripe\ORM\FieldType\DBPolymorphicRelationAwareForeignKey;
use SilverStripe\ORM\FieldType\DBPrimaryKey;
use SilverStripe\ORM\FieldType\DBString;
use SilverStripe\ORM\FieldType\DBText;
use SilverStripe\ORM\FieldType\DBTime;
use SilverStripe\ORM\FieldType\DBUrl;
use SilverStripe\ORM\FieldType\DBVarchar;
use SilverStripe\ORM\FieldType\DBYear;
class DBFieldValidatorsTest extends SapphireTest
{
public static function provideFieldValidatorConfig(): array
{
return [
'DBBigInt' => [
'class' => DBBigInt::class,
'expected' => [
BigIntValidator::class,
],
],
'DBBoolean' => [
'class' => DBBoolean::class,
'expected' => [
],
],
'DBClassName' => [
'class' => DBClassName::class,
'expected' => [
],
],
'DBComposite' => [
'class' => DBComposite::class,
'expected' => [
],
],
'DBCurrency' => [
'class' => DBCurrency::class,
'expected' => [
],
],
'DBDate' => [
'class' => DBDate::class,
'expected' => [
],
],
'DBDatetime' => [
'class' => DBDatetime::class,
'expected' => [
],
],
'DBDecimal' => [
'class' => DBDecimal::class,
'expected' => [
],
],
'DBEmail' => [
'class' => DBEmail::class,
'expected' => [
],
],
'DBFloat' => [
'class' => DBFloat::class,
'expected' => [
],
],
'DBForeignKey' => [
'class' => DBForeignKey::class,
'expected' => [
],
],
'DBHTMLText' => [
'class' => DBHTMLText::class,
'expected' => [
],
],
'DBHTMLVarchar' => [
'class' => DBHTMLVarchar::class,
'expected' => [
],
],
'DBIndexable' => [
'class' => DBIndexable::class,
'expected' => [
],
],
'DBInt' => [
'class' => DBInt::class,
'expected' => [
IntValidator::class,
],
],
'DBIp' => [
'class' => DBIp::class,
'expected' => [
],
],
'DBLocale' => [
'class' => DBLocale::class,
'expected' => [
],
],
'DBMoney' => [
'class' => DBMoney::class,
'expected' => [
],
],
'DBMultiEnum' => [
'class' => DBMultiEnum::class,
'expected' => [
],
],
'DBPercentage' => [
'class' => DBPercentage::class,
'expected' => [
],
],
'DBPolymorphicForeignKey' => [
'class' => DBPolymorphicForeignKey::class,
'expected' => [
],
],
'DBPolymorhicRelationAwareForiegnKey' => [
'class' => DBPolymorphicRelationAwareForeignKey::class,
'expected' => [
],
],
'DBPrimaryKey' => [
'class' => DBPrimaryKey::class,
'expected' => [
],
],
'DBString' => [
'class' => DBString::class,
'expected' => [
],
],
'DBText' => [
'class' => DBText::class,
'expected' => [
],
],
'DBTime' => [
'class' => DBTime::class,
'expected' => [
],
],
'DBUrl' => [
'class' => DBUrl::class,
'expected' => [
],
],
'DBVarchar' => [
'class' => DBVarchar::class,
'expected' => [
],
],
'DBYear' => [
'class' => DBYear::class,
'expected' => [
],
],
];
}
#[DataProvider('provideFieldValidatorConfig')]
public function testFieldValidatorConfig(string $class, array $expected): void
{
$method = new ReflectionMethod($class, 'getFieldValidators');
$method->setAccessible(true);
$obj = new $class('MyField');
$fieldValidators = $method->invoke($obj);
$actual = array_map('get_class', $fieldValidators);
$this->assertSame($expected, $actual);
}
}

65
tests/php/ORM/DBIntTest.php
View File

@ -4,15 +4,70 @@ namespace SilverStripe\ORM\Tests;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\FieldType\DBInt;
use PHPUnit\Framework\Attributes\DataProvider;
class DBIntTest extends SapphireTest
{
public function testGetValueCastToInt()
public function testDefaultValue(): void
{
$field = new DBInt('MyField');
$this->assertSame(0, $field->getValue());
}
public static function provideSetGetValue(): array
{
return [
'int' => [
'value' => 3,
'expected' => 3,
],
'string-int' => [
'value' => '3',
'expected' => 3,
],
'string' => [
'value' => 'fish',
'expected' => 'fish',
],
'array' => [
'value' => [],
'expected' => [],
],
'null' => [
'value' => null,
'expected' => 0,
],
];
}
#[DataProvider('provideSetGetValue')]
public function testSetGetValue(mixed $value, mixed $expected): void
{
$field = DBInt::create('MyField');
$field->setValue(3);
$this->assertSame(3, $field->getValue());
$field->setValue('3');
$this->assertSame(3, $field->getValue());
$field->setValue($value);
$this->assertSame($expected, $field->getValue());
}
public static function provideValidate(): array
{
return [
'valid' => [
'value' => 123,
'expected' => true,
],
'invalid' => [
'value' => 'abc',
'expected' => false,
],
];
}
#[DataProvider('provideValidate')]
public function testValidate(mixed $value, bool $expected): void
{
$field = new DBInt('MyField');
$field->setValue($value);
$result = $field->validate();
$this->assertSame($expected, $result->isValid());
}
}