1 package org.onap.msb.apiroute.wrapper.service;
3 import com.fiftyonred.mock_jedis.MockJedisPool;
4 import org.junit.Before;
5 import org.junit.BeforeClass;
7 import org.junit.runner.RunWith;
8 import org.onap.msb.apiroute.api.MicroServiceFullInfo;
9 import org.onap.msb.apiroute.api.Node;
10 import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper;
11 import org.onap.msb.apiroute.wrapper.service.MicroServiceFullService;
12 import org.onap.msb.apiroute.wrapper.util.JedisUtil;
13 import org.onap.msb.apiroute.wrapper.util.MicroServiceUtil;
14 import org.powermock.api.mockito.PowerMockito;
15 import org.powermock.core.classloader.annotations.PowerMockIgnore;
16 import org.powermock.core.classloader.annotations.PrepareForTest;
17 import org.powermock.modules.junit4.PowerMockRunner;
18 import redis.clients.jedis.JedisPool;
19 import redis.clients.jedis.JedisPoolConfig;
21 import java.lang.reflect.InvocationHandler;
22 import java.lang.reflect.Method;
25 import static org.junit.Assert.*;
26 import static org.powermock.api.mockito.PowerMockito.when;
28 @RunWith(PowerMockRunner.class)
29 @PrepareForTest({JedisUtil.class,RedisAccessWrapper.class})
30 @PowerMockIgnore( {"javax.management.*"})
31 public class MicroServiceFullServiceTest {
32 private static MicroServiceFullService microServiceFullService = null;
33 private static Comparator<MicroServiceFullInfo> serviceComparator = null;
35 public static void setUp() throws Exception{
36 microServiceFullService = MicroServiceFullService.getInstance();
37 serviceComparator = new Comparator<MicroServiceFullInfo>() {
39 public int compare(MicroServiceFullInfo o1, MicroServiceFullInfo o2) {
40 if (!o1.getServiceName().equals(o2.getServiceName()))
41 return (o1.getServiceName()).compareTo(o2.getServiceName());
42 if (!o1.getVersion().equals(o2.getVersion()))
43 return (o1.getVersion()).compareTo(o2.getVersion());
49 public void setUpBeforeTest() throws Exception {
50 final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost");
51 PowerMockito.mockStatic(JedisUtil.class);
52 JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class);
53 when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource());
55 PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() {
57 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
58 return mockJedisPool.getResource().keys((String) args[0]);
64 public void testExistsMicroServiceInstance_notExist(){
66 assertFalse(microServiceFullService.existsMicroServiceInstance("notExist", "v1"));
67 } catch (Exception e) {
68 assert false:"throw exception means error occured!"+e.getMessage();
72 public void testExistsMicroServiceInstance_Exist(){
73 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
74 microServiceFullInfo.setServiceName("testService");
75 microServiceFullInfo.setVersion("v1");
76 microServiceFullInfo.setStatus("1");
77 microServiceFullInfo.setUrl("/testService/v1");
78 microServiceFullInfo.setVisualRange("0");
79 microServiceFullInfo.setProtocol("http");
80 microServiceFullInfo.setEnable_ssl(false);
81 Set<Node> nodeSet = new HashSet<>();
82 nodeSet.add(new Node("10.74.148.88","8080"));
83 microServiceFullInfo.setNodes(nodeSet);
85 assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
86 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
87 assertTrue(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
88 } catch (Exception e) {
89 assert false:"throw exception means error occured!"+e.getMessage();
95 public void testSaveMicroServiceInfo2Redis(){
96 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
97 microServiceFullInfo.setServiceName("testService");
98 microServiceFullInfo.setVersion("v1");
99 microServiceFullInfo.setStatus("1");
100 microServiceFullInfo.setUrl("/testService/v1");
101 microServiceFullInfo.setVisualRange("0");
102 microServiceFullInfo.setProtocol("http");
103 microServiceFullInfo.setEnable_ssl(false);
104 Set<Node> nodeSet = new HashSet<>();
105 nodeSet.add(new Node("10.74.148.88","8080"));
106 microServiceFullInfo.setNodes(nodeSet);
108 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
109 MicroServiceFullInfo actual = microServiceFullService.getMicroServiceInstance("testService", "v1");
110 assertEquals(microServiceFullInfo, actual);
111 } catch (Exception e) {
113 assert false:"throw exception means error occured!"+e.getMessage();
118 public void testDeleteMicroService(){
119 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
120 microServiceFullInfo.setServiceName("testService");
121 microServiceFullInfo.setVersion("v1");
122 microServiceFullInfo.setStatus("1");
123 microServiceFullInfo.setUrl("/testService/v1");
124 microServiceFullInfo.setVisualRange("0");
125 microServiceFullInfo.setProtocol("http");
126 microServiceFullInfo.setEnable_ssl(false);
127 Set<Node> nodeSet = new HashSet<>();
128 nodeSet.add(new Node("10.74.148.88","8080"));
129 microServiceFullInfo.setNodes(nodeSet);
131 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
132 assertTrue(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
133 microServiceFullService.deleteMicroService("testService","v1");
134 assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
135 } catch (Exception e) {
136 assert false:"throw exception means error occured!"+e.getMessage();
142 public void testUpdateMicroServiceStatus(){
143 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
144 microServiceFullInfo.setServiceName("testService");
145 microServiceFullInfo.setVersion("v1");
146 microServiceFullInfo.setStatus("1");
147 microServiceFullInfo.setUrl("/testService/v1");
148 microServiceFullInfo.setVisualRange("0");
149 microServiceFullInfo.setProtocol("http");
150 microServiceFullInfo.setEnable_ssl(false);
151 Set<Node> nodeSet = new HashSet<>();
152 nodeSet.add(new Node("10.74.148.88","8080"));
153 microServiceFullInfo.setNodes(nodeSet);
155 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
156 assertEquals("1", microServiceFullService.getMicroServiceInstance("testService","v1").getStatus());
157 microServiceFullService.updateMicroServiceStatus("testService", "v1", "0");
158 assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", "v1").getStatus());
159 } catch (Exception e) {
160 assert false:"throw exception means error occured!"+e.getMessage();
165 public void testGetAllMicroServiceKey(){
166 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
167 microServiceFullInfo.setServiceName("testService");
168 microServiceFullInfo.setVersion("v1");
169 microServiceFullInfo.setStatus("1");
170 microServiceFullInfo.setUrl("/testService/v1");
171 microServiceFullInfo.setVisualRange("0");
172 microServiceFullInfo.setProtocol("http");
173 microServiceFullInfo.setEnable_ssl(false);
174 Set<Node> nodeSet = new HashSet<>();
175 nodeSet.add(new Node("10.74.148.88","8080"));
176 microServiceFullInfo.setNodes(nodeSet);
178 MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo();
179 microServiceFullInfo2.setServiceName("testService2");
180 microServiceFullInfo2.setVersion("");
181 microServiceFullInfo2.setStatus("1");
182 microServiceFullInfo2.setUrl("/testService2");
183 microServiceFullInfo2.setVisualRange("0");
184 microServiceFullInfo2.setProtocol("http");
185 microServiceFullInfo2.setEnable_ssl(false);
186 Set<Node> nodeSet2 = new HashSet<>();
187 nodeSet2.add(new Node("10.74.148.88","8081"));
188 microServiceFullInfo2.setNodes(nodeSet2);
190 MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo();
191 microServiceFullInfo3.setServiceName("testService");
192 microServiceFullInfo3.setVersion("v2");
193 microServiceFullInfo3.setStatus("1");
194 microServiceFullInfo3.setUrl("/testService/v2");
195 microServiceFullInfo3.setVisualRange("0");
196 microServiceFullInfo3.setProtocol("http");
197 microServiceFullInfo3.setEnable_ssl(false);
198 Set<Node> nodeSet3 = new HashSet<>();
199 nodeSet3.add(new Node("10.74.148.89","8080"));
200 microServiceFullInfo3.setNodes(nodeSet3);
203 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
204 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
205 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
207 Set<String> result = microServiceFullService.getAllMicroServiceKey();
208 final Set<String> expected =new HashSet<String>();
209 expected.add("testService");
210 expected.add("testService2");
212 assertEquals(expected, result);
213 } catch (Exception e) {
214 assert false:"throw exception means error occured!"+e.getMessage();
220 public void testGetAllVersionsOfTheService(){
221 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
222 microServiceFullInfo.setServiceName("testService");
223 microServiceFullInfo.setVersion("v1");
224 microServiceFullInfo.setStatus("1");
225 microServiceFullInfo.setUrl("/testService/v1");
226 microServiceFullInfo.setVisualRange("0");
227 microServiceFullInfo.setProtocol("http");
228 microServiceFullInfo.setEnable_ssl(false);
229 Set<Node> nodeSet = new HashSet<>();
230 nodeSet.add(new Node("10.74.148.88","8080"));
231 microServiceFullInfo.setNodes(nodeSet);
233 MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo();
234 microServiceFullInfo2.setServiceName("testService2");
235 microServiceFullInfo2.setVersion("");
236 microServiceFullInfo2.setStatus("1");
237 microServiceFullInfo2.setUrl("/testService2");
238 microServiceFullInfo2.setVisualRange("0");
239 microServiceFullInfo2.setProtocol("http");
240 microServiceFullInfo2.setEnable_ssl(false);
241 Set<Node> nodeSet2 = new HashSet<>();
242 nodeSet2.add(new Node("10.74.148.88","8081"));
243 microServiceFullInfo2.setNodes(nodeSet2);
245 MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo();
246 microServiceFullInfo3.setServiceName("testService");
247 microServiceFullInfo3.setVersion("v2");
248 microServiceFullInfo3.setStatus("1");
249 microServiceFullInfo3.setUrl("/testService/v2");
250 microServiceFullInfo3.setVisualRange("0");
251 microServiceFullInfo3.setProtocol("http");
252 microServiceFullInfo3.setEnable_ssl(false);
253 Set<Node> nodeSet3 = new HashSet<>();
254 nodeSet3.add(new Node("10.74.148.89","8080"));
255 microServiceFullInfo3.setNodes(nodeSet3);
258 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
259 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
260 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
263 List<MicroServiceFullInfo> result = microServiceFullService.getAllVersionsOfTheService("testService");
265 List<MicroServiceFullInfo> expected = new ArrayList<>();
266 expected.add(microServiceFullInfo);
267 expected.add(microServiceFullInfo3);
269 Collections.sort(expected,serviceComparator);
270 Collections.sort(result,serviceComparator);
271 assertEquals(expected, result);
272 } catch (Exception e) {
273 assert false:"throw exception means error occured!"+e.getMessage();
279 public void testGetAllMicroServicesInstances(){
280 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
281 microServiceFullInfo.setServiceName("testService");
282 microServiceFullInfo.setVersion("v1");
283 microServiceFullInfo.setStatus("1");
284 microServiceFullInfo.setUrl("/testService/v1");
285 microServiceFullInfo.setVisualRange("0");
286 microServiceFullInfo.setProtocol("http");
287 microServiceFullInfo.setEnable_ssl(false);
288 Set<Node> nodeSet = new HashSet<>();
289 nodeSet.add(new Node("10.74.148.88","8080"));
290 microServiceFullInfo.setNodes(nodeSet);
292 MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo();
293 microServiceFullInfo2.setServiceName("testService2");
294 microServiceFullInfo2.setVersion("");
295 microServiceFullInfo2.setStatus("1");
296 microServiceFullInfo2.setUrl("/testService/v1");
297 microServiceFullInfo2.setVisualRange("0");
298 microServiceFullInfo2.setProtocol("http");
299 microServiceFullInfo2.setEnable_ssl(true);
300 Set<Node> nodeSet2 = new HashSet<>();
301 nodeSet2.add(new Node("10.74.148.89","8080"));
302 microServiceFullInfo2.setNodes(nodeSet2);
305 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
306 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
308 List<MicroServiceFullInfo> expected = new ArrayList<MicroServiceFullInfo>();
309 expected.add(microServiceFullInfo);
310 expected.add(microServiceFullInfo2);
311 List<MicroServiceFullInfo> result = microServiceFullService.getAllMicroServiceInstances();
312 Collections.sort(expected, serviceComparator);
313 Collections.sort(result,serviceComparator );
314 assertEquals(expected, result);
315 } catch (Exception e) {
317 assert false:"throw exception means error occured!"+e.getMessage();
323 public void testDeleteMultiMicroService(){
324 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
325 microServiceFullInfo.setServiceName("testService");
326 microServiceFullInfo.setVersion("v1");
327 microServiceFullInfo.setStatus("1");
328 microServiceFullInfo.setUrl("/testService/v1");
329 microServiceFullInfo.setVisualRange("0");
330 microServiceFullInfo.setProtocol("http");
331 microServiceFullInfo.setEnable_ssl(false);
332 Set<Node> nodeSet = new HashSet<>();
333 nodeSet.add(new Node("10.74.148.88","8080"));
334 microServiceFullInfo.setNodes(nodeSet);
337 MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo();
338 microServiceFullInfo3.setServiceName("testService");
339 microServiceFullInfo3.setVersion("v2");
340 microServiceFullInfo3.setStatus("1");
341 microServiceFullInfo3.setUrl("/testService/v2");
342 microServiceFullInfo3.setVisualRange("0");
343 microServiceFullInfo3.setProtocol("http");
344 microServiceFullInfo3.setEnable_ssl(false);
345 Set<Node> nodeSet3 = new HashSet<>();
346 nodeSet3.add(new Node("10.74.148.89","8080"));
347 microServiceFullInfo3.setNodes(nodeSet3);
350 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
351 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
352 //two versions of testservice exist
353 assertEquals(2,microServiceFullService.getAllVersionsOfTheService("testService").size());
354 //delete all versions of testservice
355 long size = microServiceFullService.deleteMultiMicroService(MicroServiceUtil.getPrefixedKey("testService","*"));
356 //after delete,no version exist
357 assertEquals(0,microServiceFullService.getAllVersionsOfTheService("testService").size());
358 } catch (Exception e) {
359 assert false:"throw exception means error occured!"+e.getMessage();
364 public void tesGetMicroServiceInstance_notExist(){
366 assertNull(microServiceFullService.getMicroServiceInstance("notExist","v1"));
367 } catch (Exception e) {
368 assert false:"throw exception means error occured!"+e.getMessage();
373 public void tesExistsGetUpdateDeleteMicroServiceStatus_versionNull(){
374 MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
375 microServiceFullInfo.setServiceName("testService");
376 microServiceFullInfo.setVersion("");
377 microServiceFullInfo.setStatus("1");
378 microServiceFullInfo.setUrl("/testService/v1");
379 microServiceFullInfo.setVisualRange("0");
380 microServiceFullInfo.setProtocol("http");
381 microServiceFullInfo.setEnable_ssl(false);
382 Set<Node> nodeSet = new HashSet<>();
383 nodeSet.add(new Node("10.74.148.88","8080"));
384 microServiceFullInfo.setNodes(nodeSet);
387 assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "null"));
388 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
389 assertEquals("1", microServiceFullService.getMicroServiceInstance("testService","null").getStatus());
390 microServiceFullService.updateMicroServiceStatus("testService", "null", "0");
391 assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", "null").getStatus());
392 microServiceFullService.deleteMicroService("testService","null");
393 assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "null"));
397 assertFalse(microServiceFullService.existsMicroServiceInstance("testService", null));
398 microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
399 assertEquals("1", microServiceFullService.getMicroServiceInstance("testService",null).getStatus());
400 microServiceFullService.updateMicroServiceStatus("testService", null, "0");
401 assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", null).getStatus());
402 microServiceFullService.deleteMicroService("testService",null);
403 assertFalse(microServiceFullService.existsMicroServiceInstance("testService", null));
404 } catch (Exception e) {
405 assert false:"throw exception means error occured!"+e.getMessage();
409 @Test(expected = Exception.class)
410 public void tesSaveMicroService_null() throws Exception {
411 microServiceFullService.saveMicroServiceInfo2Redis(null);