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

   1 package org.onap.msb.apiroute.wrapper.service;
   2
   3 import com.fiftyonred.mock_jedis.MockJedisPool;
   4 import org.junit.Before;
   5 import org.junit.BeforeClass;
   6 import org.junit.Test;
   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;
  20
  21 import java.lang.reflect.InvocationHandler;
  22 import java.lang.reflect.Method;
  23 import java.util.*;
  24
  25 import static org.junit.Assert.*;
  26 import static org.powermock.api.mockito.PowerMockito.when;
  27
  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;
  34     @BeforeClass
  35     public static void setUp() throws Exception{
  36         microServiceFullService = MicroServiceFullService.getInstance();
  37         serviceComparator = new Comparator<MicroServiceFullInfo>() {
  38             @Override
  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());
  44                 return 0;
  45             }
  46         };
  47     }
  48     @Before
  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());
  54
  55         PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() {
  56             @Override
  57             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  58                 return mockJedisPool.getResource().keys((String) args[0]);
  59             }
  60         });
  61     }
  62
  63     @Test
  64     public void testExistsMicroServiceInstance_notExist(){
  65         try {
  66             assertFalse(microServiceFullService.existsMicroServiceInstance("notExist", "v1"));
  67         } catch (Exception e) {
  68             assert false:"throw exception means error occured!"+e.getMessage();
  69         }
  70     }
  71     @Test
  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);
  84         try {
  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();
  90         }
  91     }
  92
  93
  94     @Test
  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);
 107         try {
 108             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 109             MicroServiceFullInfo actual = microServiceFullService.getMicroServiceInstance("testService", "v1");
 110             assertEquals(microServiceFullInfo, actual);
 111         } catch (Exception e) {
 112             e.printStackTrace();
 113             assert false:"throw exception means error occured!"+e.getMessage();
 114         }
 115     }
 116
 117     @Test
 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);
 130         try {
 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();
 137         }
 138     }
 139
 140
 141     @Test
 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);
 154         try {
 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();
 161         }
 162     }
 163
 164     @Test
 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);
 177
 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);
 189
 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);
 201
 202         try {
 203             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 204             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
 205             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
 206
 207             Set<String> result = microServiceFullService.getAllMicroServiceKey();
 208             final Set<String> expected =new HashSet<String>();
 209             expected.add("testService");
 210             expected.add("testService2");
 211
 212             assertEquals(expected, result);
 213         } catch (Exception e) {
 214             assert false:"throw exception means error occured!"+e.getMessage();
 215         }
 216
 217     }
 218
 219     @Test
 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);
 232
 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);
 244
 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);
 256
 257         try {
 258             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 259             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3);
 260             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
 261
 262
 263             List<MicroServiceFullInfo> result = microServiceFullService.getAllVersionsOfTheService("testService");
 264
 265             List<MicroServiceFullInfo> expected = new ArrayList<>();
 266             expected.add(microServiceFullInfo);
 267             expected.add(microServiceFullInfo3);
 268
 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();
 274         }
 275
 276     }
 277
 278     @Test
 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);
 291
 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);
 303
 304         try {
 305             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo);
 306             microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2);
 307
 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) {
 316             e.printStackTrace();
 317             assert false:"throw exception means error occured!"+e.getMessage();
 318         }
 319     }
 320
 321
 322     @Test
 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);
 335
 336
 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);
 348
 349         try {
 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();
 360         }
 361     }
 362
 363     @Test
 364     public void tesGetMicroServiceInstance_notExist(){
 365         try {
 366             assertNull(microServiceFullService.getMicroServiceInstance("notExist","v1"));
 367         } catch (Exception e) {
 368             assert false:"throw exception means error occured!"+e.getMessage();
 369         }
 370
 371     }
 372     @Test
 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);
 385         try {
 386             //test null
 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"));
 394
 395
 396             //test String "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();
 406         }
 407     }
 408
 409     @Test(expected = Exception.class)
 410     public void tesSaveMicroService_null() throws Exception {
 411         microServiceFullService.saveMicroServiceInfo2Redis(null);
 412     }
 413 }