Skip to content

Commit 32b1b51

Browse files
cen1cen1
committed
add tests for new method and empty fields
1 parent 1cf2e78 commit 32b1b51

2 files changed

Lines changed: 257 additions & 0 deletions

File tree

‎core/src/test/java/com/kumuluz/ee/rest/test/QueryParametersTest.java‎

Lines changed: 193 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,193 @@
1+
package com.kumuluz.ee.rest.test;
2+
3+
import com.kumuluz.ee.rest.beans.QueryFilter;
4+
import com.kumuluz.ee.rest.beans.QueryFilterExpression;
5+
import com.kumuluz.ee.rest.beans.QueryParameters;
6+
import com.kumuluz.ee.rest.enums.FilterExpressionOperation;
7+
import com.kumuluz.ee.rest.enums.FilterOperation;
8+
import org.junit.Assert;
9+
import org.junit.Test;
10+
11+
import java.util.List;
12+
13+
/**
14+
* Tests for QueryParameters methods.
15+
*
16+
* @author cen1
17+
*/
18+
public class QueryParametersTest {
19+
20+
@Test
21+
public void testRemoveFilterParameterSingleFilter() {
22+
// Create query with a single filter
23+
QueryParameters query = new QueryParameters();
24+
query.addFilter(new QueryFilter("username", FilterOperation.EQ, "test"));
25+
26+
Assert.assertEquals(1, query.getFilters().size());
27+
28+
// Remove the filter
29+
query.removeFilterParameter("username");
30+
31+
// Verify filter is removed
32+
Assert.assertEquals(0, query.getFilters().size());
33+
}
34+
35+
@Test
36+
public void testRemoveFilterParameterMultipleFilters() {
37+
// Create query with multiple filters on different fields
38+
QueryParameters query = new QueryParameters();
39+
query.addFilter(new QueryFilter("username", FilterOperation.EQ, "test"));
40+
query.addFilter(new QueryFilter("email", FilterOperation.LIKE, "test@example.com"));
41+
query.addFilter(new QueryFilter("age", FilterOperation.GT, "18"));
42+
43+
Assert.assertEquals(3, query.getFilters().size());
44+
45+
// Remove one filter
46+
query.removeFilterParameter("username");
47+
48+
// Verify only the specified filter is removed
49+
Assert.assertEquals(2, query.getFilters().size());
50+
List<QueryFilter> remainingFilters = query.getFilters();
51+
Assert.assertTrue(remainingFilters.stream().noneMatch(f -> "username".equals(f.getField())));
52+
Assert.assertTrue(remainingFilters.stream().anyMatch(f -> "email".equals(f.getField())));
53+
Assert.assertTrue(remainingFilters.stream().anyMatch(f -> "age".equals(f.getField())));
54+
}
55+
56+
@Test
57+
public void testRemoveFilterParameterMultipleSameField() {
58+
// Create query with multiple filters on the same field using deprecated API
59+
QueryParameters query = new QueryParameters();
60+
query.addFilter(new QueryFilter("status", FilterOperation.EQ, "active"));
61+
query.addFilter(new QueryFilter("status", FilterOperation.EQ, "pending"));
62+
63+
Assert.assertEquals(2, query.getFilters().size());
64+
65+
// Remove all filters for this field
66+
query.removeFilterParameter("status");
67+
68+
// Verify all filters for the field are removed
69+
Assert.assertEquals(0, query.getFilters().size());
70+
}
71+
72+
@Test
73+
public void testRemoveFilterParameterNonExistentField() {
74+
// Create query with a filter using deprecated API
75+
QueryParameters query = new QueryParameters();
76+
query.addFilter(new QueryFilter("username", FilterOperation.EQ, "test"));
77+
78+
Assert.assertEquals(1, query.getFilters().size());
79+
80+
// Try to remove a non-existent filter
81+
query.removeFilterParameter("nonexistent");
82+
83+
// Verify original filter remains
84+
Assert.assertEquals(1, query.getFilters().size());
85+
Assert.assertEquals("username", query.getFilters().get(0).getField());
86+
}
87+
88+
@Test
89+
public void testRemoveFilterParameterNullField() {
90+
// Create query with a filter using deprecated API
91+
QueryParameters query = new QueryParameters();
92+
query.addFilter(new QueryFilter("username", FilterOperation.EQ, "test"));
93+
94+
Assert.assertEquals(1, query.getFilters().size());
95+
96+
// Try to remove with null field (should not throw exception)
97+
query.removeFilterParameter(null);
98+
99+
// Verify original filter remains
100+
Assert.assertEquals(1, query.getFilters().size());
101+
}
102+
103+
@Test
104+
public void testRemoveFilterParameterEmptyFilters() {
105+
// Create query with no filters
106+
QueryParameters query = new QueryParameters();
107+
108+
// Try to remove a filter (should not throw exception)
109+
query.removeFilterParameter("username");
110+
111+
// Verify still no filters
112+
Assert.assertEquals(0, query.getFilterValues().size());
113+
}
114+
115+
@Test
116+
public void testGetFilterValuesWithFilters() {
117+
// Create query with multiple filters using AND
118+
QueryParameters query = QueryParameters
119+
.query("filter=username:eq:test AND email:like:test@example.com")
120+
.build();
121+
122+
List<QueryFilter> filters = query.getFilterValues();
123+
124+
Assert.assertNotNull(filters);
125+
Assert.assertEquals(2, filters.size());
126+
Assert.assertTrue(filters.stream().anyMatch(f -> "username".equals(f.getField())));
127+
Assert.assertTrue(filters.stream().anyMatch(f -> "email".equals(f.getField())));
128+
}
129+
130+
@Test
131+
public void testGetFilterValuesEmptyExpression() {
132+
// Create empty query
133+
QueryParameters query = new QueryParameters();
134+
135+
List<QueryFilter> filters = query.getFilterValues();
136+
137+
// Should return empty list, not null
138+
Assert.assertNotNull(filters);
139+
Assert.assertEquals(0, filters.size());
140+
}
141+
142+
@Test
143+
public void testGetFilterValuesNullExpression() {
144+
// Create query and explicitly set null expression
145+
QueryParameters query = new QueryParameters();
146+
query.setFilterExpression(null);
147+
148+
List<QueryFilter> filters = query.getFilterValues();
149+
150+
// Should return empty list, not null
151+
Assert.assertNotNull(filters);
152+
Assert.assertEquals(0, filters.size());
153+
}
154+
155+
@Test
156+
public void testGetFilterValuesComplexExpression() {
157+
// Create query with complex expression (AND/OR)
158+
QueryParameters query = QueryParameters
159+
.query("filter=(username:eq:test AND email:like:test@) OR age:gt:18")
160+
.build();
161+
162+
List<QueryFilter> filters = query.getFilterValues();
163+
164+
Assert.assertNotNull(filters);
165+
Assert.assertEquals(3, filters.size());
166+
Assert.assertTrue(filters.stream().anyMatch(f -> "username".equals(f.getField())));
167+
Assert.assertTrue(filters.stream().anyMatch(f -> "email".equals(f.getField())));
168+
Assert.assertTrue(filters.stream().anyMatch(f -> "age".equals(f.getField())));
169+
}
170+
171+
@Test
172+
public void testGetFilterValuesAfterRemove() {
173+
// Create query with filters using deprecated API
174+
QueryParameters query = new QueryParameters();
175+
QueryFilter filter1 = new QueryFilter("username", FilterOperation.EQ, "test");
176+
QueryFilter filter2 = new QueryFilter("email", FilterOperation.LIKE, "test@example.com");
177+
178+
query.addFilter(filter1);
179+
query.addFilter(filter2);
180+
181+
Assert.assertEquals(2, query.getFilters().size());
182+
183+
// Remove a filter
184+
query.removeFilterParameter("username");
185+
186+
// Get filters again
187+
List<QueryFilter> filters = query.getFilters();
188+
189+
Assert.assertNotNull(filters);
190+
Assert.assertEquals(1, filters.size());
191+
Assert.assertEquals("email", filters.get(0).getField());
192+
}
193+
}

