From aa4019dcb136370bb2ac4e450f4129edb9dd57ca Mon Sep 17 00:00:00 2001 From: quinnandrews Date: Wed, 24 Jan 2024 11:08:54 -0800 Subject: [PATCH] Migrate Factory methods to static methods and rename to match the language used by the Builder. --- .../builder/SpecificationBuilder.java | 74 ++++--- .../builder/SpecificationFactory.java | 66 +++--- .../builder/SpecificationBuilderTest.java | 10 +- .../builder/SpecificationFactoryTest.java | 204 +++++++++--------- .../GuitarPedalSpecifications.java | 34 +-- 5 files changed, 196 insertions(+), 192 deletions(-) diff --git a/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilder.java b/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilder.java index 0828f49..b24fc66 100644 --- a/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilder.java +++ b/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilder.java @@ -15,8 +15,6 @@ * @author Quinn Andrews */ public class SpecificationBuilder { - - private final SpecificationFactory specificationFactory = new SpecificationFactory(); private Specification specification; @@ -77,188 +75,188 @@ public SpecificationBuilder orWhere(final Specification specification) { @Deprecated public SpecificationBuilder whereEquals(final SingularAttribute attribute, final Object value) { - return where(specificationFactory.equal(attribute, value)); + return where(SpecificationFactory.isEqualTo(attribute, value)); } @Deprecated public SpecificationBuilder whereNotEquals(final SingularAttribute attribute, final Object value) { - return where(specificationFactory.notEqual(attribute, value)); + return where(SpecificationFactory.isNotEqualTo(attribute, value)); } @Deprecated public SpecificationBuilder whereLike(final SingularAttribute attribute, final String value) { - return where(specificationFactory.like(attribute, value)); + return where(SpecificationFactory.isLike(attribute, value)); } @Deprecated public SpecificationBuilder whereNotLike(final SingularAttribute attribute, final String value) { - return where(specificationFactory.notLike(attribute, value)); + return where(SpecificationFactory.isNotLike(attribute, value)); } @Deprecated public SpecificationBuilder whereEqualsOrLike(final SingularAttribute attribute, final String value) { - return where(specificationFactory.equalOrLike(attribute, value)); + return where(SpecificationFactory.isEqualToOrLike(attribute, value)); } @Deprecated public SpecificationBuilder whereIsNull(final SingularAttribute attribute) { - return where(specificationFactory.isNull(attribute)); + return where(SpecificationFactory.isNull(attribute)); } @Deprecated public SpecificationBuilder whereIsNotNull(final SingularAttribute attribute) { - return where(specificationFactory.isNotNull(attribute)); + return where(SpecificationFactory.isNotNull(attribute)); } @Deprecated public SpecificationBuilder whereIsTrue(final SingularAttribute attribute) { - return where(specificationFactory.isTrue(attribute)); + return where(SpecificationFactory.isTrue(attribute)); } @Deprecated public SpecificationBuilder whereIsFalse(final SingularAttribute attribute) { - return where(specificationFactory.isFalse(attribute)); + return where(SpecificationFactory.isFalse(attribute)); } @Deprecated public > SpecificationBuilder whereGreaterThan(final SingularAttribute attribute, final V value) { - return where(specificationFactory.greaterThan(attribute, value)); + return where(SpecificationFactory.isGreaterThan(attribute, value)); } @Deprecated public > SpecificationBuilder whereGreaterThanOrEqualTo(final SingularAttribute attribute, final V value) { - return where(specificationFactory.greaterThanOrEqualTo(attribute, value)); + return where(SpecificationFactory.isGreaterThanOrEqualTo(attribute, value)); } @Deprecated public > SpecificationBuilder whereLessThan(final SingularAttribute attribute, final V value) { - return where(specificationFactory.lessThan(attribute, value)); + return where(SpecificationFactory.isLessThan(attribute, value)); } @Deprecated public > SpecificationBuilder whereLessThanOrEqualTo(final SingularAttribute attribute, final V value) { - return where(specificationFactory.lessThanOrEqualTo(attribute, value)); + return where(SpecificationFactory.isLessThanOrEqualTo(attribute, value)); } @Deprecated public > SpecificationBuilder whereBetween(final SingularAttribute attribute, final V firstValue, final V secondValue) { - return where(specificationFactory.between(attribute, firstValue, secondValue)); + return where(SpecificationFactory.isBetween(attribute, firstValue, secondValue)); } @Deprecated public SpecificationBuilder whereIn(final SingularAttribute attribute, final Collection collection) { - return where(specificationFactory.in(attribute, collection)); + return where(SpecificationFactory.isIn(attribute, collection)); } @Deprecated public SpecificationBuilder whereIn(final SingularAttribute attribute, final Object... values) { - return where(specificationFactory.in(attribute, values)); + return where(SpecificationFactory.isIn(attribute, values)); } @Deprecated public SpecificationBuilder withFetch(final SingularAttribute attribute) { - return and(specificationFactory.fetch(attribute)); + return and(SpecificationFactory.fetch(attribute)); } @Deprecated public SpecificationBuilder withFetch(final PluralAttribute attribute) { - return and(specificationFactory.fetch(attribute)); + return and(SpecificationFactory.fetch(attribute)); } public SpecificationBuilder isEqualTo(final SingularAttribute attribute, final Object value) { - return where(specificationFactory.equal(attribute, value)); + return where(SpecificationFactory.isEqualTo(attribute, value)); } public SpecificationBuilder isNotEqualTo(final SingularAttribute attribute, final Object value) { - return where(specificationFactory.notEqual(attribute, value)); + return where(SpecificationFactory.isNotEqualTo(attribute, value)); } public SpecificationBuilder isLike(final SingularAttribute attribute, final String value) { - return where(specificationFactory.like(attribute, value)); + return where(SpecificationFactory.isLike(attribute, value)); } public SpecificationBuilder isNotLike(final SingularAttribute attribute, final String value) { - return where(specificationFactory.notLike(attribute, value)); + return where(SpecificationFactory.isNotLike(attribute, value)); } public SpecificationBuilder isEqualToOrLike(final SingularAttribute attribute, final String value) { - return where(specificationFactory.equalOrLike(attribute, value)); + return where(SpecificationFactory.isEqualToOrLike(attribute, value)); } public SpecificationBuilder isNull(final SingularAttribute attribute) { - return where(specificationFactory.isNull(attribute)); + return where(SpecificationFactory.isNull(attribute)); } public SpecificationBuilder isNotNull(final SingularAttribute attribute) { - return where(specificationFactory.isNotNull(attribute)); + return where(SpecificationFactory.isNotNull(attribute)); } public SpecificationBuilder isTrue(final SingularAttribute attribute) { - return where(specificationFactory.isTrue(attribute)); + return where(SpecificationFactory.isTrue(attribute)); } public SpecificationBuilder isFalse(final SingularAttribute attribute) { - return where(specificationFactory.isFalse(attribute)); + return where(SpecificationFactory.isFalse(attribute)); } public > SpecificationBuilder isGreaterThan(final SingularAttribute attribute, final V value) { - return where(specificationFactory.greaterThan(attribute, value)); + return where(SpecificationFactory.isGreaterThan(attribute, value)); } public > SpecificationBuilder isGreaterThanOrEqualTo(final SingularAttribute attribute, final V value) { - return where(specificationFactory.greaterThanOrEqualTo(attribute, value)); + return where(SpecificationFactory.isGreaterThanOrEqualTo(attribute, value)); } public > SpecificationBuilder isLessThan(final SingularAttribute attribute, final V value) { - return where(specificationFactory.lessThan(attribute, value)); + return where(SpecificationFactory.isLessThan(attribute, value)); } public > SpecificationBuilder isLessThanOrEqualTo(final SingularAttribute attribute, final V value) { - return where(specificationFactory.lessThanOrEqualTo(attribute, value)); + return where(SpecificationFactory.isLessThanOrEqualTo(attribute, value)); } public > SpecificationBuilder isBetween(final SingularAttribute attribute, final V firstValue, final V secondValue) { - return where(specificationFactory.between(attribute, firstValue, secondValue)); + return where(SpecificationFactory.isBetween(attribute, firstValue, secondValue)); } public SpecificationBuilder isIn(final SingularAttribute attribute, final Collection collection) { - return where(specificationFactory.in(attribute, collection)); + return where(SpecificationFactory.isIn(attribute, collection)); } public SpecificationBuilder isIn(final SingularAttribute attribute, final Object... values) { - return where(specificationFactory.in(attribute, values)); + return where(SpecificationFactory.isIn(attribute, values)); } public SpecificationBuilder fetch(final SingularAttribute attribute) { - return and(specificationFactory.fetch(attribute)); + return and(SpecificationFactory.fetch(attribute)); } public SpecificationBuilder fetch(final PluralAttribute attribute) { - return and(specificationFactory.fetch(attribute)); + return and(SpecificationFactory.fetch(attribute)); } } diff --git a/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactory.java b/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactory.java index 783dfc7..1fca07c 100644 --- a/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactory.java +++ b/src/main/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactory.java @@ -21,11 +21,11 @@ public class SpecificationFactory { private static final String ATTRIBUTE_CANNOT_BE_NULL = "Argument 'attribute' cannot be null."; - public SpecificationFactory() { + private SpecificationFactory() { // no-op } - public Specification equal(final SingularAttribute attribute, + public static Specification isEqualTo(final SingularAttribute attribute, final Object value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(value)) { @@ -34,7 +34,7 @@ public Specification equal(final SingularAttribute attribute, return ghost(); } - public Specification notEqual(final SingularAttribute attribute, + public static Specification isNotEqualTo(final SingularAttribute attribute, final Object value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(value)) { @@ -43,8 +43,8 @@ public Specification notEqual(final SingularAttribute attribute, return ghost(); } - public Specification like(final SingularAttribute attribute, - final String value) { + public static Specification isLike(final SingularAttribute attribute, + final String value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); final Object trimmedValue = stripToNull(value); if (noneAreNull(trimmedValue)) { @@ -56,8 +56,8 @@ public Specification like(final SingularAttribute attribute, return ghost(); } - public Specification notLike(final SingularAttribute attribute, - final String value) { + public static Specification isNotLike(final SingularAttribute attribute, + final String value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); final Object trimmedValue = stripToNull(value); if (noneAreNull(trimmedValue)) { @@ -69,34 +69,34 @@ public Specification notLike(final SingularAttribute attribute return ghost(); } - public Specification equalOrLike(final SingularAttribute attribute, - final String value) { + public static Specification isEqualToOrLike(final SingularAttribute attribute, + final String value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); - return isWildcardExpression(value) ? like(attribute, value) : equal(attribute, value); + return isWildcardExpression(value) ? isLike(attribute, value) : isEqualTo(attribute, value); } - public Specification isNull(final SingularAttribute attribute) { + public static Specification isNull(final SingularAttribute attribute) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); return (root, query, builder) -> builder.isNull(root.get(attribute)); } - public Specification isNotNull(final SingularAttribute attribute) { + public static Specification isNotNull(final SingularAttribute attribute) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); return (root, query, builder) -> builder.isNotNull(root.get(attribute)); } - public Specification isTrue(final SingularAttribute attribute) { + public static Specification isTrue(final SingularAttribute attribute) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); return (root, query, builder) -> builder.isTrue(root.get(attribute).as(Boolean.class)); } - public Specification isFalse(final SingularAttribute attribute) { + public static Specification isFalse(final SingularAttribute attribute) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); return (root, query, builder) -> builder.isFalse(root.get(attribute).as(Boolean.class)); } - public > Specification greaterThan(final SingularAttribute attribute, - final V value) { + public static > Specification isGreaterThan(final SingularAttribute attribute, + final V value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(value)) { return (root, query, builder) -> builder.greaterThan(root.get(attribute), value); @@ -104,8 +104,8 @@ public > Specification greaterThan(final return ghost(); } - public > Specification greaterThanOrEqualTo(final SingularAttribute attribute, - final V value) { + public static > Specification isGreaterThanOrEqualTo(final SingularAttribute attribute, + final V value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(value)) { return (root, query, builder) -> builder.greaterThanOrEqualTo(root.get(attribute), value); @@ -113,8 +113,8 @@ public > Specification greaterThanOrEqualT return ghost(); } - public > Specification lessThan(final SingularAttribute attribute, - final V value) { + public static > Specification isLessThan(final SingularAttribute attribute, + final V value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(value)) { return (root, query, builder) -> builder.lessThan(root.get(attribute), value); @@ -122,8 +122,8 @@ public > Specification lessThan(final Sing return ghost(); } - public > Specification lessThanOrEqualTo(final SingularAttribute attribute, - final V value) { + public static > Specification isLessThanOrEqualTo(final SingularAttribute attribute, + final V value) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(value)) { return (root, query, builder) -> builder.lessThanOrEqualTo(root.get(attribute), value); @@ -131,9 +131,9 @@ public > Specification lessThanOrEqualTo(f return ghost(); } - public > Specification between(final SingularAttribute attribute, - final V firstValue, - final V secondValue) { + public static > Specification isBetween(final SingularAttribute attribute, + final V firstValue, + final V secondValue) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(firstValue, secondValue)) { return (root, query, builder) -> builder.between(root.get(attribute), firstValue, secondValue); @@ -141,8 +141,8 @@ public > Specification between(final Singu return ghost(); } - public Specification in(final SingularAttribute attribute, - final Collection collection) { + public static Specification isIn(final SingularAttribute attribute, + final Collection collection) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(collection) && !collection.isEmpty()) { return (root, query, builder) -> root.get(attribute).in(collection); @@ -150,15 +150,15 @@ public Specification in(final SingularAttribute attribute, return ghost(); } - public Specification in(final SingularAttribute attribute, - final Object... values) { + public static Specification isIn(final SingularAttribute attribute, + final Object... values) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); - return in(attribute, Arrays.stream(values) + return isIn(attribute, Arrays.stream(values) .filter(SpecificationUtil::noneAreNull) .collect(Collectors.toSet())); } - public Specification fetch(final SingularAttribute attribute) { + public static Specification fetch(final SingularAttribute attribute) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(attribute)) { return (root, query, builder) -> { @@ -169,7 +169,7 @@ public Specification fetch(final SingularAttribute attribute) { return ghost(); } - public Specification fetch(final PluralAttribute attribute) { + public static Specification fetch(final PluralAttribute attribute) { Objects.requireNonNull(attribute, ATTRIBUTE_CANNOT_BE_NULL); if (noneAreNull(attribute)) { return (root, query, builder) -> { @@ -180,7 +180,7 @@ public Specification fetch(final PluralAttribute attribute) { return ghost(); } - public Specification ghost() { + public static Specification ghost() { return (root, query, builder) -> null; } } diff --git a/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilderTest.java b/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilderTest.java index 6cffab5..7a228ff 100644 --- a/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilderTest.java +++ b/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationBuilderTest.java @@ -72,7 +72,7 @@ void where_returnsBuilder() { @Test void where_returnsBuilderWithSpecification() { var builder = SpecificationBuilder.from(GuitarPedal.class) - .where(new SpecificationFactory().ghost()); + .where(SpecificationFactory.ghost()); assertNotNull(builder); assertNotNull(builder.toSpecification()); } @@ -96,7 +96,7 @@ void and_returnsBuilder() { @Test void and_returnsBuilderWithSpecification() { var builder = SpecificationBuilder.from(GuitarPedal.class) - .and(new SpecificationFactory().ghost()); + .and(SpecificationFactory.ghost()); assertNotNull(builder); assertNotNull(builder.toSpecification()); } @@ -113,7 +113,7 @@ void and_throwsException_whenArgumentIsNull() { @Test void or_returnsBuilderWithSpecification() { var builder = SpecificationBuilder.from(GuitarPedal.class) - .or(new SpecificationFactory().ghost()); + .or(SpecificationFactory.ghost()); assertNotNull(builder); assertNotNull(builder.toSpecification()); } @@ -131,7 +131,7 @@ void or_throwsException_whenArgumentIsNull() { @Deprecated void andWhere_returnsBuilderWithSpecification() { var builder = SpecificationBuilder.withRoot(GuitarPedal.class) - .andWhere(new SpecificationFactory().ghost()); + .andWhere(SpecificationFactory.ghost()); assertNotNull(builder); assertNotNull(builder.toSpecification()); } @@ -150,7 +150,7 @@ void andWhere_throwsException_whenArgumentIsNull() { @Deprecated void orWhere_returnsBuilderWithSpecification() { var builder = SpecificationBuilder.withRoot(GuitarPedal.class) - .orWhere(new SpecificationFactory().ghost()); + .orWhere(SpecificationFactory.ghost()); assertNotNull(builder); assertNotNull(builder.toSpecification()); } diff --git a/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactoryTest.java b/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactoryTest.java index c8288fe..24196d0 100644 --- a/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactoryTest.java +++ b/src/test/java/io/github/quinnandrews/spring/data/specification/builder/SpecificationFactoryTest.java @@ -11,6 +11,7 @@ import io.github.quinnandrews.spring.data.specification.builder.application.Application; import io.github.quinnandrews.spring.data.specification.builder.application.data.guitarpedals.GuitarPedal; import io.github.quinnandrews.spring.data.specification.builder.application.data.guitarpedals.GuitarPedal_; +import org.mockito.Mockito; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.jpa.domain.Specification; @@ -19,14 +20,13 @@ import java.util.Collection; import java.util.List; +import static io.github.quinnandrews.spring.data.specification.builder.SpecificationFactory.*; import static org.junit.jupiter.api.Assertions.*; import static org.mockito.Mockito.*; @SpringBootTest(classes = Application.class) class SpecificationFactoryTest { - private final SpecificationFactory specificationFactory = new SpecificationFactory(); - @Autowired private EntityManager entityManager; @@ -42,129 +42,135 @@ void setUp() { } @Test - void equal_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.equal(GuitarPedal_.id, 0L); + void isEqualTo_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isEqualTo(GuitarPedal_.id, 0L); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void equal_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.equal(GuitarPedal_.id, null); + void isEqualTo_returnsNullPredicate_whenValueIsNull() { + var specification = isEqualTo(GuitarPedal_.id, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void equal_throwsException_whenAttributeIsNull() { + void isEqualTo_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.equal(null, 0L)); + () -> isEqualTo(null, 0L)); } @Test - void notEqual_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.notEqual(GuitarPedal_.id, 0L); + void isNotEqual_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isNotEqualTo(GuitarPedal_.id, 0L); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void notEqual_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.notEqual(GuitarPedal_.id, null); + void isNotEqual_returnsNullPredicate_whenValueIsNull() { + var specification = isNotEqualTo(GuitarPedal_.id, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void notEqual_throwsException_whenAttributeIsNull() { + void isNotEqual_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.notEqual(null, 0L)); + () -> isNotEqualTo(null, 0L)); } @Test - void like_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.like(GuitarPedal_.name, "%test%"); + void isLike_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isLike(GuitarPedal_.name, "%test%"); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void like_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.like(GuitarPedal_.name, null); + void isLike_returnsNullPredicate_whenValueIsNull() { + var specification = isLike(GuitarPedal_.name, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void like_throwsException_whenAttributeIsNull() { + void isLike_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.like(null, "%test%")); + () -> isLike(null, "%test%")); } @Test - void notLike_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.notLike(GuitarPedal_.name, "%test%"); + void isNotLike_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isNotLike(GuitarPedal_.name, "%test%"); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void notLike_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.notLike(GuitarPedal_.name, null); + void isNotLike_returnsNullPredicate_whenValueIsNull() { + var specification = isNotLike(GuitarPedal_.name, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void notLike_throwsException_whenAttributeIsNull() { + void isNotLike_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.notLike(null, "%test%")); + () -> isNotLike(null, "%test%")); } @Test - void equalOrLike_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.equalOrLike(GuitarPedal_.name, "%test%"); + void isEqualToOrLike_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isEqualToOrLike(GuitarPedal_.name, "%test%"); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void equalOrLike_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.equalOrLike(GuitarPedal_.name, null); + void isEqualToOrLike_returnsNullPredicate_whenValueIsNull() { + var specification = isEqualToOrLike(GuitarPedal_.name, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void equalOrLike_callsEqual_whenValueContainsNoWildcards() { - var specificationFactory = spy(this.specificationFactory); - specificationFactory.equalOrLike(GuitarPedal_.name, "test"); - verify(specificationFactory, times(1)).equal(GuitarPedal_.name, "test"); - verify(specificationFactory, times(0)).like(GuitarPedal_.name, "test"); + void isEqualToOrLike_callsIsEqualTo_whenValueContainsNoWildcards() { + try (var mockedStatic = mockStatic( + SpecificationFactory.class, + Mockito.withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))) { + isEqualToOrLike(GuitarPedal_.name, "test"); + mockedStatic.verify(() -> SpecificationFactory.isEqualTo(GuitarPedal_.name,"test"), times(1)); + mockedStatic.verify(() -> SpecificationFactory.isLike(GuitarPedal_.name,"test"), times(0)); + } } @Test - void equalOrLike_callsLike_whenValueContainsWildcards() { - var specificationFactory = spy(this.specificationFactory); - specificationFactory.equalOrLike(GuitarPedal_.name, "%test%"); - verify(specificationFactory, times(0)).equal(GuitarPedal_.name, "%test%"); - verify(specificationFactory, times(1)).like(GuitarPedal_.name, "%test%"); + void isEqualToOrLike_callsIsLike_whenValueContainsWildcards() { + try (var mockedStatic = mockStatic( + SpecificationFactory.class, + Mockito.withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))) { + isEqualToOrLike(GuitarPedal_.name, "%test%"); + mockedStatic.verify(() -> SpecificationFactory.isEqualTo(GuitarPedal_.name,"%test%"), times(0)); + mockedStatic.verify(() -> SpecificationFactory.isLike(GuitarPedal_.name,"%test%"), times(1)); + } } @Test - void equalOrLike_throwsException_whenAttributeIsNull() { + void isEqualToOrLike_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.equalOrLike(null, "%test%")); + () -> isEqualToOrLike(null, "%test%")); } @Test void isTrue_returnsNonNullPredicate() { - var specification = specificationFactory.isTrue(GuitarPedal_.hasStereoOutput); + var specification = isTrue(GuitarPedal_.hasStereoOutput); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @@ -173,12 +179,12 @@ void isTrue_returnsNonNullPredicate() { void isTrue_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.isTrue(null)); + () -> isTrue(null)); } @Test void isFalse_returnsNonNullPredicate() { - var specification = specificationFactory.isFalse(GuitarPedal_.hasStereoOutput); + var specification = isFalse(GuitarPedal_.hasStereoOutput); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @@ -187,12 +193,12 @@ void isFalse_returnsNonNullPredicate() { void isFalse_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.isFalse(null)); + () -> isFalse(null)); } @Test void isNull_returnsNonNullPredicate() { - var specification = specificationFactory.isNull(GuitarPedal_.dateSold); + var specification = isNull(GuitarPedal_.dateSold); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @@ -201,12 +207,12 @@ void isNull_returnsNonNullPredicate() { void isNull_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.isNull(null)); + () -> SpecificationFactory.isNull(null)); } @Test void isNotNull_returnsNonNullPredicate() { - var specification = specificationFactory.isNotNull(GuitarPedal_.dateSold); + var specification = isNotNull(GuitarPedal_.dateSold); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @@ -215,96 +221,96 @@ void isNotNull_returnsNonNullPredicate() { void isNotNull_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.isNotNull(null)); + () -> SpecificationFactory.isNotNull(null)); } @Test - void greaterThan_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.greaterThan(GuitarPedal_.usedValue, 0); + void isGreaterThan_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isGreaterThan(GuitarPedal_.usedValue, 0); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void greaterThan_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.greaterThan(GuitarPedal_.usedValue, null); + void isGreaterThan_returnsNullPredicate_whenValueIsNull() { + var specification = isGreaterThan(GuitarPedal_.usedValue, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void greaterThan_throwsException_whenAttributeIsNull() { + void isGreaterThan_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.greaterThan(null, 0)); + () -> isGreaterThan(null, 0)); } @Test - void greaterThanOrEqualTo_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.greaterThanOrEqualTo(GuitarPedal_.usedValue, 0); + void isGreaterThanOrEqualTo_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isGreaterThanOrEqualTo(GuitarPedal_.usedValue, 0); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void greaterThanOrEqualTo_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.greaterThanOrEqualTo(GuitarPedal_.usedValue, null); + void isGreaterThanOrEqualTo_returnsNullPredicate_whenValueIsNull() { + var specification = isGreaterThanOrEqualTo(GuitarPedal_.usedValue, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void greaterThanOrEqualTo_throwsException_whenAttributeIsNull() { + void isGreaterThanOrEqualTo_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.greaterThanOrEqualTo(null, 0)); + () -> isGreaterThanOrEqualTo(null, 0)); } @Test - void lessThan_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.lessThan(GuitarPedal_.usedValue, 0); + void isLessThan_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isLessThan(GuitarPedal_.usedValue, 0); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void lessThan_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.lessThan(GuitarPedal_.usedValue, null); + void isLessThan_returnsNullPredicate_whenValueIsNull() { + var specification = isLessThan(GuitarPedal_.usedValue, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void lessThan_throwsException_whenAttributeIsNull() { + void isLessThan_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.lessThan(null, 0)); + () -> isLessThan(null, 0)); } @Test - void lessThanOrEqualTo_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.lessThanOrEqualTo(GuitarPedal_.usedValue, 0); + void isLessThanOrEqualTo_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isLessThanOrEqualTo(GuitarPedal_.usedValue, 0); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void lessThanOrEqualTo_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.lessThanOrEqualTo(GuitarPedal_.usedValue, null); + void isLessThanOrEqualTo_returnsNullPredicate_whenValueIsNull() { + var specification = isLessThanOrEqualTo(GuitarPedal_.usedValue, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void lessThanOrEqualTo_throwsException_whenAttributeIsNull() { + void isLessThanOrEqualTo_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.lessThanOrEqualTo(null, 0)); + () -> isLessThanOrEqualTo(null, 0)); } @Test - void between_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.between( + void isBetween_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isBetween( GuitarPedal_.datePurchased, LocalDate.now(), LocalDate.now().plusDays(7) @@ -314,72 +320,72 @@ void between_returnsNonNullPredicate_whenValueIsNotNull() { } @Test - void between_returnsNullPredicate_whenEitherValueIsNull() { - var specification = specificationFactory.between(GuitarPedal_.usedValue, null, null); + void isBetween_returnsNullPredicate_whenEitherValueIsNull() { + var specification = isBetween(GuitarPedal_.usedValue, null, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); - specification = specificationFactory.between(GuitarPedal_.usedValue, 0, null); + specification = isBetween(GuitarPedal_.usedValue, 0, null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); - specification = specificationFactory.between(GuitarPedal_.usedValue, null, 9); + specification = isBetween(GuitarPedal_.usedValue, null, 9); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void between_throwsException_whenAttributeIsNull() { + void isBetween_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.between(null, 0L, 9L)); + () -> isBetween(null, 0L, 9L)); } @Test - void in_collection_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.in(GuitarPedal_.id, List.of(1L, 2L, 3L)); + void isIn_collection_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isIn(GuitarPedal_.id, List.of(1L, 2L, 3L)); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void in_collection_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.in(GuitarPedal_.id, (Collection) null); + void isIn_collection_returnsNullPredicate_whenValueIsNull() { + var specification = isIn(GuitarPedal_.id, (Collection) null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void in_collection_throwsException_whenAttributeIsNull() { + void isIn_collection_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.in(null, List.of(1L, 2L, 3L))); + () -> isIn(null, List.of(1L, 2L, 3L))); } @Test - void in_array_returnsNonNullPredicate_whenValueIsNotNull() { - var specification = specificationFactory.in(GuitarPedal_.id, 1L, 2L, 3L); + void isIn_array_returnsNonNullPredicate_whenValueIsNotNull() { + var specification = isIn(GuitarPedal_.id, 1L, 2L, 3L); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @Test - void in_array_returnsNullPredicate_whenValueIsNull() { - var specification = specificationFactory.in(GuitarPedal_.id, (Object) null); + void isIn_array_returnsNullPredicate_whenValueIsNull() { + var specification = isIn(GuitarPedal_.id, (Object) null); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } @Test - void in_array_throwsException_whenAttributeIsNull() { + void isIn_array_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.in(null, 1L, 2L, 3L)); + () -> isIn(null, 1L, 2L, 3L)); } @Test void fetch_singular_returnsNonNullPredicate() { - var specification = specificationFactory.fetch(GuitarPedal_.manufacturer); + var specification = fetch(GuitarPedal_.manufacturer); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @@ -388,12 +394,12 @@ void fetch_singular_returnsNonNullPredicate() { void fetch_singular_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.fetch((SingularAttribute) null)); + () -> fetch((SingularAttribute) null)); } @Test void fetch_list_returnsNonNullPredicate() { - var specification = specificationFactory.fetch(GuitarPedal_.tags); + var specification = fetch(GuitarPedal_.tags); assertNotNull(specification); assertNotNull(specification.toPredicate(root, query, builder)); } @@ -402,12 +408,12 @@ void fetch_list_returnsNonNullPredicate() { void fetch_list_throwsException_whenAttributeIsNull() { assertThrows( NullPointerException.class, - () -> specificationFactory.fetch((ListAttribute) null)); + () -> fetch((ListAttribute) null)); } @Test void ghost_returnsNullPredicate() { - Specification specification = specificationFactory.ghost(); + Specification specification = ghost(); assertNotNull(specification); assertNull(specification.toPredicate(root, query, builder)); } diff --git a/src/test/java/io/github/quinnandrews/spring/data/specification/builder/application/data/guitarpedals/specifications/GuitarPedalSpecifications.java b/src/test/java/io/github/quinnandrews/spring/data/specification/builder/application/data/guitarpedals/specifications/GuitarPedalSpecifications.java index 63d3b6a..4b194cc 100644 --- a/src/test/java/io/github/quinnandrews/spring/data/specification/builder/application/data/guitarpedals/specifications/GuitarPedalSpecifications.java +++ b/src/test/java/io/github/quinnandrews/spring/data/specification/builder/application/data/guitarpedals/specifications/GuitarPedalSpecifications.java @@ -5,13 +5,15 @@ import jakarta.persistence.criteria.Join; import io.github.quinnandrews.spring.data.specification.annotations.Specifications; import io.github.quinnandrews.spring.data.specification.builder.SpecificationBuilder; -import io.github.quinnandrews.spring.data.specification.builder.SpecificationFactory; import io.github.quinnandrews.spring.data.specification.builder.SpecificationUtil; import io.github.quinnandrews.spring.data.specification.builder.application.data.guitarpedals.*; import org.springframework.data.jpa.domain.Specification; import java.util.Collection; +import static io.github.quinnandrews.spring.data.specification.builder.SpecificationBuilder.from; +import static io.github.quinnandrews.spring.data.specification.builder.SpecificationFactory.*; + /** *

Examples using the Builder and Factory classes, including comparisons * with examples that use Spring's Specification Class directly. The @@ -27,8 +29,6 @@ @Specifications public class GuitarPedalSpecifications { - private final SpecificationFactory specificationFactory = new SpecificationFactory(); - public GuitarPedalSpecifications() { // no-op } @@ -188,11 +188,11 @@ public Specification search_example_04(final Integer usedValueGreat } public Specification hasNotBeenSold_usingFactory() { - return specificationFactory.isNull(GuitarPedal_.dateSold); + return isNull(GuitarPedal_.dateSold); } public Specification usedValueGreaterThan_usingFactory(final Integer usedValueGreaterThan) { - return specificationFactory.greaterThan(GuitarPedal_.usedValue, usedValueGreaterThan); + return isGreaterThan(GuitarPedal_.usedValue, usedValueGreaterThan); } /* @@ -211,8 +211,8 @@ or to provide null safety, because the where() method will return a Specificatio The next example, Search Example #6, shows what I mean. */ public Specification search_example_05(final Integer usedValueGreaterThan) { - return Specification.where(specificationFactory.isNull(GuitarPedal_.dateSold)) - .and(specificationFactory.greaterThan(GuitarPedal_.usedValue, usedValueGreaterThan)); + return Specification.where(isNull(GuitarPedal_.dateSold)) + .and(isGreaterThan(GuitarPedal_.usedValue, usedValueGreaterThan)); } /* @@ -237,8 +237,8 @@ public Specification search_example_06_alt(final Integer usedValueG } */ public Specification search_example_06(final Integer usedValueGreaterThan) { - return specificationFactory.isNull(GuitarPedal_.dateSold) - .and(specificationFactory.greaterThan(GuitarPedal_.usedValue, usedValueGreaterThan)); + return isNull(GuitarPedal_.dateSold) + .and(isGreaterThan(GuitarPedal_.usedValue, usedValueGreaterThan)); } /* @@ -346,7 +346,7 @@ All we need to do is call fetch() on the SpecificationBuilder (or fetch() on the The next example, Fetch Example #2, begins looking at how to do that. */ public Specification fetch_example_01() { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .toSpecification(); } @@ -407,7 +407,7 @@ may get unexpected results (see Fetch Example #7). associated Collections of Entities. */ public Specification fetch_example_02(final String name) { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .where( (root, query, builder) -> { @@ -442,7 +442,7 @@ the where() method to filter by a property belonging to Entity of the In the next example, Fetch Example #4, we'll clean this up a bit. */ public Specification fetch_example_03(final Collection tags) { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .fetch(GuitarPedal_.tags) .where( @@ -474,7 +474,7 @@ called, which simply returns a Specification whose toPredicate() method (the lam Let's look at the next example, Fetch Example #5, and see what NOT to do. */ public Specification fetch_example_04(final Collection tags) { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .fetch(GuitarPedal_.tags) .where(tagsContain(tags)) @@ -488,7 +488,7 @@ public Specification tagsContain(final Collection tags) { return join.get(GuitarPedalTag_.tag).in(tags); }; } - return specificationFactory.ghost(); + return ghost(); } /* @@ -514,7 +514,7 @@ public Specification tagsContain(final Collection tags) { */ public Specification fetch_example_05(final Long id, final Collection tags) { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .fetch(GuitarPedal_.tags) .where( @@ -561,7 +561,7 @@ the same Join, only two joins will be rendered in the SQL query (again, one for */ public Specification fetch_example_06(final Long id, final Collection tags) { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .fetch(GuitarPedal_.tags) .where( @@ -654,7 +654,7 @@ When we use fetch() to eagerly fetch an associated Collections, most of the time @SuppressWarnings("unchecked") public Specification fetch_example_07(final Long id, final Collection tags) { - return SpecificationBuilder.from(GuitarPedal.class) + return from(GuitarPedal.class) .fetch(GuitarPedal_.manufacturer) .where( (root, query, builder) -> {