Skip to content

Commit 228ea05

Browse files
hamza-shahzaddhamza-shahzadd
committed
test(pagination): updated offset and paged pagination test
1 parent 9ea0e4f commit 228ea05

2 files changed

Lines changed: 128 additions & 173 deletions

File tree

‎src/test/java/apimatic/core/type/pagination/OffsetPaginationTest.java‎

Lines changed: 82 additions & 119 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,12 @@
11
package apimatic.core.type.pagination;
22

33
import static org.junit.Assert.assertEquals;
4-
import static org.junit.Assert.assertFalse;
54
import static org.junit.Assert.assertNotNull;
6-
import static org.junit.Assert.assertTrue;
7-
import static org.junit.Assert.fail;
5+
import static org.junit.Assert.assertNull;
86
import static org.mockito.Mockito.mock;
97
import static org.mockito.Mockito.when;
108

119
import java.util.HashMap;
12-
import java.util.Map;
13-
import java.util.concurrent.atomic.AtomicBoolean;
1410

1511
import org.junit.Rule;
1612
import org.junit.Test;
@@ -21,6 +17,7 @@
2117
import io.apimatic.core.HttpRequest.Builder;
2218
import io.apimatic.core.types.pagination.OffsetPagination;
2319
import io.apimatic.core.types.pagination.PaginatedData;
20+
import io.apimatic.coreinterfaces.http.response.Response;
2421