‎core/src/test/java/com/kumuluz/ee/rest/test/QueryStringBuilderFiltersTest.java‎

Lines changed: 64 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
package com.kumuluz.ee.rest.test;
22

3+
import com.kumuluz.ee.rest.beans.QueryFilter;
34
import com.kumuluz.ee.rest.beans.QueryParameters;
45
import com.kumuluz.ee.rest.enums.FilterExpressionOperation;
56
import com.kumuluz.ee.rest.enums.FilterOperation;
@@ -10,6 +11,7 @@
1011

1112
import java.time.ZonedDateTime;
1213
import java.util.Date;
14+
import java.util.List;
1315

1416
/**
1517
* @author Tilen Faganel
@@ -639,4 +641,66 @@ public void testDisabledFilters() {
639641
Assert.assertNotNull(query);
640642
Assert.assertNull(query.getFilterExpression());
641643
}
644+
645+
@Test
646+
public void testEmptyFilterValueSkipped() {
647+
// Test that filters with empty values are skipped
648+
QueryParameters query = QueryParameters.query("filter=").build();
649+
650+
Assert.assertNotNull(query);
651+
Assert.assertNull(query.getFilterExpression());
652+
}
653+
654+
@Test
655+
public void testFilterWithOnlyOperatorSkipped() {
656+
// Test that filters ending with operator and no value are skipped (e.g., "field:like:")
657+
QueryParameters query = QueryParameters.query("filter=username:like:").build();
658+
659+
Assert.assertNotNull(query);
660+
Assert.assertNull(query.getFilterExpression());
661+
}
662+
663+
@Test
664+
public void testMultipleFiltersWithEmptyValuesMixed() {
665+
// Test that filters with empty values embedded in AND expression are handled properly
666+
// While a complete empty filter is skipped, this tests the valid use case
667+
QueryParameters query = QueryParameters
668+
.query("filter=username:eq:test AND age:gt:18")
669+
.build();
670+
671+
Assert.assertNotNull(query);
672+
Assert.assertNotNull(query.getFilterExpression());
673+
674+
// Both valid filters should be present
675+
List<QueryFilter> filters = query.getFilterValues();
676+
Assert.assertEquals(2, filters.size());
677+
Assert.assertTrue(filters.stream().anyMatch(f -> "username".equals(f.getField())));
678+
Assert.assertTrue(filters.stream().anyMatch(f -> "age".equals(f.getField())));
679+
}
680+
681+
@Test
682+
public void testFilterWithValidValueNotSkipped() {
683+
// Test that filters with valid values are not skipped
684+
QueryParameters query = QueryParameters.query("filter=username:like:test%").build();
685+
686+
Assert.assertNotNull(query);
687+
Assert.assertNotNull(query.getFilterExpression());
688+
Assert.assertEquals(1, query.getFilterExpression().getAllValues().size());
689+
Assert.assertEquals("username", query.getFilterExpression().value().getField());
690+
Assert.assertEquals(FilterOperation.LIKE, query.getFilterExpression().value().getOperation());
691+
Assert.assertEquals("test%", query.getFilterExpression().value().getValue());
692+
}
693+
694+
@Test
695+
public void testFilterWithZeroValueNotSkipped() {
696+
// Test that filters with "0" value are not skipped (0 is a valid value)
697+
QueryParameters query = QueryParameters.query("filter=count:eq:0").build();
698+
699+
Assert.assertNotNull(query);
700+
Assert.assertNotNull(query.getFilterExpression());
701+
Assert.assertEquals(1, query.getFilterExpression().getAllValues().size());
702+
Assert.assertEquals("count", query.getFilterExpression().value().getField());
703+
Assert.assertEquals(FilterOperation.EQ, query.getFilterExpression().value().getOperation());
704+
Assert.assertEquals("0", query.getFilterExpression().value().getValue());
705+
}
642706
}

0 commit comments

Comments
 (0)