apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/MicroServiceFullServiceTest.java

   1 /*******************************************************************************
   2  * Copyright 2016-2017 ZTE, Inc. and others.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   5  * in compliance with the License. You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software distributed under the License
  10  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  11  * or implied. See the License for the specific language governing permissions and limitations under
  12  * the License.
  13  ******************************************************************************/
  14 package org.onap.msb.apiroute.wrapper.service;
  15
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertFalse;
  18 import static org.junit.Assert.assertNull;
  19 import static org.junit.Assert.assertTrue;
  20 import static org.powermock.api.mockito.PowerMockito.when;
  21
  22 import java.lang.reflect.InvocationHandler;
  23 import java.lang.reflect.Method;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.Comparator;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Set;
  30
  31 import org.junit.Before;
  32 import org.junit.BeforeClass;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.onap.msb.apiroute.api.MicroServiceFullInfo;
  36 import org.onap.msb.apiroute.api.Node;
  37 import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper;
  38 import org.onap.msb.apiroute.wrapper.util.JedisUtil;
  39 import org.onap.msb.apiroute.wrapper.util.MicroServiceUtil;
  40 import org.powermock.api.mockito.PowerMockito;
  41 import org.powermock.core.classloader.annotations.PowerMockIgnore;
  42 import org.powermock.core.classloader.annotations.PrepareForTest;
  43 import org.powermock.modules.junit4.PowerMockRunner;
  44
  45 import com.fiftyonred.mock_jedis.MockJedisPool;
  46
  47 import redis.clients.jedis.JedisPool;
  48 import redis.clients.jedis.JedisPoolConfig;
  49
  50 @RunWith(PowerMockRunner.class)
  51 @PrepareForTest({JedisUtil.class, RedisAccessWrapper.class})
  52 @PowerMockIgnore({"javax.management.*"})
  53 public class MicroServiceFullServiceTest {
  54     private static MicroServiceFullService microServiceFullService = null;
  55     private static Comparator<MicroServiceFullInfo> serviceComparator = null;
  56
  57     @BeforeClass
  58     public static void setUp() throws Exception {
  59         microServiceFullService = MicroServiceFullService.getInstance();
  60         serviceComparator = new Comparator<MicroServiceFullInfo>() {
  61             @Override
  62             public int compare(MicroServiceFullInfo o1, MicroServiceFullInfo o2) {
  63                 if (!o1.getServiceName().equals(o2.getServiceName()))
  64                     return (o1.getServiceName()).compareTo(o2.getServiceName());
  65                 if (!o1.getVersion().equals(o2.getVersion()))
  66                     return (o1.getVersion()).compareTo(o2.getVersion());
  67                 return 0;
  68             }
  69         };
  70     }
  71
  72     @Before
  73     public void setUpBeforeTest() throws Exception {
  74         final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost");
  75         PowerMockito.mockStatic(JedisUtil.class);
  76         JedisUtil jedisUtil = PowerMockito.mock(JedisUtil.class);
  77         when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource());
  78
  79         PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() {
  80             @Override
  81             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  82                 return mockJedisPool.getResource().keys((String) args[0]);
  83             }
  84         });
  85     }
  86
  87     @Test
  88     public void testExistsMicroServiceInstance_notExist() {
  89         try {
  90             assertFalse(microServiceFullService.existsMicroServiceInstance("notExist", "v1"));
  91         } catch (Exception e) {
  92             assert false : "throw exception means error occured!" + e.getMessage();
  93         }
  94     }
  95
  96     @Test
  97     public void testExistsMicroServiceInstance_Exist() {
  98         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
  99         microServiceFullInfo.setServiceName("testService");
 100         microServiceFullInfo.setVersion("v1");
 101         microServiceFullInfo.setStatus("1");
 102         microServiceFullInfo.setUrl("/testService/v1");
 103         microServiceFullInfo.setVisualRange("0");
 104         microServiceFullInfo.setProtocol("http");
 105         microServiceFullInfo.setEnable_ssl(false);
 106         Set<Node> nodeSet = new HashSet<>();
 107         nodeSet.add(new Node("10.74.148.88", "8080"));
 108         microServiceFullInfo.setNodes(nodeSet);
 109         try {
 110             assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
 111             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 112             assertTrue(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
 113         } catch (Exception e) {
 114             assert false : "throw exception means error occured!" + e.getMessage();
 115         }
 116     }
 117
 118
 119     @Test
 120     public void testSaveMicroServiceInfo2Redis() {
 121         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 122         microServiceFullInfo.setServiceName("testService");
 123         microServiceFullInfo.setVersion("v1");
 124         microServiceFullInfo.setStatus("1");
 125         microServiceFullInfo.setUrl("/testService/v1");
 126         microServiceFullInfo.setVisualRange("0");
 127         microServiceFullInfo.setProtocol("http");
 128         microServiceFullInfo.setEnable_ssl(false);
 129         Set<Node> nodeSet = new HashSet<>();
 130         nodeSet.add(new Node("10.74.148.88", "8080"));
 131         microServiceFullInfo.setNodes(nodeSet);
 132         try {
 133             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 134             MicroServiceFullInfo actual = microServiceFullService.getMicroServiceInstance("testService", "v1");
 135             assertEquals(microServiceFullInfo, actual);
 136         } catch (Exception e) {
 137             e.printStackTrace();
 138             assert false : "throw exception means error occured!" + e.getMessage();
 139         }
 140     }
 141
 142     @Test
 143     public void testDeleteMicroService() {
 144         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 145         microServiceFullInfo.setServiceName("testService");
 146         microServiceFullInfo.setVersion("v1");
 147         microServiceFullInfo.setStatus("1");
 148         microServiceFullInfo.setUrl("/testService/v1");
 149         microServiceFullInfo.setVisualRange("0");
 150         microServiceFullInfo.setProtocol("http");
 151         microServiceFullInfo.setEnable_ssl(false);
 152         Set<Node> nodeSet = new HashSet<>();
 153         nodeSet.add(new Node("10.74.148.88", "8080"));
 154         microServiceFullInfo.setNodes(nodeSet);
 155         try {
 156             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 157             assertTrue(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
 158             microServiceFullService.deleteMicroService("testService", "v1");
 159             assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "v1"));
 160         } catch (Exception e) {
 161             assert false : "throw exception means error occured!" + e.getMessage();
 162         }
 163     }
 164
 165
 166     @Test
 167     public void testUpdateMicroServiceStatus() {
 168         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 169         microServiceFullInfo.setServiceName("testService");
 170         microServiceFullInfo.setVersion("v1");
 171         microServiceFullInfo.setStatus("1");
 172         microServiceFullInfo.setUrl("/testService/v1");
 173         microServiceFullInfo.setVisualRange("0");
 174         microServiceFullInfo.setProtocol("http");
 175         microServiceFullInfo.setEnable_ssl(false);
 176         Set<Node> nodeSet = new HashSet<>();
 177         nodeSet.add(new Node("10.74.148.88", "8080"));
 178         microServiceFullInfo.setNodes(nodeSet);
 179         try {
 180             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 181             assertEquals("1", microServiceFullService.getMicroServiceInstance("testService", "v1").getStatus());
 182             microServiceFullService.updateMicroServiceStatus("testService", "v1", "0");
 183             assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", "v1").getStatus());
 184         } catch (Exception e) {
 185             assert false : "throw exception means error occured!" + e.getMessage();
 186         }
 187     }
 188
 189     @Test
 190     public void testGetAllMicroServiceKey() {
 191         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 192         microServiceFullInfo.setServiceName("testService");
 193         microServiceFullInfo.setVersion("v1");
 194         microServiceFullInfo.setStatus("1");
 195         microServiceFullInfo.setUrl("/testService/v1");
 196         microServiceFullInfo.setVisualRange("0");
 197         microServiceFullInfo.setProtocol("http");
 198         microServiceFullInfo.setEnable_ssl(false);
 199         Set<Node> nodeSet = new HashSet<>();
 200         nodeSet.add(new Node("10.74.148.88", "8080"));
 201         microServiceFullInfo.setNodes(nodeSet);
 202
 203         MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo();
 204         microServiceFullInfo2.setServiceName("testService2");
 205         microServiceFullInfo2.setVersion("");
 206         microServiceFullInfo2.setStatus("1");
 207         microServiceFullInfo2.setUrl("/testService2");
 208         microServiceFullInfo2.setVisualRange("0");
 209         microServiceFullInfo2.setProtocol("http");
 210         microServiceFullInfo2.setEnable_ssl(false);
 211         Set<Node> nodeSet2 = new HashSet<>();
 212         nodeSet2.add(new Node("10.74.148.88", "8081"));
 213         microServiceFullInfo2.setNodes(nodeSet2);
 214
 215         MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo();
 216         microServiceFullInfo3.setServiceName("testService");
 217         microServiceFullInfo3.setVersion("v2");
 218         microServiceFullInfo3.setStatus("1");
 219         microServiceFullInfo3.setUrl("/testService/v2");
 220         microServiceFullInfo3.setVisualRange("0");
 221         microServiceFullInfo3.setProtocol("http");
 222         microServiceFullInfo3.setEnable_ssl(false);
 223         Set<Node> nodeSet3 = new HashSet<>();
 224         nodeSet3.add(new Node("10.74.148.89", "8080"));
 225         microServiceFullInfo3.setNodes(nodeSet3);
 226
 227         try {
 228             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 229             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
 230             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
 231
 232             Set<String> result = microServiceFullService.getAllMicroServiceKey();
 233             final Set<String> expected = new HashSet<String>();
 234             expected.add("testService");
 235             expected.add("testService2");
 236
 237             assertEquals(expected, result);
 238         } catch (Exception e) {
 239             assert false : "throw exception means error occured!" + e.getMessage();
 240         }
 241
 242     }
 243
 244     @Test
 245     public void testGetAllVersionsOfTheService() {
 246         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 247         microServiceFullInfo.setServiceName("testService");
 248         microServiceFullInfo.setVersion("v1");
 249         microServiceFullInfo.setStatus("1");
 250         microServiceFullInfo.setUrl("/testService/v1");
 251         microServiceFullInfo.setVisualRange("0");
 252         microServiceFullInfo.setProtocol("http");
 253         microServiceFullInfo.setEnable_ssl(false);
 254         Set<Node> nodeSet = new HashSet<>();
 255         nodeSet.add(new Node("10.74.148.88", "8080"));
 256         microServiceFullInfo.setNodes(nodeSet);
 257
 258         MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo();
 259         microServiceFullInfo2.setServiceName("testService2");
 260         microServiceFullInfo2.setVersion("");
 261         microServiceFullInfo2.setStatus("1");
 262         microServiceFullInfo2.setUrl("/testService2");
 263         microServiceFullInfo2.setVisualRange("0");
 264         microServiceFullInfo2.setProtocol("http");
 265         microServiceFullInfo2.setEnable_ssl(false);
 266         Set<Node> nodeSet2 = new HashSet<>();
 267         nodeSet2.add(new Node("10.74.148.88", "8081"));
 268         microServiceFullInfo2.setNodes(nodeSet2);
 269
 270         MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo();
 271         microServiceFullInfo3.setServiceName("testService");
 272         microServiceFullInfo3.setVersion("v2");
 273         microServiceFullInfo3.setStatus("1");
 274         microServiceFullInfo3.setUrl("/testService/v2");
 275         microServiceFullInfo3.setVisualRange("0");
 276         microServiceFullInfo3.setProtocol("http");
 277         microServiceFullInfo3.setEnable_ssl(false);
 278         Set<Node> nodeSet3 = new HashSet<>();
 279         nodeSet3.add(new Node("10.74.148.89", "8080"));
 280         microServiceFullInfo3.setNodes(nodeSet3);
 281
 282         try {
 283             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 284             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
 285             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
 286
 287
 288             List<MicroServiceFullInfo> result = microServiceFullService.getAllVersionsOfTheService("testService");
 289
 290             List<MicroServiceFullInfo> expected = new ArrayList<>();
 291             expected.add(microServiceFullInfo);
 292             expected.add(microServiceFullInfo3);
 293
 294             Collections.sort(expected, serviceComparator);
 295             Collections.sort(result, serviceComparator);
 296             assertEquals(expected, result);
 297         } catch (Exception e) {
 298             assert false : "throw exception means error occured!" + e.getMessage();
 299         }
 300
 301     }
 302
 303     @Test
 304     public void testGetAllMicroServicesInstances() {
 305         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 306         microServiceFullInfo.setServiceName("testService");
 307         microServiceFullInfo.setVersion("v1");
 308         microServiceFullInfo.setStatus("1");
 309         microServiceFullInfo.setUrl("/testService/v1");
 310         microServiceFullInfo.setVisualRange("0");
 311         microServiceFullInfo.setProtocol("http");
 312         microServiceFullInfo.setEnable_ssl(false);
 313         Set<Node> nodeSet = new HashSet<>();
 314         nodeSet.add(new Node("10.74.148.88", "8080"));
 315         microServiceFullInfo.setNodes(nodeSet);
 316
 317         MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo();
 318         microServiceFullInfo2.setServiceName("testService2");
 319         microServiceFullInfo2.setVersion("");
 320         microServiceFullInfo2.setStatus("1");
 321         microServiceFullInfo2.setUrl("/testService/v1");
 322         microServiceFullInfo2.setVisualRange("0");
 323         microServiceFullInfo2.setProtocol("http");
 324         microServiceFullInfo2.setEnable_ssl(true);
 325         Set<Node> nodeSet2 = new HashSet<>();
 326         nodeSet2.add(new Node("10.74.148.89", "8080"));
 327         microServiceFullInfo2.setNodes(nodeSet2);
 328
 329         try {
 330             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 331             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
 332
 333             List<MicroServiceFullInfo> expected = new ArrayList<MicroServiceFullInfo>();
 334             expected.add(microServiceFullInfo);
 335             expected.add(microServiceFullInfo2);
 336             List<MicroServiceFullInfo> result = microServiceFullService.getAllMicroServiceInstances();
 337             Collections.sort(expected, serviceComparator);
 338             Collections.sort(result, serviceComparator);
 339             assertEquals(expected, result);
 340         } catch (Exception e) {
 341             e.printStackTrace();
 342             assert false : "throw exception means error occured!" + e.getMessage();
 343         }
 344     }
 345
 346
 347     @Test
 348     public void testDeleteMultiMicroService() {
 349         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 350         microServiceFullInfo.setServiceName("testService");
 351         microServiceFullInfo.setVersion("v1");
 352         microServiceFullInfo.setStatus("1");
 353         microServiceFullInfo.setUrl("/testService/v1");
 354         microServiceFullInfo.setVisualRange("0");
 355         microServiceFullInfo.setProtocol("http");
 356         microServiceFullInfo.setEnable_ssl(false);
 357         Set<Node> nodeSet = new HashSet<>();
 358         nodeSet.add(new Node("10.74.148.88", "8080"));
 359         microServiceFullInfo.setNodes(nodeSet);
 360
 361
 362         MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo();
 363         microServiceFullInfo3.setServiceName("testService");
 364         microServiceFullInfo3.setVersion("v2");
 365         microServiceFullInfo3.setStatus("1");
 366         microServiceFullInfo3.setUrl("/testService/v2");
 367         microServiceFullInfo3.setVisualRange("0");
 368         microServiceFullInfo3.setProtocol("http");
 369         microServiceFullInfo3.setEnable_ssl(false);
 370         Set<Node> nodeSet3 = new HashSet<>();
 371         nodeSet3.add(new Node("10.74.148.89", "8080"));
 372         microServiceFullInfo3.setNodes(nodeSet3);
 373
 374         try {
 375             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 376             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
 377             // two versions of testservice exist
 378             assertEquals(2, microServiceFullService.getAllVersionsOfTheService("testService").size());
 379             // delete all versions of testservice
 380             long size = microServiceFullService
 381                             .deleteMultiMicroService(MicroServiceUtil.getPrefixedKey("testService", "*"));
 382             // after delete,no version exist
 383             assertEquals(0, microServiceFullService.getAllVersionsOfTheService("testService").size());
 384         } catch (Exception e) {
 385             assert false : "throw exception means error occured!" + e.getMessage();
 386         }
 387     }
 388
 389     @Test
 390     public void tesGetMicroServiceInstance_notExist() {
 391         try {
 392             assertNull(microServiceFullService.getMicroServiceInstance("notExist", "v1"));
 393         } catch (Exception e) {
 394             assert false : "throw exception means error occured!" + e.getMessage();
 395         }
 396
 397     }
 398
 399     @Test
 400     public void tesExistsGetUpdateDeleteMicroServiceStatus_versionNull() {
 401         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 402         microServiceFullInfo.setServiceName("testService");
 403         microServiceFullInfo.setVersion("");
 404         microServiceFullInfo.setStatus("1");
 405         microServiceFullInfo.setUrl("/testService/v1");
 406         microServiceFullInfo.setVisualRange("0");
 407         microServiceFullInfo.setProtocol("http");
 408         microServiceFullInfo.setEnable_ssl(false);
 409         Set<Node> nodeSet = new HashSet<>();
 410         nodeSet.add(new Node("10.74.148.88", "8080"));
 411         microServiceFullInfo.setNodes(nodeSet);
 412         try {
 413             // test null
 414             assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "null"));
 415             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 416             assertEquals("1", microServiceFullService.getMicroServiceInstance("testService", "null").getStatus());
 417             microServiceFullService.updateMicroServiceStatus("testService", "null", "0");
 418             assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", "null").getStatus());
 419             microServiceFullService.deleteMicroService("testService", "null");
 420             assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "null"));
 421
 422
 423             // test String "null"
 424             assertFalse(microServiceFullService.existsMicroServiceInstance("testService", null));
 425             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 426             assertEquals("1", microServiceFullService.getMicroServiceInstance("testService", null).getStatus());
 427             microServiceFullService.updateMicroServiceStatus("testService", null, "0");
 428             assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", null).getStatus());
 429             microServiceFullService.deleteMicroService("testService", null);
 430             assertFalse(microServiceFullService.existsMicroServiceInstance("testService", null));
 431         } catch (Exception e) {
 432             assert false : "throw exception means error occured!" + e.getMessage();
 433         }
 434     }
 435
 436     @Test(expected = Exception.class)
 437     public void tesSaveMicroService_null() throws Exception {
 438         microServiceFullService.saveMicroServiceInfo2Redis(null);
 439     }
 440 }