1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
package org.onap.vid.testUtils;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.ImmutableList;
import org.json.JSONArray;
import org.json.JSONObject;
import org.junit.Assert;
import org.mockito.MockSettings;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.onap.vid.asdc.beans.Service;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.Response;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import static fj.parser.Parser.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;
/**
* Created by Oren on 6/7/17.
*/
public class TestUtils {
/**
* The method compares between two jsons. the function assert that the actual object does not reduce or change the functionallity/parsing of the expected json.
* This means that if the expected JSON has a key which is null or the JSON doesn't have a key which contained in the expected JSON the assert will succeed and the will pass.
* For example : For JSON expected = {a:null} and actual {a:3} the test will pass
* Other example : For JSON expected = {a:3} and actual {a:null} the test will fail
*
* @param expected JSON
* @param actual JSON
*/
public static void assertJsonStringEqualsIgnoreNulls(String expected, String actual) {
if (expected == null || expected == JSONObject.NULL) {return;}
JSONObject expectedJSON = new JSONObject(expected);
JSONObject actualJSON = new JSONObject(actual);
Iterator<?> keys = expectedJSON.keys();
while( keys.hasNext() ) {
String key = (String)keys.next();
Object expectedValue = expectedJSON.get(key);
if (expectedValue == JSONObject.NULL){
continue;
}
Object actualValue = actualJSON.get(key);
if (expectedValue instanceof JSONObject) {
String expectedVal = expectedValue.toString();
String actualVal = actualValue.toString();
assertJsonStringEqualsIgnoreNulls(expectedVal, actualVal);
}
else if (expectedValue instanceof JSONArray) {
if (actualValue instanceof JSONArray) {
JSONArray expectedJSONArray = (JSONArray)expectedValue;
JSONArray actualJSONArray = (JSONArray)actualValue;
for (int i = 0; i < expectedJSONArray.length(); i++) {
String expectedItem = expectedJSONArray.get(i).toString();
String actualItem = actualJSONArray.get(i).toString();
if (expectedValue instanceof JSONObject)
assertJsonStringEqualsIgnoreNulls(expectedItem, actualItem);
}
}
else {
fail("expected: " + expectedValue + " got:" + actualValue);
}
}
else {
Assert.assertEquals(expectedValue, actualValue);
}
}
}
public static <T> T readJsonResourceFileAsObject(String pathInResource, Class<T> valueType) throws IOException {
return readJsonResourceFileAsObject(pathInResource, valueType, false);
}
public static <T> T readJsonResourceFileAsObject(String pathInResource, Class<T> valueType, boolean ignoreUnknownProperties)
throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, ignoreUnknownProperties);
return objectMapper.readValue(
TestUtils.class.getResource(pathInResource),
valueType);
}
public static class JavaxRsClientMocks {
private final javax.ws.rs.client.Client fakeClient;
private final javax.ws.rs.client.Invocation.Builder fakeBuilder;
private final Response fakeResponse;
public javax.ws.rs.client.Client getFakeClient() {
return fakeClient;
}
public javax.ws.rs.client.Invocation.Builder getFakeBuilder() {
return fakeBuilder;
}
public Response getFakeResponse() {
return fakeResponse;
}
public JavaxRsClientMocks() {
final MockSettings mockSettings = withSettings().defaultAnswer(new TriesToReturnMockByType());
fakeClient = mock(javax.ws.rs.client.Client.class, mockSettings);
fakeBuilder = mock(javax.ws.rs.client.Invocation.Builder.class, mockSettings);
fakeResponse = mock(Response.class, mockSettings);
final javax.ws.rs.client.WebTarget fakeWebTarget = mock(javax.ws.rs.client.WebTarget.class, mockSettings);
TriesToReturnMockByType.setAvailableMocks(
fakeClient,
fakeWebTarget,
fakeBuilder,
fakeResponse
);
Mockito.when(fakeBuilder.get(any(Class.class))).thenReturn(null);
Mockito.when(fakeBuilder.get(eq(InputStream.class))).thenReturn(new ByteArrayInputStream(new byte[]{}));
Mockito.when(fakeBuilder.get(any(GenericType.class))).thenReturn(null);
Mockito.when(fakeResponse.getStatus()).thenReturn(200);
Mockito.when(fakeResponse.getStatusInfo()).thenReturn(Response.Status.OK);
Mockito.when(fakeResponse.readEntity(Service.class)).thenReturn(null);
}
}
/*
inspired out from newer Mockito version
returns a mock from given list if it's a matching return-type
*/
private static class TriesToReturnMockByType implements Answer<Object>, Serializable {
private final Answer<Object> defaultReturn = RETURNS_DEFAULTS;
private static List<Object> availableMocks = ImmutableList.of();
static void setAvailableMocks(Object... mocks) {
availableMocks = ImmutableList.copyOf(mocks);
}
public Object answer(InvocationOnMock invocation) throws Throwable {
Class<?> methodReturnType = invocation.getMethod().getReturnType();
return availableMocks.stream()
.filter(mock -> methodReturnType.isAssignableFrom(mock.getClass()))
//.peek(m -> System.out.println("found a mock: " + m.getClass().getName()))
.findFirst()
.orElse(defaultReturn.answer(invocation));
}
}
}
|
