class ConstraintValidatorTestCase

abstract class ConstraintValidatorTestCase extends TestCase {
    protected ExecutionContextInterface $context;
    
    /**
     * @var T
     */
    protected ConstraintValidatorInterface $validator;
    protected string $group;
    protected ?MetadataInterface $metadata;
    protected mixed $object;
    protected mixed $value;
    protected mixed $root;
    protected string $propertyPath;
    protected Constraint $constraint;
    protected ?string $defaultTimezone = null;
    private string $defaultLocale;
    private array $expectedViolations;
    private int $call;
    protected function setUp() : void {
        $this->group = 'MyGroup';
        $this->metadata = null;
        $this->object = null;
        $this->value = 'InvalidValue';
        $this->root = 'root';
        $this->propertyPath = 'property.path';
        // Initialize the context with some constraint so that we can
        // successfully build a violation.
        $this->constraint = new NotNull();
        $this->context = $this->createContext();
        $this->validator = $this->createValidator();
        $this->validator
            ->initialize($this->context);
        if (class_exists(\Locale::class)) {
            $this->defaultLocale = \Locale::getDefault();
            \Locale::setDefault('en');
        }
        $this->expectedViolations = [];
        $this->call = 0;
        $this->setDefaultTimezone('UTC');
    }
    protected function tearDown() : void {
        $this->restoreDefaultTimezone();
        if (class_exists(\Locale::class)) {
            \Locale::setDefault($this->defaultLocale);
        }
    }
    protected function setDefaultTimezone(?string $defaultTimezone) {
        // Make sure this method cannot be called twice before calling
        // also restoreDefaultTimezone()
        if (null === $this->defaultTimezone) {
            $this->defaultTimezone = date_default_timezone_get();
            date_default_timezone_set($defaultTimezone);
        }
    }
    protected function restoreDefaultTimezone() {
        if (null !== $this->defaultTimezone) {
            date_default_timezone_set($this->defaultTimezone);
            $this->defaultTimezone = null;
        }
    }
    protected function createContext() {
        $translator = $this->createMock(TranslatorInterface::class);
        $translator->expects($this->any())
            ->method('trans')
            ->willReturnArgument(0);
        $validator = $this->createMock(ValidatorInterface::class);
        $validator->expects($this->any())
            ->method('validate')
            ->willReturnCallback(fn() => $this->expectedViolations[$this->call++] ?? new ConstraintViolationList());
        $context = new ExecutionContext($validator, $this->root, $translator);
        $context->setGroup($this->group);
        $context->setNode($this->value, $this->object, $this->metadata, $this->propertyPath);
        $context->setConstraint($this->constraint);
        $contextualValidatorMockBuilder = $this->getMockBuilder(AssertingContextualValidator::class)
            ->setConstructorArgs([
            $context,
        ]);
        $contextualValidatorMethods = [
            'atPath',
            'validate',
            'validateProperty',
            'validatePropertyValue',
            'getViolations',
        ];
        $contextualValidatorMockBuilder->onlyMethods($contextualValidatorMethods);
        $contextualValidator = $contextualValidatorMockBuilder->getMock();
        $contextualValidator->expects($this->any())
            ->method('atPath')
            ->willReturnCallback(fn($path) => $contextualValidator->doAtPath($path));
        $contextualValidator->expects($this->any())
            ->method('validate')
            ->willReturnCallback(fn($value, $constraints = null, $groups = null) => $contextualValidator->doValidate($value, $constraints, $groups));
        $contextualValidator->expects($this->any())
            ->method('validateProperty')
            ->willReturnCallback(fn($object, $propertyName, $groups = null) => $contextualValidator->validateProperty($object, $propertyName, $groups));
        $contextualValidator->expects($this->any())
            ->method('validatePropertyValue')
            ->willReturnCallback(fn($objectOrClass, $propertyName, $value, $groups = null) => $contextualValidator->doValidatePropertyValue($objectOrClass, $propertyName, $value, $groups));
        $contextualValidator->expects($this->any())
            ->method('getViolations')
            ->willReturnCallback(fn() => $contextualValidator->doGetViolations());
        $validator->expects($this->any())
            ->method('inContext')
            ->with($context)
            ->willReturn($contextualValidator);
        return $context;
    }
    protected function setGroup(?string $group) {
        $this->group = $group;
        $this->context
            ->setGroup($group);
    }
    protected function setObject(mixed $object) {
        $this->object = $object;
        $this->metadata = \is_object($object) ? new ClassMetadata($object::class) : null;
        $this->context
            ->setNode($this->value, $this->object, $this->metadata, $this->propertyPath);
    }
    protected function setProperty(mixed $object, string $property) {
        $this->object = $object;
        $this->metadata = \is_object($object) ? new PropertyMetadata($object::class, $property) : null;
        $this->context
            ->setNode($this->value, $this->object, $this->metadata, $this->propertyPath);
    }
    protected function setValue(mixed $value) {
        $this->value = $value;
        $this->context
            ->setNode($this->value, $this->object, $this->metadata, $this->propertyPath);
    }
    protected function setRoot(mixed $root) {
        $this->root = $root;
        $this->context = $this->createContext();
        $this->validator
            ->initialize($this->context);
    }
    protected function setPropertyPath(string $propertyPath) {
        $this->propertyPath = $propertyPath;
        $this->context
            ->setNode($this->value, $this->object, $this->metadata, $this->propertyPath);
    }
    protected function expectNoValidate() {
        $validator = $this->context
            ->getValidator()
            ->inContext($this->context);
        $validator->expectNoValidate();
    }
    protected function expectValidateAt(int $i, string $propertyPath, mixed $value, string|GroupSequence|array|null $group) {
        $validator = $this->context
            ->getValidator()
            ->inContext($this->context);
        $validator->expectValidation($i, $propertyPath, $value, $group, function ($passedConstraints) {
            $expectedConstraints = LogicalOr::fromConstraints(new IsNull(), new IsIdentical([]), new IsInstanceOf(Valid::class));
            Assert::assertThat($passedConstraints, $expectedConstraints);
        });
    }
    protected function expectValidateValue(int $i, mixed $value, array $constraints = [], string|GroupSequence|array|null $group = null) {
        $contextualValidator = $this->context
            ->getValidator()
            ->inContext($this->context);
        $contextualValidator->expectValidation($i, null, $value, $group, function ($passedConstraints) use ($constraints) {
            if (!\is_array($passedConstraints)) {
                $passedConstraints = [
                    $passedConstraints,
                ];
            }
            Assert::assertEquals($constraints, $passedConstraints);
        });
    }
    protected function expectFailingValueValidation(int $i, mixed $value, array $constraints, string|GroupSequence|array|null $group, ConstraintViolationInterface $violation) {
        $contextualValidator = $this->context
            ->getValidator()
            ->inContext($this->context);
        $contextualValidator->expectValidation($i, null, $value, $group, function ($passedConstraints) use ($constraints) {
            if (!\is_array($passedConstraints)) {
                $passedConstraints = [
                    $passedConstraints,
                ];
            }
            Assert::assertEquals($constraints, $passedConstraints);
        }, $violation);
    }
    protected function expectValidateValueAt(int $i, string $propertyPath, mixed $value, Constraint|array $constraints, string|GroupSequence|array|null $group = null) {
        $contextualValidator = $this->context
            ->getValidator()
            ->inContext($this->context);
        $contextualValidator->expectValidation($i, $propertyPath, $value, $group, function ($passedConstraints) use ($constraints) {
            Assert::assertEquals($constraints, $passedConstraints);
        });
    }
    protected function expectViolationsAt(int $i, mixed $value, Constraint $constraint) {
        $context = $this->createContext();
        $validatorClassname = $constraint->validatedBy();
        $validator = new $validatorClassname();
        $validator->initialize($context);
        $validator->validate($value, $constraint);
        $this->expectedViolations[] = $context->getViolations();
        return $context->getViolations();
    }
    protected function assertNoViolation() {
        $this->assertSame(0, $violationsCount = \count($this->context
            ->getViolations()), \sprintf('0 violation expected. Got %u.', $violationsCount));
    }
    protected function buildViolation(string|\Stringable $message) : ConstraintViolationAssertion {
        return new ConstraintViolationAssertion($this->context, $message, $this->constraint);
    }
    
    /**
     * @return T
     */
    protected abstract function createValidator() : ConstraintValidatorInterface;

}