2522
/**
2623
* Unit tests for {@link OffsetPagination}.
@@ -41,199 +38,165 @@ public class OffsetPaginationTest {
4138

4239
@Test
4340
public void testValidOffsetHeaderReturnsTrue() {
44-
// Setup mocks
4541
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
46-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
47-
.headerParam(h -> h.key("offset").value(INITIAL_OFFSET));
42+
Response response = mock(Response.class);
4843

49-
// Mock behaviors
50-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
44+
when(paginatedData.getRequestBuilder())
45+
.thenReturn(new HttpRequest.Builder().headerParam(
46+
h -> h.key("offset").value(INITIAL_OFFSET)));
47+
when(paginatedData.getResponse()).thenReturn(response);
48+
when(response.getBody()).thenReturn("{\"offset\": " + INITIAL_OFFSET + "}");
5149
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
5250

53-
// Test the offset pagination
5451
OffsetPagination offset = new OffsetPagination("$request.headers#/offset");
55-
Builder nextRequestBuilder = offset.apply(paginatedData);
56-
57-
// Verify results
58-
assertNotNull(nextRequestBuilder);
59-
nextRequestBuilder.updateByReference("$request.headers#/offset", v -> {
52+
53+
Builder requestBuilder = offset.apply(paginatedData);
54+
assertNotNull(requestBuilder);
55+
56+
requestBuilder.updateByReference("$request.headers#/offset", v -> {
6057
assertEquals(OFFSET_PLUS_PAGE, v);
6158
return v;
6259
});
6360
}
6461

6562
@Test
6663
public void testValidOffsetTemplateReturnsTrue() {
67-
// Setup mocks
6864
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
69-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
70-
.templateParam(t -> t.key("offset").value(INITIAL_OFFSET));
65+
Response response = mock(Response.class);
7166

72-
// Mock behaviors
73-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
67+
when(paginatedData.getRequestBuilder())
68+
.thenReturn(new HttpRequest.Builder().templateParam(
69+
t -> t.key("offset").value(INITIAL_OFFSET)));
70+
when(paginatedData.getResponse()).thenReturn(response);
71+
when(response.getBody()).thenReturn("{\"offset\": " + INITIAL_OFFSET + "}");
7472
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
7573

76-
// Test the offset pagination
7774
OffsetPagination offset = new OffsetPagination("$request.path#/offset");
78-
Builder nextRequestBuilder = offset.apply(paginatedData);
79-
80-
// Verify results
81-
assertNotNull(nextRequestBuilder);
82-
nextRequestBuilder.updateByReference("$request.path#/offset", v -> {
75+
76+
Builder requestBuilder = offset.apply(paginatedData);
77+
assertNotNull(requestBuilder);
78+
79+
requestBuilder.updateByReference("$request.path#/offset", v -> {
8380
assertEquals(OFFSET_PLUS_PAGE, v);
8481
return v;
8582
});
8683
}
8784

8885
@Test
8986
public void testValidOffsetReturnsTrue() {
90-
// Setup mocks
9187
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
92-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
93-
.queryParam(q -> q.key("offset").value(INITIAL_OFFSET));
88+
Response response = mock(Response.class);
9489

95-
// Mock behaviors
96-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
90+
when(paginatedData.getRequestBuilder())
91+
.thenReturn(new HttpRequest.Builder().queryParam(
92+
q -> q.key("offset").value(INITIAL_OFFSET)));
93+
when(paginatedData.getResponse()).thenReturn(response);
94+
when(response.getBody()).thenReturn("{\"offset\": " + INITIAL_OFFSET + "}");
9795
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
9896

99-
// Test the offset pagination
10097
OffsetPagination offset = new OffsetPagination("$request.query#/offset");
101-
Builder nextRequestBuilder = offset.apply(paginatedData);
102-
103-
// Verify results
104-
assertNotNull(nextRequestBuilder);
105-
nextRequestBuilder.updateByReference("$request.query#/offset", v -> {
98+
99+
Builder requestBuilder = offset.apply(paginatedData);
100+
assertNotNull(requestBuilder);
101+
102+
requestBuilder.updateByReference("$request.query#/offset", v -> {
106103
assertEquals(OFFSET_PLUS_PAGE, v);
107104
return v;
108105
});
109106
}
110107

111108
@Test
112109
public void testValidOffsetAsInnerFieldReturnsTrue() {
113-
// Setup mocks
114110
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
115-
Map<String, String> offsetMap = new HashMap<String, String>() {{
116-
put("val", "1");
117-
}};
118-
119-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
120-
.queryParam(q -> q.key("offset").value(offsetMap));
121-
122-
// Mock behaviors
123-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
111+
Response response = mock(Response.class);
112+
113+
when(paginatedData.getRequestBuilder()).thenReturn(
114+
new HttpRequest.Builder().queryParam(q -> q.key("offset").value(
115+
new HashMap<String, String>() {
116+
private static final long serialVersionUID = 1L;
117+
{
118+
put("val", "1");
119+
}
120+
})));
121+
when(paginatedData.getResponse()).thenReturn(response);
122+
when(response.getBody()).thenReturn("{\"offset\": {\"val\": 1}}");
124123
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
125124

126-
// Test the offset pagination with nested field
127125
OffsetPagination offset = new OffsetPagination("$request.query#/offset/val");
128-
Builder nextRequestBuilder = offset.apply(paginatedData);
129-
130-
// Verify results
131-
assertNotNull(nextRequestBuilder);
132-
nextRequestBuilder.updateByReference("$request.query#/offset/val", v -> {
126+
127+
Builder requestBuilder = offset.apply(paginatedData);
128+
assertNotNull(requestBuilder);
129+
130+
requestBuilder.updateByReference("$request.query#/offset/val", v -> {
133131
assertEquals(OFFSET_VAL_PLUS_ONE, v);
134132
return v;
135133
});
136134
}
137135

138136
@Test
139137
public void testValidStringOffsetReturnsTrue() {
140-
// Setup mocks
141138
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
142-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
143-
.queryParam(q -> q.key("offset").value("5"));
139+
Response response = mock(Response.class);
144140

145-
// Mock behaviors
146-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
141+
when(paginatedData.getRequestBuilder())
142+
.thenReturn(new HttpRequest.Builder().queryParam(
143+
q -> q.key("offset").value("5")));
144+
when(paginatedData.getResponse()).thenReturn(response);
145+
when(response.getBody()).thenReturn("{\"offset\": \"5\"}");
147146
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
148147

149-
// Test the offset pagination with string value
150148
OffsetPagination offset = new OffsetPagination("$request.query#/offset");
151-
Builder nextRequestBuilder = offset.apply(paginatedData);
152-
153-
// Verify results
154-
assertNotNull(nextRequestBuilder);
155-
nextRequestBuilder.updateByReference("$request.query#/offset", v -> {
149+
150+
Builder requestBuilder = offset.apply(paginatedData);
151+
assertNotNull(requestBuilder);
152+
153+
requestBuilder.updateByReference("$request.query#/offset", v -> {
156154
assertEquals(OFFSET_STRING_PLUS_PAGE, v);
157155
return v;
158156
});
159157
}
158+
159+
160160
@Test
161161
public void testInvalidStringOffsetReturnsFalse() {
162-
// Setup mocks
163162
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
164-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
165-
.queryParam(q -> q.key("offset").value("5a"));
166163

167-
// Mock behaviors
168-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
164+
when(paginatedData.getRequestBuilder())
165+
.thenReturn(new HttpRequest.Builder().queryParam(
166+
q -> q.key("offset").value("5a")));
169167
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
170168

171-
// Test the offset pagination with invalid string value
172169
OffsetPagination offset = new OffsetPagination("$request.query#/offset");
173-
174-
// Verify the offset remains unchanged for invalid values
175-
Builder nextRequestBuilder = offset.apply(paginatedData);
176-
assertNotNull(nextRequestBuilder);
177-
178-
nextRequestBuilder.updateByReference("$request.query#/offset", v -> {
179-
assertEquals("5a", v); // Value should remain unchanged
180-
return v;
181-
});
170+
171+
Builder requestBuilder = offset.apply(paginatedData);
172+
assertNull(requestBuilder);
182173
}
183174

184175
@Test
185176
public void testMissingOffsetReturnsFalse() {
186-
// Setup mocks
187177
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
188-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder(); // No offset param
189178

190-
// Mock behaviors
191-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
179+
when(paginatedData.getRequestBuilder()).thenReturn(new HttpRequest.Builder());
192180
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
193181

194-
// Test the offset pagination with missing offset
195182
OffsetPagination offset = new OffsetPagination("$request.query#/offset");
196-
197-
// Execute and verify
198-
Builder nextRequestBuilder = offset.apply(paginatedData);
199-
assertNotNull("Builder should still be returned even with missing offset", nextRequestBuilder);
200-
201-
// Verify no update is attempted for missing offset
202-
AtomicBoolean callbackInvoked = new AtomicBoolean(false);
203-
nextRequestBuilder.updateByReference("$request.query#/offset", v -> {
204-
callbackInvoked.set(true);
205-
return v;
206-
});
207-
208-
assertFalse("Callback should not be invoked for missing offset", callbackInvoked.get());
183+
184+
Builder requestBuilder = offset.apply(paginatedData);
185+
assertNull(requestBuilder);
209186
}
210187

211188
@Test
212189
public void testNullOffsetReturnsFalse() {
213-
// Setup mocks
214190
PaginatedData<?, ?, ?, ?> paginatedData = mock(PaginatedData.class);
215-
HttpRequest.Builder requestBuilder = new HttpRequest.Builder()
216-
.queryParam(q -> q.key("offset").value(NUMERIC_OFFSET));
217191

218-
// Mock behaviors
219-
when(paginatedData.getRequestBuilder()).thenReturn(requestBuilder);
192+
when(paginatedData.getRequestBuilder())
193+
.thenReturn(new HttpRequest.Builder().queryParam(
194+
q -> q.key("offset").value(NUMERIC_OFFSET)));
220195
when(paginatedData.getPageSize()).thenReturn(PAGE_SIZE);
221196

222-
// Test with null offset configuration
223197
OffsetPagination offset = new OffsetPagination(null);
224-
225-
// Execute and verify
226-
Builder nextRequestBuilder = offset.apply(paginatedData);
227-
assertNotNull("Builder should still be returned even with null offset config", nextRequestBuilder);
228-
229-
// Verify original offset remains unchanged
230-
AtomicBoolean callbackInvoked = new AtomicBoolean(false);
231-
nextRequestBuilder.updateByReference("$request.query#/offset", v -> {
232-
callbackInvoked.set(true);
233-
assertEquals("Original offset should remain unchanged", NUMERIC_OFFSET, v);
234-
return v;
235-
});
236-
237-
assertTrue("Should still process existing offset values", callbackInvoked.get());
198+
199+
Builder requestBuilder = offset.apply(paginatedData);
200+
assertNull(requestBuilder);
238201
}
239-
}
202+
}

0 commit comments

Comments
 (0)