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