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
|
package org.onap.dcae.ci.api.tests.ruleEditor;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.assertj.core.api.SoftAssertions;
import org.onap.dcae.ci.api.tests.DcaeRestBaseTest;
import org.onap.dcae.ci.entities.RestResponse;
import org.onap.dcae.ci.utilities.DcaeRestClient;
import org.onap.dcae.ci.report.Report;
import org.onap.sdc.dcae.composition.restmodels.ruleeditor.EventTypeDefinitionUI;
import org.onap.sdc.dcae.composition.restmodels.ruleeditor.EventTypesByVersionUI;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import com.aventstack.extentreports.Status;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
public class GetDefinitionTest extends DcaeRestBaseTest {
@DataProvider(name = "EventTypes")
public static Object[][] getVesVersions() {
Gson gson = new GsonBuilder().create();
try {
Report.log(Status.INFO, "Requesting VES event types");
RestResponse response = DcaeRestClient.getVesEventTypes();
Report.logDebug("Response", response);
if (response.getStatusCode() != 200) {
throw new Exception(response.toString());
}
EventTypesByVersionUI[] eventsByVersionList = gson.fromJson(response.getResponse(), EventTypesByVersionUI[].class);
return Arrays.stream(eventsByVersionList)
.flatMap(version -> version.getEventTypes().stream()
.map( event -> new Object[] {version.getVersion(), event} )
).toArray(Object[][]::new);
} catch (Exception err) {
Report.log(Status.ERROR, "Unable to get ves event types\nException: %s", err.toString());
return new Object[][] {};
}
}
/* Positive */
@Test(dataProvider = "EventTypes")
public void testParameterized(String version, String eventType) throws Exception {
// arrange
Report.log(Status.INFO, "testParameterized. version="+version+", eventType="+eventType);
Gson gsonStrict = new GsonBuilder()
.registerTypeAdapter(EventTypeDefinitionUI.class, new StrictJsonDeserializer<EventTypeDefinitionUI>())
.create();
// act
RestResponse response = DcaeRestClient.getVesDataTypes(version, eventType);
Report.logDebug("Response", response);
// assert
EventTypeDefinitionUI[] resBody = gson.fromJson(response.getResponse(), EventTypeDefinitionUI[].class);
List<EventTypeDefinitionUI> resBodyFlat = flatten(Arrays.asList(resBody));
Report.logDebug("resBodyFlat", gsonStrict.toJson(resBodyFlat));
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(response.getStatusCode()).as("response status").isEqualTo(200);
softly.assertThat(resBodyFlat).extracting("name").as("name")
.doesNotContain(StringUtils.EMPTY)
.doesNotContainNull();
softly.assertThat(resBodyFlat).extracting("id").as("id")
.doesNotContain(StringUtils.EMPTY)
.doesNotContainNull();
});
}
/* Negative */
/* Private Methods */
public class StrictJsonDeserializer<T> implements JsonDeserializer<T> {
private Gson gson = new Gson();
@Override
public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
try {
Field[] declaredFields = Class.forName(typeOfT.getTypeName()).getDeclaredFields();
Arrays.asList(declaredFields).stream()
.map(field -> field.getName())
.forEach(fieldName -> {
if (json.getAsJsonObject().has(fieldName) == false) {
throw new JsonParseException(String.format("Missing field '%s'", fieldName));
}
});
} catch (SecurityException e) {
throw new JsonParseException("unable to parse", e);
} catch (ClassNotFoundException e) {
throw new JsonParseException("unable to parse", e);
}
return gson.fromJson(json, typeOfT);
}
}
private List<EventTypeDefinitionUI> flatten(List<EventTypeDefinitionUI> events) {
List<EventTypeDefinitionUI> result = new ArrayList<EventTypeDefinitionUI>();
events.stream().forEach(e -> {
List<EventTypeDefinitionUI> children = e.getChildren();
result.add(e); // add this node
if (children != null) {
result.addAll(flatten(children)); // add child nodes recursively
}
});
return result;
}
/* Negative */
}
|
