Unit test for empty restriction

Author: njr-11

api/src/test/java/jakarta/data/metamodel/restrict/RestrictTest.java

@@ -20,19 +20,69 @@
 import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.Test;
 
+import jakarta.data.metamodel.SortableAttribute;
+import jakarta.data.metamodel.TextAttribute;
+import jakarta.data.metamodel.impl.SortableAttributeRecord;
+import jakarta.data.metamodel.impl.TextAttributeRecord;
+
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 
+import java.util.List;
+
 class RestrictTest {
+    // Mock static metamodel class for tests
+    interface _Employee {
+        String BADGENUM = "badgeNum";
+        String NAME = "name";
+        String POSITION = "position";
+        String YEARHIRED = "yearHired";
+
+        SortableAttribute<Employee> badgeNum = new SortableAttributeRecord<>(BADGENUM);
+        TextAttribute<Employee> name = new TextAttributeRecord<>(NAME);
+        TextAttribute<Employee> position = new TextAttributeRecord<>(POSITION);
+        SortableAttribute<Employee> yearHired = new SortableAttributeRecord<>(YEARHIRED);
+    }
+
+    // Mock entity class for tests
+    class Employee {
+        int badgeNum;
+        String name;
+        String position;
+        int yearHired;
+    }
+
+    /**
+     * Mock repository method for tests.
+     */
+    List<Employee> findByPosition(String position,
+                                  Restriction<Employee> restriction) {
+        return List.of();
+    }
+
+    @Test
+    void shouldCreateEmptyRestriction() {
+        Restriction<Employee> unrestricted = Restrict.none();
+
+        assertThat(unrestricted).isInstanceOf(EmptyRestriction.class);
 
+        EmptyRestriction<Employee> emptyRestriction =
+                (EmptyRestriction<Employee>) unrestricted;
+
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(emptyRestriction.isNegated()).isEqualTo(false);
+            soft.assertThat(emptyRestriction.restrictions()).isEmpty();
+            soft.assertThat(emptyRestriction.type()).isEqualTo(CompositeRestriction.Type.ALL);
+        });
+    }
 
     @Test
     void shouldCreateEqualToRestriction() {
-        Restriction<String> restriction = Restrict.equalTo("value", "attributeName");
+        Restriction<Employee> restriction = Restrict.equalTo("value", "attributeName");
 
         assertThat(restriction).isInstanceOf(TextRestrictionRecord.class);
 
-        TextRestrictionRecord<String> basic = (TextRestrictionRecord<String>) restriction;
+        TextRestrictionRecord<Employee> basic = (TextRestrictionRecord<Employee>) restriction;
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(basic.attribute()).isEqualTo("attributeName");
             soft.assertThat(basic.comparison()).isEqualTo(Operator.EQUAL);
@@ -42,11 +92,11 @@ void shouldCreateEqualToRestriction() {
 
     @Test
     void shouldCreateNotEqualToRestriction() {
-        Restriction<String> restriction = Restrict.notEqualTo("value", "attributeName");
+        Restriction<Employee> restriction = Restrict.notEqualTo("value", "attributeName");
 
         assertThat(restriction).isInstanceOf(TextRestrictionRecord.class);
 
-        TextRestrictionRecord<String> basic = (TextRestrictionRecord<String>) restriction;
+        TextRestrictionRecord<Employee> basic = (TextRestrictionRecord<Employee>) restriction;
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(basic.attribute()).isEqualTo("attributeName");
             soft.assertThat(basic.comparison()).isEqualTo(Operator.NOT_EQUAL);
@@ -56,14 +106,14 @@ void shouldCreateNotEqualToRestriction() {
 
     @Test
     void shouldCombineAllRestrictionsWithNegation() {
-        Restriction<String> r1 = Restrict.notEqualTo("value1", "attributeName1");
-        Restriction<String> r2 = Restrict.greaterThan(100, "attributeName2");
+        Restriction<Employee> r1 = Restrict.notEqualTo("value1", "attributeName1");
+        Restriction<Employee> r2 = Restrict.greaterThan(100, "attributeName2");
 
-        Restriction<String> combined = Restrict.all(r1, r2);
+        Restriction<Employee> combined = Restrict.all(r1, r2);
 
         assertThat(combined).isInstanceOf(CompositeRestrictionRecord.class);
 
-        CompositeRestrictionRecord<String> composite = (CompositeRestrictionRecord<String>) combined;
+        CompositeRestrictionRecord<Employee> composite = (CompositeRestrictionRecord<Employee>) combined;
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(composite.type()).isEqualTo(CompositeRestriction.Type.ALL);
             soft.assertThat(composite.restrictions()).containsExactly(r1, r2);
@@ -73,7 +123,7 @@ void shouldCombineAllRestrictionsWithNegation() {
 
     @Test
     void shouldCreateContainsRestriction() {
-        TextRestriction<String> restriction = Restrict.contains("substring", "attributeName");
+        TextRestriction<Employee> restriction = Restrict.contains("substring", "attributeName");
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(restriction.attribute()).isEqualTo("attributeName");
@@ -84,7 +134,7 @@ void shouldCreateContainsRestriction() {
 
     @Test
     void shouldCreateNegatedContainsRestriction() {
-        TextRestriction<String> restriction = Restrict.notContains("substring", "attributeName");
+        TextRestriction<Employee> restriction = Restrict.notContains("substring", "attributeName");
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(restriction.attribute()).isEqualTo("attributeName");
@@ -95,7 +145,7 @@ void shouldCreateNegatedContainsRestriction() {
 
     @Test
     void shouldCreateStartsWithRestriction() {
-        TextRestriction<String> restriction = Restrict.startsWith("prefix", "attributeName");
+        TextRestriction<Employee> restriction = Restrict.startsWith("prefix", "attributeName");
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(restriction.attribute()).isEqualTo("attributeName");
@@ -106,7 +156,7 @@ void shouldCreateStartsWithRestriction() {
 
     @Test
     void shouldCreateNegatedStartsWithRestriction() {
-        TextRestriction<String> restriction = Restrict.notStartsWith("prefix", "attributeName");
+        TextRestriction<Employee> restriction = Restrict.notStartsWith("prefix", "attributeName");
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(restriction.attribute()).isEqualTo("attributeName");
@@ -117,7 +167,7 @@ void shouldCreateNegatedStartsWithRestriction() {
 
     @Test
     void shouldCreateEndsWithRestriction() {
-        TextRestriction<String> restriction = Restrict.endsWith("suffix", "attributeName");
+        TextRestriction<Employee> restriction = Restrict.endsWith("suffix", "attributeName");
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(restriction.attribute()).isEqualTo("attributeName");
@@ -128,7 +178,7 @@ void shouldCreateEndsWithRestriction() {
 
     @Test
     void shouldCreateNegatedEndsWithRestriction() {
-        TextRestriction<String> restriction = Restrict.notEndsWith("suffix", "attributeName");
+        TextRestriction<Employee> restriction = Restrict.notEndsWith("suffix", "attributeName");
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(restriction.attribute()).isEqualTo("attributeName");
@@ -144,10 +194,23 @@ void shouldEscapeToLikePatternCorrectly() {
         assertThat(result).isEqualTo("%test\\_value");
     }
 
+    @Test
+    void shouldSupplyEmptyRestrictionToRepositoryMethod() {
+        this.findByPosition("Software Engineer", Restrict.none());
+    }
+
     @Test
     void shouldThrowExceptionForInvalidWildcard() {
         assertThatThrownBy(() -> Restrict.like("pattern_value", '_', '_', "attributeName"))
                 .isInstanceOf(IllegalArgumentException.class)
                 .hasMessage("Cannot use the same character (_) for both types of wildcards.");
     }
+
+    @Test
+    void shouldThrowExceptionForNegatingEmptyRestriction() {
+        Restriction<Employee> unrestricted = Restrict.none();
+        assertThatThrownBy(() -> unrestricted.negate())
+                .isInstanceOf(UnsupportedOperationException.class)
+                .hasMessage("Empty restriction cannot be negated.");
+    }
 }