Skip to content

Commit 780e69f

Browse files
rmcdougarmcdouga
committed
✅ Created RestClientTest to test default methods
The test coverage minimum made me do this, but it was the right thing to do for future me (or someone else who has to maintain the RestClient class).
1 parent 4edf465 commit 780e69f

1 file changed

Lines changed: 238 additions & 0 deletions

File tree

  • rest-services/client/src/test/java/com/_4point/aem/docservices/rest_services/client

‎rest-services/client/src/test/java/com/_4point/aem/docservices/rest_services/client/RestClientTest.java‎

Lines changed: 238 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,238 @@
1+
package com._4point.aem.docservices.rest_services.client;
2+
3+
import static org.junit.jupiter.api.Assertions.*;
4+
5+
import java.io.ByteArrayInputStream;
6+
import java.io.IOException;
7+
import java.io.InputStream;
8+
import java.io.UncheckedIOException;
9+
import java.util.ArrayList;
10+
import java.util.List;
11+
12+
import org.junit.jupiter.api.Test;
13+
import org.junit.jupiter.params.ParameterizedTest;
14+
import org.junit.jupiter.params.provider.EnumSource;
15+
16+
import com._4point.aem.docservices.rest_services.client.RestClient.ContentType;
17+
import com._4point.aem.docservices.rest_services.client.RestClient.MultipartPayload;
18+
import com._4point.aem.docservices.rest_services.client.RestClient.MultipartPayload.Builder;
19+
import com._4point.aem.fluentforms.api.Document;
20+
import com._4point.aem.fluentforms.api.DocumentFactory;
21+
import com._4point.aem.fluentforms.impl.SimpleDocumentFactoryImpl;
22+
23+
class RestClientTest {
24+
25+
26+
private static final DocumentFactory DOC_FACTORY = SimpleDocumentFactoryImpl.getFactory();
27+
28+
/**
29+
* This class is used to test all the Builder interface's default methods.
30+
*/
31+
private static class MockBuilder implements Builder {
32+
record AddStringStringParams(String fieldName, String fieldData) {};
33+
record AddStringByteArrrayContentTypeParams(String fieldName, byte[] fieldData, ContentType contentType) {};
34+
record AddStringInputStreamContentTypeParams(String fieldName, InputStream fieldData, ContentType contentType) {};
35+
36+
private List<AddStringStringParams> addStringStringParams = new ArrayList<>();
37+
private List<AddStringByteArrrayContentTypeParams> addStringByteArrrayContentTypeParams = new ArrayList<>();
38+
private List<AddStringInputStreamContentTypeParams> addStringInputStreamContentTypeParams = new ArrayList<>();
39+
40+
@Override
41+
public Builder add(String fieldName, String fieldData) {
42+
addStringStringParams.add(new AddStringStringParams(fieldName, fieldData));
43+
return this;
44+
}
45+
46+
@Override
47+
public Builder add(String fieldName, byte[] fieldData, ContentType contentType) {
48+
addStringByteArrrayContentTypeParams.add(new AddStringByteArrrayContentTypeParams(fieldName, fieldData, contentType));
49+
return this;
50+
}
51+
52+
@Override
53+
public Builder add(String fieldName, InputStream fieldData, ContentType contentType) {
54+
addStringInputStreamContentTypeParams.add(new AddStringInputStreamContentTypeParams(fieldName, fieldData, contentType));
55+
return this;
56+
}
57+
58+
@Override
59+
public Builder queryParam(String name, String value) {
60+
throw new UnsupportedOperationException("Not implemented");
61+
}
62+
63+
@Override
64+
public Builder addHeader(String name, String value) {
65+
throw new UnsupportedOperationException("Not implemented");
66+
}
67+
68+
@Override
69+
public MultipartPayload build() {
70+
throw new UnsupportedOperationException("Not implemented");
71+
}
72+
};
73+
74+
private final MockBuilder underTest = new MockBuilder();
75+
76+
enum InputStreamTest {
77+
NonNullInputStream,
78+
NonNullDocWithoutContentType,
79+
NonNullDocWithContentType,
80+
DocWithoutContentType,
81+
DocWithContentType;
82+
}
83+
84+
@ParameterizedTest
85+
@EnumSource
86+
void testAddInputStreamVariations(InputStreamTest testType) {
87+
// given
88+
String fieldName = "fieldName";
89+
byte[] fieldData = "fieldData".getBytes();
90+
String contentType = "application/pdf";
91+
Document doc = DOC_FACTORY.create(fieldData);
92+
93+
94+
// when
95+
switch (testType) {
96+
case NonNullInputStream -> underTest.addIfNotNull(fieldName, new ByteArrayInputStream(fieldData), ContentType.APPLICATION_PDF);
97+
case NonNullDocWithoutContentType -> { doc.setContentType(contentType); underTest.addIfNotNull(fieldName, doc); } // Set the content type of the document
98+
case NonNullDocWithContentType -> underTest.addIfNotNull(fieldName, doc, ContentType.APPLICATION_PDF);
99+
case DocWithoutContentType -> { doc.setContentType(contentType); underTest.add(fieldName, doc); } // Set the content type of the document
100+
case DocWithContentType -> underTest.add(fieldName, doc, ContentType.APPLICATION_PDF); // Explicitly pass in the content type
101+
}
102+
103+
// then
104+
assertEquals(1, underTest.addStringInputStreamContentTypeParams.size());
105+
MockBuilder.AddStringInputStreamContentTypeParams params = underTest.addStringInputStreamContentTypeParams.get(0);
106+
assertAll(
107+
()->assertEquals(fieldName, params.fieldName()),
108+
()->assertArrayEquals(fieldData, readInputStream(params.fieldData())),
109+
()->assertEquals(contentType, params.contentType().contentType())
110+
);
111+
}
112+
113+
114+
enum CollectionTest {
115+
List, Stream, NonNullList;
116+
}
117+
118+
@ParameterizedTest
119+
@EnumSource
120+
void testAddStringCollections(CollectionTest testType) {
121+
// given
122+
String fieldName = "fieldName";
123+
List<String> fieldData = List.of("fieldData1", "fieldData2");
124+
125+
// when
126+
switch (testType) {
127+
case List -> underTest.addStrings(fieldName, fieldData);
128+
case Stream -> underTest.addStrings(fieldName, fieldData.stream());
129+
case NonNullList -> underTest.addStringVersion(fieldName, fieldData);
130+
}
131+
132+
// then
133+
assertEquals(fieldData.size(), underTest.addStringStringParams.size());
134+
135+
for (int i = 0; i < fieldData.size(); i++) {
136+
int index = i; // Need to use final variable in lambda
137+
MockBuilder.AddStringStringParams params = underTest.addStringStringParams.get(index);
138+
assertAll(
139+
() -> assertEquals(fieldName, params.fieldName()),
140+
() -> assertEquals(fieldData.get(index), params.fieldData())
141+
);
142+
}
143+
}
144+
145+
@ParameterizedTest
146+
@EnumSource
147+
void testAddDocsCollections(CollectionTest testType) {
148+
// given
149+
String fieldName = "fieldName";
150+
String contentType = "application/pdf";
151+
List<byte[]> rawFieldData = List.of("fieldData1".getBytes(), "fieldData2".getBytes());
152+
List<Document> fieldData = rawFieldData.stream()
153+
.map(ba->DOC_FACTORY.create(ba))
154+
.map(doc -> doc.setContentType(contentType))
155+
.toList();
156+
157+
// when
158+
switch (testType) {
159+
case List -> underTest.addDocs(fieldName, fieldData); // Test the List version
160+
case Stream -> underTest.addDocs(fieldName, fieldData.stream()); // Test the Stream version
161+
case NonNullList -> underTest.addDocsIfNotNull(fieldName, fieldData);
162+
}
163+
164+
// then
165+
assertEquals(fieldData.size(), underTest.addStringInputStreamContentTypeParams.size());
166+
167+
for (int i = 0; i < fieldData.size(); i++) {
168+
int index = i; // Need to use final variable in lambda
169+
MockBuilder.AddStringInputStreamContentTypeParams params = underTest.addStringInputStreamContentTypeParams.get(index);
170+
assertAll(
171+
()->assertEquals(fieldName, params.fieldName()),
172+
()->assertArrayEquals(rawFieldData.get(index), readInputStream(params.fieldData())),
173+
()->assertEquals(contentType, params.contentType().contentType())
174+
);
175+
}
176+
}
177+
178+
@Test
179+
void testAddByteArrayVariarions() {
180+
// given
181+
String fieldName = "fieldName";
182+
byte[] fieldData = "fieldData1".getBytes();
183+
184+
// when
185+
underTest.addIfNotNull(fieldName, fieldData, ContentType.APPLICATION_PDF);
186+
187+
// then
188+
assertEquals(1, underTest.addStringByteArrrayContentTypeParams.size());
189+
MockBuilder.AddStringByteArrrayContentTypeParams params = underTest.addStringByteArrrayContentTypeParams.get(0);
190+
assertAll(
191+
() -> assertEquals(fieldName, params.fieldName()),
192+
() -> assertArrayEquals(fieldData, params.fieldData()),
193+
() -> assertEquals(ContentType.APPLICATION_PDF, params.contentType())
194+
);
195+
}
196+
197+
@Test
198+
void testAddIfNotNull_Null() {
199+
// Test all the addifNotNull cases when null is used.
200+
// Given
201+
String fieldName = "fieldName";
202+
203+
// When
204+
underTest.addIfNotNull(fieldName, (String) null);
205+
underTest.addIfNotNull(fieldName, (byte[]) null, ContentType.APPLICATION_PDF);
206+
underTest.addIfNotNull(fieldName, (InputStream) null, ContentType.APPLICATION_PDF);
207+
underTest.addIfNotNull(fieldName, (Document) null);
208+
underTest.addIfNotNull(fieldName, (Document) null, ContentType.APPLICATION_PDF);
209+
underTest.addDocsIfNotNull(fieldName, (List<Document>) null);
210+
underTest.addStringVersion(fieldName, (String) null);
211+
underTest.addStringVersion(fieldName, (List<Document>) null);
212+
underTest.transformAndAdd(fieldName, (String) null, s -> s); // Initial Value is null
213+
underTest.transformAndAdd(fieldName, "", s -> null); // Value after transformation is null
214+
underTest.transformAndAddBytes(fieldName, (String) null, ContentType.APPLICATION_PDF, s -> s.getBytes()); // Initial Value is null
215+
underTest.transformAndAddBytes(fieldName, "".getBytes(), ContentType.APPLICATION_PDF, s -> null); // Value after transformation is null
216+
underTest.transformAndAddInputStream(fieldName, (String) null, ContentType.APPLICATION_PDF, s -> new ByteArrayInputStream(s.getBytes())); // Initial Value is null
217+
underTest.transformAndAddInputStream(fieldName, new ByteArrayInputStream("".getBytes()), ContentType.APPLICATION_PDF, s -> null); // Value after transformation is null
218+
underTest.transformAndAddStringVersion(fieldName, (String) null, s -> s); // Initial Value is null
219+
underTest.transformAndAddStringVersion(fieldName, "", s -> null); // Value after transformation is null
220+
underTest.transformAndAddDocs(fieldName, (String) null, s -> { throw new IllegalArgumentException("Shouldn't reach here"); }); // Initial Value is null
221+
underTest.transformAndAddDocs(fieldName, "", s -> null); // Value after transformation is null
222+
223+
assertAll(
224+
()->assertTrue(underTest.addStringInputStreamContentTypeParams.isEmpty(), "InputStream was added when null was passed in."),
225+
()->assertTrue(underTest.addStringStringParams.isEmpty(), "String was added when null was passed in."),
226+
()->assertTrue(underTest.addStringByteArrrayContentTypeParams.isEmpty(), "byte[] was added when null was passed in.")
227+
);
228+
229+
}
230+
231+
private byte[] readInputStream(InputStream is) {
232+
try {
233+
return is.readAllBytes();
234+
} catch (IOException e) {
235+
throw new UncheckedIOException(e);
236+
}
237+
}
238+
}

0 commit comments

Comments
 (0)