The Unified and Autonomous Development Platform
feat: Add comprehensive Hibernate validation tests
Robin Shenbfc978772ae2
diff --git a/server-core/src/test/java/io/onedev/server/validation/HibernateValidationInheritanceTest.java b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationInheritanceTest.javanew file mode 100644index 0000000000..8c5a71dc5e--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationInheritanceTest.java@@ -0,0 +1,161 @@+package io.onedev.server.validation;++import static org.junit.Assert.assertEquals;++import java.util.List;+import java.util.Set;+import java.util.stream.Collectors;++import javax.validation.Valid;+import javax.validation.constraints.NotNull;+import javax.validation.constraints.Size;+import javax.validation.groups.Default;++import org.junit.Test;++public class HibernateValidationInheritanceTest extends HibernateValidationTestSupport {++ @Test+ public void childGetterReplacesConstraintAttributes() {+ // MetaDataBuilder: editable subclasses can redefine a constraint of the same type.+ var descriptors = validator.getConstraintsForClass(ChildSize.class)+ .getConstraintsForProperty("name").getConstraintDescriptors();+ assertEquals(1, descriptors.size());+ assertEquals(2, ((Size) descriptors.iterator().next().getAnnotation()).min());+ assertPaths(validator.validateValue(ChildSize.class, "name", "abc"));+ var violations = validator.validateValue(ChildSize.class, "name", "a");+ assertPaths(violations, "name");+ assertEquals("child size", violations.iterator().next().getMessage());+ assertPaths(validator.validateProperty(new ParentSize(), "name"), "name");+ }++ @Test+ public void defaultGroupRetainsParentConstraintsOfTheSameType() {+ // Unlike validateValue and explicit groups, default-group bean/property validation+ // also checks the parent's annotation when the child redeclares the same type.+ var bean = new ChildSize();+ for (Class<?> group : new Class<?>[] {Default.class, Checks.class}) {+ bean.name = "abc";+ for (var violations : List.of(validator.validate(bean, group),+ validator.validateProperty(bean, "name", group))) {+ if (group == Default.class) {+ assertPaths(violations, "name");+ assertEquals("parent size", violations.iterator().next().getMessage());+ } else {+ assertPaths(violations);+ }+ }+ bean.name = "a";+ for (var violations : List.of(validator.validate(bean, group),+ validator.validateProperty(bean, "name", group))) {+ assertPaths(violations, group == Default.class ? new String[] {"name", "name"} : new String[] {"name"});+ assertEquals(group == Default.class ? Set.of("parent size", "child size") : Set.of("child size"), violations.stream()+ .map(it -> it.getMessage()).collect(Collectors.toSet()));+ }+ }+ }++ @Test+ public void overridingGetterCanRemoveConstraintsWhileInheritedGettersRetainThem() {+ // ValidatorImpl: derived build steps compute properties that were required user inputs.+ assertPaths(validator.validate(new RequiredName()), "name");+ assertPaths(validator.validate(new InheritedName()), "name");+ assertPaths(validator.validate(new OptionalName()));+ assertPaths(validator.validateProperty(new OptionalName(), "name"));+ }++ @Test+ public void overridingGetterCanRemoveObjectAndCollectionCascades() {+ assertPaths(validator.validate(new ParentCascade()), "child.name", "children[0].name");+ assertPaths(validator.validate(new InheritedCascade()), "child.name", "children[0].name");+ assertPaths(validator.validate(new RemovedCascade()));+ }++ @Test+ public void overridingGetterCanRedeclareValidWithoutMetadataErrors() {+ // MethodValidationConfiguration, OD-2564: @Valid on both hierarchy levels is legal+ // for OneDev's replacement semantics; it must still validate the returned children.+ assertPaths(validator.validate(new RedeclaredCascade()), "child.name", "children[0].name");+ }++ public interface Checks {+ }++ public static class ParentSize {+ String name = "abc";++ @Size(min = 5, message = "parent size", groups = {Default.class, Checks.class})+ public String getName() {+ return name;+ }+ }++ public static class ChildSize extends ParentSize {+ @Override+ @Size(min = 2, message = "child size", groups = {Default.class, Checks.class})+ public String getName() {+ return super.getName();+ }+ }++ public static class RequiredName {+ @NotNull+ public String getName() {+ return null;+ }+ }++ public static class InheritedName extends RequiredName {+ }++ public static class OptionalName extends RequiredName {+ @Override+ public String getName() {+ return null;+ }+ }++ public static class ParentCascade {+ private final RequiredName child = new RequiredName();+ private final List<RequiredName> children = List.of(new RequiredName());++ @Valid+ public RequiredName getChild() {+ return child;+ }++ @Valid+ public List<RequiredName> getChildren() {+ return children;+ }+ }++ public static class InheritedCascade extends ParentCascade {+ }++ public static class RemovedCascade extends ParentCascade {+ @Override+ public RequiredName getChild() {+ return super.getChild();+ }++ @Override+ public List<RequiredName> getChildren() {+ return super.getChildren();+ }+ }++ public static class RedeclaredCascade extends ParentCascade {+ @Override+ @Valid+ public RequiredName getChild() {+ return super.getChild();+ }++ @Override+ @Valid+ public List<RequiredName> getChildren() {+ return super.getChildren();+ }+ }+}diff --git a/server-core/src/test/java/io/onedev/server/validation/HibernateValidationInterpolationTest.java b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationInterpolationTest.javanew file mode 100644index 0000000000..e550fa0558--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationInterpolationTest.java@@ -0,0 +1,191 @@+package io.onedev.server.validation;++import static org.junit.Assert.assertEquals;+import static org.junit.Assert.assertNull;+import static org.junit.Assert.assertSame;+import static org.junit.Assert.assertThrows;++import java.lang.annotation.Retention;+import java.lang.annotation.Target;+import java.util.List;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;++import javax.validation.Constraint;+import javax.validation.ConstraintValidator;+import javax.validation.ConstraintValidatorContext;+import javax.validation.Payload;+import javax.validation.ValidationException;+import javax.validation.constraints.NotNull;+import javax.validation.constraints.Pattern;++import org.hibernate.validator.internal.metadata.core.MetaConstraint;+import org.junit.Test;++import io.onedev.server.annotation.ClassValidating;+import io.onedev.server.annotation.Interpolative;+import io.onedev.server.buildspec.step.CreateTagStep;++public class HibernateValidationInterpolationTest extends HibernateValidationTestSupport {++ @Test+ public void validatesTagNamesAfterExpandingJobVariablesAndEscapedAtSigns() {+ // ConstraintTree + MetaConstraint: #222 (literal @@), #1242 (tag name validation).+ var step = new CreateTagStep();+ for (String name : List.of("release-@build_number@", "release@@candidate")) {+ step.setTagName(name);+ assertPaths(validator.validateProperty(step, "tagName"));+ assertEquals(name, step.getTagName());+ }+ step.setTagName("release bad-@build_number@");+ var violations = validator.validateProperty(step, "tagName");+ assertPaths(violations, "tagName");+ assertEquals("Invalid git tag name", violations.iterator().next().getMessage());+ assertEquals(step.getTagName(), violations.iterator().next().getInvalidValue());+ }++ @Test+ public void usesTheAnnotationExampleInsteadOfResolvingRuntimeVariables() {+ var bean = new NumericSetting();+ bean.value = "@param:port@";+ assertPaths(validator.validate(bean));+ assertEquals("@param:port@", bean.value);+ bean.value = "invalid-@param:port@";+ assertPaths(validator.validate(bean), "value");+ bean.value = null;+ assertPaths(validator.validate(bean), "value");+ }++ @Test+ public void malformedInterpolationIsReportedOnlyByTheInterpolationValidator() {+ var bean = new NumericSetting();+ bean.value = "@param:port";+ var violations = validator.validate(bean);+ assertPaths(violations, "value");+ assertEquals(Interpolative.class, violations.iterator().next().getConstraintDescriptor().getAnnotation().annotationType());+ assertNull(MetaConstraint.get());+ }++ @Test+ public void collectionConstraintsSeeExpandedValuesWithoutChangingTheBean() {+ var bean = new NumericList();+ bean.values = List.of("@param:first@", "12");+ assertPaths(validator.validate(bean));+ assertEquals(List.of("@param:first@", "12"), bean.values);+ bean.values = List.of("@param:first@", "bad");+ assertPaths(validator.validate(bean), "values");+ bean.values = List.of("@param:first");+ var violations = validator.validate(bean);+ assertPaths(violations, "values");+ assertEquals(Interpolative.class, violations.iterator().next().getConstraintDescriptor().getAnnotation().annotationType());+ }++ @Test+ public void nestedValidationRestoresTheEnclosingConstraint() {+ // A custom validator may validate another bean; interpolation must use the inner+ // getter's metadata, then restore the caller's metadata even on failure.+ assertNull(MetaConstraint.get());+ var probe = new ValidationProbe();+ probe.action = () -> {+ var enclosing = MetaConstraint.get();+ assertEquals(ClassValidating.class, enclosing.getDescriptor().getAnnotationType());+ var bean = new NumericSetting();+ bean.value = "@param:port@";+ assertPaths(validator.validate(bean));+ assertSame(enclosing, MetaConstraint.get());+ var broken = new ValidationProbe();+ broken.action = () -> { throw new IllegalStateException("validator failed"); };+ assertThrows(ValidationException.class, () -> validator.validate(broken));+ assertSame(enclosing, MetaConstraint.get());+ };+ assertPaths(validator.validate(probe));+ assertNull(MetaConstraint.get());+ }++ @Test+ public void validatorExceptionsDoNotLeakConstraintMetadata() {+ var probe = new ValidationProbe();+ probe.action = () -> { throw new IllegalStateException("validator failed"); };+ assertThrows(ValidationException.class, () -> validator.validate(probe));+ assertNull(MetaConstraint.get());+ var bean = new NumericSetting();+ bean.value = "@param:port@";+ assertPaths(validator.validate(bean));+ assertNull(MetaConstraint.get());+ }++ @Test+ public void concurrentValidationDoesNotShareConstraintMetadata() {+ var executor = Executors.newSingleThreadExecutor();+ try {+ var probe = new ValidationProbe();+ probe.action = () -> {+ var enclosing = MetaConstraint.get();+ try {+ executor.submit(() -> {+ assertNull(MetaConstraint.get());+ var bean = new NumericSetting();+ bean.value = "@param:port@";+ assertPaths(validator.validate(bean));+ assertNull(MetaConstraint.get());+ }).get(5, TimeUnit.SECONDS);+ } catch (Exception e) {+ throw new AssertionError(e);+ }+ assertSame(enclosing, MetaConstraint.get());+ };+ assertPaths(validator.validate(probe));+ assertNull(MetaConstraint.get());+ } finally {+ executor.shutdownNow();+ }+ }++ public static class NumericSetting {+ String value;++ @NotNull+ @Interpolative(exampleVar = "42")+ @Pattern(regexp = "[0-9]+")+ public String getValue() {+ return value;+ }+ }++ public static class NumericList {+ List<String> values;++ @Interpolative(exampleVar = "42")+ @NumericElements+ public List<String> getValues() {+ return values;+ }+ }++ @Target(java.lang.annotation.ElementType.METHOD)+ @Retention(java.lang.annotation.RetentionPolicy.RUNTIME)+ @Constraint(validatedBy = NumericElementsValidator.class)+ public @interface NumericElements {+ String message() default "Expected numeric elements";+ Class<?>[] groups() default {};+ Class<? extends Payload>[] payload() default {};+ }++ public static class NumericElementsValidator implements ConstraintValidator<NumericElements, List<String>> {+ @Override+ public boolean isValid(List<String> value, ConstraintValidatorContext context) {+ return value == null || value.stream().allMatch(it -> it.matches("[0-9]+"));+ }+ }++ @ClassValidating+ public static class ValidationProbe implements Validatable {+ Runnable action;++ @Override+ public boolean isValid(ConstraintValidatorContext context) {+ action.run();+ return true;+ }+ }+}diff --git a/server-core/src/test/java/io/onedev/server/validation/HibernateValidationOrderTest.java b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationOrderTest.javanew file mode 100644index 0000000000..f464f03b90--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationOrderTest.java@@ -0,0 +1,117 @@+package io.onedev.server.validation;++import static org.junit.Assert.assertEquals;++import java.util.ArrayList;+import java.util.List;++import javax.validation.ConstraintValidatorContext;+import javax.validation.GroupSequence;+import javax.validation.Valid;+import javax.validation.constraints.NotNull;+import javax.validation.groups.Default;++import org.junit.Test;++import io.onedev.server.annotation.ClassValidating;++public class HibernateValidationOrderTest extends HibernateValidationTestSupport {++ @Test+ public void classValidationWaitsForPropertiesAndCascadedBeans() {+ // BuildSpec.isValid runs after nested jobs/steps are validated. Cover the default,+ // explicit group, and group-sequence paths through the customized ValidatorImpl.+ for (Class<?> group : new Class<?>[] {Default.class, Checks.class, OrderedChecks.class}) {+ var root = new Root();+ root.name = "job";+ root.child.name = "step";+ assertPaths(validator.validate(root, group));+ assertEquals(List.of("child", "root"), root.calls);+ }+ }++ @Test+ public void invalidPropertySuppressesClassValidationOnlyOutsideTheDefaultGroup() {+ for (Class<?> group : new Class<?>[] {Default.class, Checks.class, OrderedChecks.class}) {+ var root = new Root();+ root.child.name = "step";+ assertPaths(validator.validate(root, group), "name");+ // The default-group path bypasses the existing failure guard.+ assertEquals(group == Default.class ? List.of("child", "root") : List.of(), root.calls);+ }+ }++ @Test+ public void invalidNestedPropertySuppressesClassValidationOnlyOutsideTheDefaultGroup() {+ for (Class<?> group : new Class<?>[] {Default.class, Checks.class, OrderedChecks.class}) {+ var root = new Root();+ root.name = "job";+ assertPaths(validator.validate(root, group), "child.name");+ assertEquals(group == Default.class ? List.of("child", "root") : List.of(), root.calls);+ }+ }++ @Test+ public void nestedClassViolationSuppressesParentValidationOnlyOutsideTheDefaultGroup() {+ for (Class<?> group : new Class<?>[] {Default.class, Checks.class, OrderedChecks.class}) {+ var root = new Root();+ root.name = "job";+ root.child.name = "step";+ root.child.valid = false;+ assertPaths(validator.validate(root, group), "child");+ assertEquals(group == Default.class ? List.of("child", "root") : List.of("child"), root.calls);+ }+ }++ public interface Checks {+ }++ @GroupSequence({Checks.class, Default.class})+ public interface OrderedChecks {+ }++ @ClassValidating(groups = {Default.class, Checks.class})+ public static class Root implements Validatable {+ final List<String> calls = new ArrayList<>();+ final Child child = new Child(calls);+ String name;++ @NotNull(groups = {Default.class, Checks.class})+ public String getName() {+ return name;+ }++ @Valid+ public Child getChild() {+ return child;+ }++ @Override+ public boolean isValid(ConstraintValidatorContext context) {+ calls.add("root");+ return true;+ }+ }++ @ClassValidating(groups = {Default.class, Checks.class}, message = "Invalid step")+ public static class Child implements Validatable {+ final List<String> calls;+ String name;+ boolean valid = true;++ Child(List<String> calls) {+ this.calls = calls;+ }++ @NotNull(groups = {Default.class, Checks.class})+ public String getName() {+ return name;+ }++ @Override+ public boolean isValid(ConstraintValidatorContext context) {+ calls.add("child");+ return valid;+ }+ }+}diff --git a/server-core/src/test/java/io/onedev/server/validation/HibernateValidationTestSupport.java b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationTestSupport.javanew file mode 100644index 0000000000..98e6be401f--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationTestSupport.java@@ -0,0 +1,39 @@+package io.onedev.server.validation;++import static org.junit.Assert.assertEquals;++import java.util.Arrays;+import java.util.Set;+import java.util.stream.Collectors;++import javax.validation.ConstraintViolation;+import javax.validation.Validation;+import javax.validation.Validator;+import javax.validation.ValidatorFactory;++import org.junit.After;+import org.junit.Before;++public abstract class HibernateValidationTestSupport {++ private ValidatorFactory factory;++ protected Validator validator;++ @Before+ public void createValidator() {+ factory = Validation.buildDefaultValidatorFactory();+ validator = factory.getValidator();+ }++ @After+ public void closeValidator() {+ factory.close();+ }++ protected void assertPaths(Set<? extends ConstraintViolation<?>> violations, String... expected) {+ assertEquals(Arrays.stream(expected).collect(Collectors.toSet()), violations.stream()+ .map(it -> it.getPropertyPath().toString()).collect(Collectors.toSet()));+ assertEquals("Unexpected duplicate violations: " + violations, expected.length, violations.size());+ }+}diff --git a/server-core/src/test/java/io/onedev/server/validation/HibernateValidationVisibilityTest.java b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationVisibilityTest.javanew file mode 100644index 0000000000..02da3949b9--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/validation/HibernateValidationVisibilityTest.java@@ -0,0 +1,210 @@+package io.onedev.server.validation;++import static org.junit.Assert.assertSame;+import static org.junit.Assert.assertThrows;++import java.util.List;++import javax.validation.Valid;+import javax.validation.constraints.NotNull;++import org.junit.Test;++import io.onedev.server.annotation.DependsOn;+import io.onedev.server.annotation.Editable;+import io.onedev.server.annotation.ShowCondition;+import io.onedev.server.util.EditContext;++public class HibernateValidationVisibilityTest extends HibernateValidationTestSupport {++ @Test+ public void hiddenPropertiesAndNestedBeansAreNotValidated() {+ var bean = new DependentSettings();+ assertPaths(validator.validate(bean));+ bean.enabled = true;+ assertPaths(validator.validate(bean), "name", "child.name", "children[0].name");+ bean.enabled = false;+ assertPaths(validator.validate(bean));+ }++ @Test+ public void allRepeatedDependenciesMustBeSatisfied() {+ // OD-2884: a setting can depend on more than one privilege or mode.+ var bean = new MultipleDependencies();+ for (boolean enabled : new boolean[] {false, true}) {+ for (String mode : new String[] {"read", "write"}) {+ bean.enabled = enabled;+ bean.mode = mode;+ if (enabled && mode.equals("write"))+ assertPaths(validator.validate(bean), "name", "child.name", "children[0].name");+ else+ assertPaths(validator.validate(bean));+ }+ }+ }++ @Test+ public void showConditionsUseBeanValuesAndRestoreTheOuterEditContext() {+ EditContext outer = name -> "outer value";+ EditContext.push(outer);+ try {+ var bean = new ConditionalSettings();+ assertPaths(validator.validate(bean));+ assertSame(outer, EditContext.get());+ bean.enabled = true;+ assertPaths(validator.validate(bean), "name", "child.name", "children[0].name");+ assertSame(outer, EditContext.get());+ } finally {+ EditContext.pop();+ }+ }++ @Test+ public void showConditionsCanLookUpEditableDisplayNames() {+ // OD-2560: parameter show conditions use display names, not only Java property names.+ var bean = new DisplayNameCondition();+ assertPaths(validator.validate(bean));+ bean.enabled = true;+ assertPaths(validator.validate(bean), "name");+ }++ @Test+ public void failingShowConditionRestoresTheOuterEditContext() {+ EditContext outer = name -> "outer value";+ EditContext.push(outer);+ try {+ assertThrows(RuntimeException.class, () -> validator.validate(new BrokenCondition()));+ assertSame(outer, EditContext.get());+ } finally {+ EditContext.pop();+ }+ }++ public static class Child {+ @NotNull+ public String getName() {+ return null;+ }+ }++ public static class DependentSettings {+ boolean enabled;+ private final Child child = new Child();+ private final List<Child> children = List.of(new Child());++ public boolean isEnabled() {+ return enabled;+ }++ @NotNull+ @DependsOn(property = "enabled")+ public String getName() {+ return null;+ }++ @Valid+ @DependsOn(property = "enabled")+ public Child getChild() {+ return child;+ }++ @Valid+ @DependsOn(property = "enabled")+ public List<Child> getChildren() {+ return children;+ }+ }++ public static class MultipleDependencies extends DependentSettings {+ String mode;++ public String getMode() {+ return mode;+ }++ @Override+ @NotNull+ @DependsOn(property = "enabled")+ @DependsOn(property = "mode", value = "read", inverse = true)+ public String getName() {+ return null;+ }++ @Override+ @Valid+ @DependsOn(property = "enabled")+ @DependsOn(property = "mode", value = "write")+ public Child getChild() {+ return super.getChild();+ }++ @Override+ @Valid+ @DependsOn(property = "enabled")+ @DependsOn(property = "mode", value = "write")+ public List<Child> getChildren() {+ return super.getChildren();+ }+ }++ public static class ConditionalSettings {+ boolean enabled;++ public boolean isEnabled() {+ return enabled;+ }++ @NotNull+ @ShowCondition("isVisible")+ public String getName() {+ return null;+ }++ @Valid+ @ShowCondition("isVisible")+ public Child getChild() {+ return new Child();+ }++ @Valid+ @ShowCondition("isVisible")+ public List<Child> getChildren() {+ return List.of(new Child());+ }++ public static boolean isVisible() {+ return (boolean) EditContext.get().getInputValue("enabled");+ }+ }++ public static class DisplayNameCondition {+ boolean enabled;++ @Editable(name = "Enable Advanced Settings")+ public boolean isEnabled() {+ return enabled;+ }++ @NotNull+ @ShowCondition("isVisible")+ public String getName() {+ return null;+ }++ public static boolean isVisible() {+ return (boolean) EditContext.get().getInputValue("Enable Advanced Settings");+ }+ }++ public static class BrokenCondition {+ @NotNull+ @ShowCondition("isVisible")+ public String getName() {+ return null;+ }++ public static boolean isVisible() {+ throw new IllegalStateException("broken condition");+ }+ }+}diff --git a/server-core/src/test/java/org/hibernate/README.md b/server-core/src/test/java/org/hibernate/README.mdnew file mode 100644index 0000000000..ab961a777a--- /dev/null+++ b/server-core/src/test/java/org/hibernate/README.md@@ -0,0 +1,48 @@+# Hibernate customization regression tests++OneDev overrides seven Hibernate classes in `server-core/src/main/java/org/hibernate`.+The reasons below were checked against Git history and the source jars for the+versions in `pom.xml`: Hibernate ORM 5.4.24.Final and Hibernate Validator 6.2.5.Final.++| Customized class | Why OneDev needs it | Regression coverage |+| --- | --- | --- |+| `cache.spi.support.SimpleTimestamper` | Replace the clock-based busy loop with an atomic counter to prevent excessive CPU usage during cache timestamp generation. Introduced in `8de9b24808` for #711. | `SimpleTimestamperTest`: a counter ahead of the wall clock still advances; concurrent cache users get unique, increasing timestamps. The clock regression uses an isolated counter, not the machine clock. |+| `proxy.pojo.BasicLazyInitializer` | Apply `AbstractEntity` ID equality and hashing without loading the entity. Added with the large-user-count performance improvements in `a32c76862a` (#875). Collection membership checks should not fetch every referenced user. | `BasicLazyInitializerTest`: detached references with equal/different IDs, loaded entities, null/unrelated values, unsaved identity semantics, and ordinary method delegation. Calls the interceptor directly because `AbstractEntity`'s final methods can bypass interception on real proxies. |+| `validator.internal.metadata.aggregated.MetaDataBuilder` | Let editable subclasses replace constraint attributes instead of combining parent and child annotations of the same type. Introduced in `de278c1554`. | `HibernateValidationInheritanceTest`: metadata contains the child's `@Size`, and value validation uses its limit and message. |+| `validator.internal.engine.MethodValidationConfiguration` | Permit `@Valid` on both overridden and overriding getters, consistent with OneDev's getter replacement semantics. Added in `e3b23bd5ba` for Kaniko build-spec validation, OD-2564. | `HibernateValidationInheritanceTest`: redeclared object and collection cascades build metadata successfully and still report invalid children. |+| `validator.internal.engine.ValidatorImpl` | Respect removed/overridden getter constraints and cascades; skip fields and nested beans hidden by `@DependsOn` or `@ShowCondition`; validate properties and nested beans before `@ClassValidating`, and suppress class validation after failures. The changes span `de278c1554`, `8ac7615738`, `77cf1da58c`, and `e3b23bd5ba`. Display-name lookup fixes hidden parameters (OD-2560, `0defe8b62a`); repeated dependencies support multiple visibility conditions (OD-2884, `91457af05e`). | `HibernateValidationInheritanceTest`, `HibernateValidationVisibilityTest`, and `HibernateValidationOrderTest`: inherited/replaced/removed annotations, visible and hidden scalar/object/list properties, repeated/inverse dependencies, display-name lookup, edit-context cleanup, and successful/failing recursive validation through default groups, explicit groups, and sequences. |+| `validator.internal.engine.constraintvalidation.ConstraintTree` | Validate the shape of interpolative settings before runtime variables are available: substitute `@Interpolative.exampleVar` and unescape `@@` before other validators run. Apply this to strings and collections, while leaving syntax errors to `InterpolativeValidator`. Introduced with #222 in `0dd7555781`; the real create-tag scenario was added in #1242 (`52dca1aab9`). | `HibernateValidationInterpolationTest`: real `CreateTagStep` names, escaped at signs, custom example values, invalid literals, malformed interpolation, null values, and collections. Assertions also ensure validation does not modify the bean or the reported invalid value. |+| `validator.internal.metadata.core.MetaConstraint` | Expose the active constraint's getter metadata to `ConstraintTree` with a thread-local stack. Added alongside interpolation in `0dd7555781`; nested validation must restore the previous constraint and exceptions must clean it up. | `HibernateValidationInterpolationTest`: interpolation through the public validator API, nested validation, exception cleanup, and isolation between concurrent validation threads. |++The validation tests are in `io/onedev/server/validation`. They use a real+`ValidatorFactory` and small beans so they need neither a running OneDev server+nor a database. These behaviors intentionally differ from standard Bean Validation.++## Existing behavior preserved by the tests++The tests also record two distinctions in the existing `ValidatorImpl` behavior:++- A child annotation replaces the parent in property metadata, `validateValue`,+ and explicit-group validation, but default-group bean/property validation still+ checks the parent's attributes when the child redeclares the same annotation type.+ Parent getter annotations whose+ types are absent from the overriding getter are skipped.+- Default-group validation bypasses the class-validation failure guard: class+ validators still run after property or nested validation failures. Explicit+ non-default groups suppress them; sequences stop after a failing group.++These cases are covered in the inheritance and ordering tests. No production+Hibernate classes are changed.++## Running the tests++From the repository root:++```sh+./dev.sh test -pl server-core '-Dtest=SimpleTimestamperTest,BasicLazyInitializerTest,HibernateValidation*Test'+```++Each customization was also disabled individually in a temporary classpath to+verify that this suite detects its removal. For `MetaConstraint`, the accessor API+was retained while disabling push/pop, so the check exercises context propagation+rather than a missing-method error. The other six checks used the upstream class.diff --git a/server-core/src/test/java/org/hibernate/cache/spi/support/SimpleTimestamperTest.java b/server-core/src/test/java/org/hibernate/cache/spi/support/SimpleTimestamperTest.javanew file mode 100644index 0000000000..46eb62ff3b--- /dev/null+++ b/server-core/src/test/java/org/hibernate/cache/spi/support/SimpleTimestamperTest.java@@ -0,0 +1,70 @@+package org.hibernate.cache.spi.support;++import static org.junit.Assert.assertEquals;+import static org.junit.Assert.assertTrue;++import java.net.URLClassLoader;+import java.util.ArrayList;+import java.util.HashSet;+import java.util.concurrent.Callable;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicLong;++import org.junit.Test;++public class SimpleTimestamperTest {++ @Test+ public void keepsGeneratingCacheTimestampsWhenClockFallsBehind() throws Exception {+ // #711: the upstream clock-based loop spins when its counter is ahead of the clock.+ // Isolate the static counter so this test cannot affect another cache user.+ try (var loader = new URLClassLoader(new java.net.URL[] {+ SimpleTimestamper.class.getProtectionDomain().getCodeSource().getLocation()+ }, ClassLoader.getPlatformClassLoader())) {+ var timestamper = loader.loadClass(SimpleTimestamper.class.getName());+ var field = timestamper.getDeclaredField("VALUE");+ field.setAccessible(true);+ var counter = (AtomicLong) field.get(null);+ long future = (System.currentTimeMillis() + TimeUnit.DAYS.toMillis(1)) * SimpleTimestamper.ONE_MS;+ counter.set(future);+ var executor = Executors.newSingleThreadExecutor();+ try {+ var next = executor.submit(() -> (Long) timestamper.getMethod("next").invoke(null));+ assertEquals(future + 1, (long) next.get(5, TimeUnit.SECONDS));+ } finally {+ // Also releases the upstream spin loop if this regression is reintroduced.+ counter.set(0);+ executor.shutdownNow();+ assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS));+ }+ }+ }++ @Test+ public void concurrentCacheUsersReceiveDistinctIncreasingTimestamps() throws Exception {+ var executor = Executors.newFixedThreadPool(4);+ try {+ var tasks = new ArrayList<Callable<long[]>>();+ for (int i = 0; i < 4; i++) {+ tasks.add(() -> {+ long[] timestamps = new long[10000];+ for (int j = 0; j < timestamps.length; j++) {+ timestamps[j] = SimpleTimestamper.next();+ if (j != 0)+ assertTrue(timestamps[j] > timestamps[j - 1]);+ }+ return timestamps;+ });+ }+ var distinct = new HashSet<Long>();+ for (var result : executor.invokeAll(tasks)) {+ for (long timestamp : result.get())+ assertTrue("Duplicate cache timestamp", distinct.add(timestamp));+ }+ assertEquals(40000, distinct.size());+ } finally {+ executor.shutdownNow();+ }+ }+}diff --git a/server-core/src/test/java/org/hibernate/proxy/pojo/BasicLazyInitializerTest.java b/server-core/src/test/java/org/hibernate/proxy/pojo/BasicLazyInitializerTest.javanew file mode 100644index 0000000000..afb7d064f8--- /dev/null+++ b/server-core/src/test/java/org/hibernate/proxy/pojo/BasicLazyInitializerTest.java@@ -0,0 +1,96 @@+package org.hibernate.proxy.pojo;++import static org.junit.Assert.assertEquals;+import static org.junit.Assert.assertFalse;+import static org.junit.Assert.assertSame;+import static org.junit.Assert.assertTrue;++import org.junit.Test;++import io.onedev.server.model.AbstractEntity;++public class BasicLazyInitializerTest {++ @Test+ public void comparesEntityIdsWithoutLoadingDetachedProxies() throws Throwable {+ // #875: membership checks over large collections of users must not load each user.+ // Exercise the interceptor directly: AbstractEntity's final equals/hashCode would+ // otherwise bypass it on a ByteBuddy proxy and fail to protect this customization.+ for (boolean overridesEquals : new boolean[] {false, true}) {+ var initializer = new Initializer(42L, overridesEquals);+ var proxy = new EntityReference(initializer);+ var same = new EntityReference(new Initializer(42L, overridesEquals));+ var other = new EntityReference(new Initializer(43L, overridesEquals));+ var loaded = new EntityReference(null);+ loaded.setId(42L);++ assertEquals(true, initializer.call("equals", proxy, proxy));+ assertEquals(true, initializer.call("equals", proxy, same));+ assertEquals(true, initializer.call("equals", proxy, loaded));+ assertTrue(loaded.equals(proxy));+ assertEquals(false, initializer.call("equals", proxy, other));+ assertEquals(false, initializer.call("equals", proxy, (Object) null));+ assertEquals(false, initializer.call("equals", proxy, "42"));+ assertEquals(loaded.hashCode(), initializer.call("hashCode", proxy));+ assertEquals(initializer.call("hashCode", proxy), same.hashCode());+ assertTrue(initializer.isUninitialized());+ assertTrue(same.initializer.isUninitialized());+ assertTrue(other.initializer.isUninitialized());+ }+ }++ @Test+ public void unsavedEntitiesKeepIdentitySemantics() throws Throwable {+ var initializer = new Initializer(null, true);+ var proxy = new EntityReference(initializer);+ var other = new EntityReference(new Initializer(null, true));+ assertEquals(true, initializer.call("equals", proxy, proxy));+ assertEquals(false, initializer.call("equals", proxy, other));+ assertFalse(other.equals(proxy));+ assertEquals(System.identityHashCode(proxy), initializer.call("hashCode", proxy));+ assertTrue(initializer.isUninitialized());+ }++ @Test+ public void ordinaryMethodsStillDelegateToTheEntity() throws Throwable {+ var initializer = new Initializer(42L, true);+ var proxy = new EntityReference(initializer);+ assertEquals(42L, initializer.invoke(AbstractEntity.class.getMethod("getId"), new Object[0], proxy));+ assertSame(BasicLazyInitializer.INVOKE_IMPLEMENTATION,+ initializer.invoke(AbstractEntity.class.getMethod("isNew"), new Object[0], proxy));+ assertTrue(initializer.isUninitialized());+ }++ private static class Initializer extends BasicLazyInitializer {+ private Initializer(Long id, boolean overridesEquals) throws NoSuchMethodException {+ super(EntityReference.class.getName(), EntityReference.class, id,+ AbstractEntity.class.getMethod("getId"), AbstractEntity.class.getMethod("setId", Long.class),+ null, null, overridesEquals);+ }++ private Object call(String method, Object proxy, Object... args) throws Throwable {+ return invoke(args.length == 0 ? Object.class.getMethod(method) : Object.class.getMethod(method, Object.class),+ args, proxy);+ }++ @Override+ protected Object serializableProxy() {+ throw new AssertionError("Unexpected serialization");+ }+ }++ private static class EntityReference extends AbstractEntity {+ private static final long serialVersionUID = 1L;++ private final Initializer initializer;++ private EntityReference(Initializer initializer) {+ this.initializer = initializer;+ }++ @Override+ public Long getId() {+ return initializer != null ? (Long) initializer.getIdentifier() : super.getId();+ }+ }+}