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
|
package org.onap.sdc.http;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.onap.sdc.impl.DistributionClientResultImpl;
import org.onap.sdc.api.asdc.RegistrationRequest;
import org.onap.sdc.api.consumer.IConfiguration;
import org.onap.sdc.utils.Pair;
import com.att.nsa.apiClient.credentials.ApiCredential;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import fj.data.Either;
public class SdcConnectorClientTest {
private Gson gson = new GsonBuilder().create();
private static final String MOCK_ENV = "MockEnv";
private static final String MOCK_API_KEY = "MockApikey";
private static HttpAsdcClient httpClient = Mockito.mock(HttpAsdcClient.class);
private static IConfiguration configuration = Mockito.mock(IConfiguration.class);
private static ApiCredential apiCredential = Mockito.mock(ApiCredential.class);
private static HttpAsdcResponse httpAsdcResponse = Mockito.mock(HttpAsdcResponse.class);
@SuppressWarnings("unchecked")
private static Either<TopicRegistrationResponse, DistributionClientResultImpl> mockResponse = Mockito
.mock(Either.class);
private static Map<String, String> mockHeaders = new HashMap<>();
Pair<HttpAsdcResponse, CloseableHttpResponse> mockPair = new Pair<>(httpAsdcResponse, null);
private HttpEntity lastHttpEntity = null;
private static SdcConnectorClient asdcClient = Mockito.spy(new SdcConnectorClient());
@BeforeClass
public static void beforeClass() {
asdcClient.setConfiguration(configuration);
asdcClient.setHttpClient(httpClient);
when(apiCredential.getApiKey()).thenReturn(MOCK_API_KEY);
when(httpAsdcResponse.getStatus()).thenReturn(HttpStatus.SC_OK);
doReturn(mockHeaders).when(asdcClient).addHeadersToHttpRequest(Mockito.anyString());
doReturn(mockResponse).when(asdcClient).parseRegistrationResponse(httpAsdcResponse);
}
@Before
public void beforeMethod() {
Mockito.reset(configuration, httpClient);
lastHttpEntity = null;
when(configuration.getEnvironmentName()).thenReturn(MOCK_ENV);
doAnswer(new Answer<Pair<HttpAsdcResponse, CloseableHttpResponse>>() {
@Override
public Pair<HttpAsdcResponse, CloseableHttpResponse> answer(InvocationOnMock invocation) throws Throwable {
lastHttpEntity = invocation.getArgumentAt(1, HttpEntity.class);
return mockPair;
}
}).when(httpClient).postRequest(Mockito.eq(AsdcUrls.POST_FOR_TOPIC_REGISTRATION), Mockito.any(HttpEntity.class),
Mockito.eq(mockHeaders), Mockito.eq(false));
}
@Test
public void testConsumeProduceStatusTopicFalse() throws UnsupportedOperationException, IOException {
testConsumeProduceStatusTopic(false);
}
@Test
public void testConsumeProduceStatusTopicTrue() throws UnsupportedOperationException, IOException {
testConsumeProduceStatusTopic(true);
}
private void testConsumeProduceStatusTopic(final boolean isConsumeProduceStatusFlag) throws IOException {
when(configuration.isConsumeProduceStatusTopic()).thenReturn(isConsumeProduceStatusFlag);
asdcClient.registerAsdcTopics(apiCredential);
verify(httpClient, times(1)).postRequest(Mockito.eq(AsdcUrls.POST_FOR_TOPIC_REGISTRATION),
Mockito.any(HttpEntity.class), Mockito.eq(mockHeaders), Mockito.eq(false));
assertNotNull(lastHttpEntity);
RegistrationRequest actualRegRequest = gson.fromJson(IOUtils.toString(lastHttpEntity.getContent(), StandardCharsets.UTF_8), RegistrationRequest.class);
RegistrationRequest expectedRegRequest = gson.fromJson(excpectedStringBody(isConsumeProduceStatusFlag), RegistrationRequest.class);
assertTrue(actualRegRequest.getApiPublicKey().equals(expectedRegRequest.getApiPublicKey()));
assertTrue(actualRegRequest.getDistrEnvName().equals(expectedRegRequest.getDistrEnvName()));
assertTrue(actualRegRequest.getIsConsumerToSdcDistrStatusTopic()
.equals(expectedRegRequest.getIsConsumerToSdcDistrStatusTopic()));
}
private String excpectedStringBody(boolean isConsumeProduceStatusTopic) {
String stringBodyTemplate = "{\r\n" + " \"apiPublicKey\": \"MockApikey\",\r\n"
+ " \"distrEnvName\": \"MockEnv\",\r\n" + " \"isConsumerToSdcDistrStatusTopic\": %s\r\n" + "}";
return String.format(stringBodyTemplate, isConsumeProduceStatusTopic);
}
}
|
