Skip to content

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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.md
new file mode 100644
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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();
+ }
+ }
+}