apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/MicroServiceWrapperTest.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;
  15
  16 import java.lang.reflect.InvocationHandler;
  17 import java.lang.reflect.Method;
  18 import java.util.ArrayList;
  19 import java.util.Collections;
  20 import java.util.Comparator;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Set;
  24
  25 import org.junit.Assert;
  26 import org.junit.Before;
  27 import org.junit.BeforeClass;
  28 import org.junit.Test;
  29 import org.junit.runner.RunWith;
  30 import org.onap.msb.apiroute.api.MicroServiceFullInfo;
  31 import org.onap.msb.apiroute.api.Node;
  32 import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException;
  33 import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper;
  34 import org.onap.msb.apiroute.wrapper.util.JedisUtil;
  35 import org.powermock.api.mockito.PowerMockito;
  36 import org.powermock.core.classloader.annotations.PowerMockIgnore;
  37 import org.powermock.core.classloader.annotations.PrepareForTest;
  38 import org.powermock.modules.junit4.PowerMockRunner;
  39
  40 import com.fiftyonred.mock_jedis.MockJedisPool;
  41
  42 import redis.clients.jedis.JedisPool;
  43 import redis.clients.jedis.JedisPoolConfig;
  44
  45
  46 @RunWith(PowerMockRunner.class)
  47 @PrepareForTest({JedisUtil.class, RedisAccessWrapper.class})
  48 @PowerMockIgnore({"javax.management.*", "jdk.internal.reflect.*"})
  49 public class MicroServiceWrapperTest {
  50     private static MicroServiceWrapper microServiceWrapper;
  51     private static Comparator<MicroServiceFullInfo> microServiceComparator = null;
  52
  53
  54     @BeforeClass
  55     public static void setUpBeforeClass() throws Exception {
  56         microServiceWrapper = MicroServiceWrapper.getInstance();
  57         microServiceComparator = new Comparator<MicroServiceFullInfo>() {
  58             @Override
  59             public int compare(MicroServiceFullInfo o1, MicroServiceFullInfo o2) {
  60                 if (!o1.getServiceName().equals(o2.getServiceName()))
  61                     return (o1.getServiceName()).compareTo(o2.getServiceName());
  62                 return 0;
  63             }
  64         };
  65     }
  66
  67     @Before
  68     public void setUpBeforeTest() throws Exception {
  69         final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost");
  70         PowerMockito.mockStatic(JedisUtil.class);
  71         JedisUtil jedisUtil = PowerMockito.mock(JedisUtil.class);
  72         PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource());
  73
  74         PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() {
  75             @Override
  76             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  77                 return mockJedisPool.getResource().keys((String) args[0]);
  78             }
  79         });
  80     }
  81
  82     @Test
  83     public void test_getMicroServiceFullInfo_not_exist() {
  84         try {
  85             microServiceWrapper.getMicroServiceInstance("testForJunit", "v1");
  86             Assert.fail("should not process to here.");
  87         } catch (Exception e) {
  88             Assert.assertTrue(e instanceof ExtendedNotFoundException);
  89
  90         }
  91
  92     }
  93
  94     @Test
  95     public void test_getMicroServiceFullInfo() {
  96
  97         MicroServiceFullInfo microServiceFullInfo = buildMicroServiceFullInfo();
  98         try {
  99             microServiceWrapper.saveMicroServiceInstance(microServiceFullInfo, false, "", "");
 100             MicroServiceFullInfo dbMicroServiceFullInfo =
 101                             microServiceWrapper.getMicroServiceInstance("testService", "v1");
 102             Assert.assertEquals(microServiceFullInfo, dbMicroServiceFullInfo);
 103         } catch (Exception e) {
 104             assert false : "throw exception means error occured!" + e.getMessage();
 105         }
 106
 107     }
 108
 109     @Test
 110     public void test_getAllMicroServiceInstances() {
 111         MicroServiceFullInfo microService = buildMicroServiceFullInfo();
 112         MicroServiceFullInfo microService2 = buildMicroServiceFullInfo2();
 113         List<MicroServiceFullInfo> expected = new ArrayList<>();
 114         expected.add(microService);
 115         expected.add(microService2);
 116         Collections.sort(expected, microServiceComparator);
 117
 118         try {
 119             microServiceWrapper.saveMicroServiceInstance(microService, false, "", "");
 120             microServiceWrapper.saveMicroServiceInstance(microService2, false, "", "");
 121
 122             List<MicroServiceFullInfo> microServiceList = microServiceWrapper.getAllMicroServiceInstances();
 123             Collections.sort(microServiceList, microServiceComparator);
 124
 125             Assert.assertEquals(expected, microServiceList);
 126
 127         } catch (Exception e) {
 128             Assert.fail("throw exception means error occured!" + e.getMessage());
 129         }
 130
 131     }
 132
 133     @Test
 134     public void test_updateMicroServiceStatus() {
 135         MicroServiceFullInfo microService = buildMicroServiceFullInfo();
 136
 137         try {
 138             microServiceWrapper.saveMicroServiceInstance(microService, false, "", "");
 139             MicroServiceFullInfo dbMicroServiceFullInfo =
 140                             microServiceWrapper.getMicroServiceInstance("testService", "v1");
 141             Assert.assertEquals("1", dbMicroServiceFullInfo.getStatus());
 142             microServiceWrapper.updateMicroServiceStatus("testService", "v1", "0");
 143             dbMicroServiceFullInfo = microServiceWrapper.getMicroServiceInstance("testService", "v1");
 144             Assert.assertEquals("0", dbMicroServiceFullInfo.getStatus());
 145         } catch (Exception e) {
 146             Assert.fail("throw exception means error occured!" + e.getMessage());
 147         }
 148
 149     }
 150
 151
 152
 153     @Test
 154     public void test_deleteMicroService() {
 155         MicroServiceFullInfo microService = buildMicroServiceFullInfo2();
 156         try {
 157             microServiceWrapper.saveMicroServiceInstance(microService, false, "", "");
 158             MicroServiceFullInfo dbMicroServiceFullInfo =
 159                             microServiceWrapper.getMicroServiceInstance("testService2", "v1");
 160             Assert.assertNotNull(dbMicroServiceFullInfo);
 161
 162         } catch (Exception e) {
 163             Assert.fail("throw exception means error occured!" + e.getMessage());
 164         }
 165         try {
 166             microServiceWrapper.deleteMicroService("testService2", "v1");
 167             microServiceWrapper.getMicroServiceInstance("testService2", "v1");
 168         } catch (Exception e) {
 169             Assert.assertTrue(e instanceof ExtendedNotFoundException);
 170         }
 171     }
 172
 173     @Test
 174     public void test_deleteMicroServiceInstance() {
 175
 176
 177         // 添加多版本服务
 178         MicroServiceFullInfo microService4v2 = buildMicroServiceFullInfo4version2();
 179         try {
 180             microServiceWrapper.saveMicroServiceInstance(microService4v2, false, "", "");
 181         } catch (Exception e) {
 182             Assert.fail("throw exception means error occured!" + e.getMessage());
 183         }
 184
 185         // 删除不存在实例
 186         try {
 187             microServiceWrapper.deleteMicroServiceInstance("testService", "v2", "127.0.0.1", "8989");
 188         } catch (Exception e) {
 189             Assert.assertTrue(e instanceof ExtendedNotFoundException);
 190         }
 191
 192         try {
 193             // 删除其中一个实例
 194             microServiceWrapper.deleteMicroServiceInstance("testService", "v2", "10.74.148.87", "8080");
 195             MicroServiceFullInfo microService = microServiceWrapper.getMicroServiceInstance("testService", "v2");
 196
 197             Set<Node> nodeSet = new HashSet<Node>();
 198             nodeSet.add(new Node("10.74.148.86", "8080"));
 199             Assert.assertEquals(nodeSet, microService.getNodes());
 200
 201             // 删除服务
 202             microServiceWrapper.deleteMicroServiceInstance("testService", "v2", "10.74.148.86", "8080");
 203         } catch (Exception e) {
 204             Assert.fail("throw exception means error occured!" + e.getMessage());
 205         }
 206
 207         try {
 208             microServiceWrapper.getMicroServiceInstance("testService", "v2");
 209             Assert.fail("should not process to here.");
 210         } catch (Exception e) {
 211             Assert.assertTrue(e instanceof ExtendedNotFoundException);
 212
 213         }
 214     }
 215
 216     @Test
 217     public void test_getAllVersion() {
 218         try {
 219             microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo(), false, "", "");
 220             microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo4version2(), false, "", "");
 221             Set<String> versionSet = new HashSet<String>();
 222             versionSet.add("v1");
 223             versionSet.add("v2");
 224             Assert.assertEquals(versionSet, microServiceWrapper.getAllVersion("testService"));
 225
 226
 227         } catch (Exception e) {
 228             Assert.fail("throw exception means error occured!" + e.getMessage());
 229         }
 230         try {
 231             microServiceWrapper.deleteMicroService4AllVersion("testService");
 232             Assert.assertEquals(0, microServiceWrapper.getAllVersion("testService").size());
 233         } catch (Exception e) {
 234             Assert.assertTrue(e instanceof ExtendedNotFoundException);
 235
 236         }
 237
 238     }
 239
 240     @Test
 241     public void test_getAllMicroServiceKey() {
 242         microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo(), false, "", "");
 243         microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo2(), false, "", "");
 244         Set<String> builder = new HashSet<String>();
 245         builder.add("testService");
 246         builder.add("testService2");
 247         Assert.assertEquals(builder, microServiceWrapper.getAllMicroServiceKey());
 248
 249
 250     }
 251
 252     private MicroServiceFullInfo buildMicroServiceFullInfo() {
 253         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 254         microServiceFullInfo.setServiceName("testService");
 255         microServiceFullInfo.setVersion("v1");
 256         microServiceFullInfo.setStatus("1");
 257         microServiceFullInfo.setUrl("/testService/v1");
 258         microServiceFullInfo.setVisualRange("0");
 259         microServiceFullInfo.setProtocol("HTTP");
 260         microServiceFullInfo.setEnable_ssl(false);
 261         Set<Node> nodeSet = new HashSet<>();
 262         nodeSet.add(new Node("10.74.148.88", "8080"));
 263         microServiceFullInfo.setNodes(nodeSet);
 264
 265         return microServiceFullInfo;
 266     }
 267
 268     private MicroServiceFullInfo buildMicroServiceFullInfo4version2() {
 269         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 270         microServiceFullInfo.setServiceName("testService");
 271         microServiceFullInfo.setVersion("v2");
 272         microServiceFullInfo.setStatus("1");
 273         microServiceFullInfo.setUrl("/testService/v1");
 274         microServiceFullInfo.setVisualRange("0");
 275         microServiceFullInfo.setProtocol("HTTP");
 276         microServiceFullInfo.setEnable_ssl(false);
 277         Set<Node> nodeSet = new HashSet<>();
 278         nodeSet.add(new Node("10.74.148.87", "8080"));
 279         nodeSet.add(new Node("10.74.148.86", "8080"));
 280         microServiceFullInfo.setNodes(nodeSet);
 281
 282         return microServiceFullInfo;
 283     }
 284
 285     private MicroServiceFullInfo buildMicroServiceFullInfo2() {
 286         MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo();
 287         microServiceFullInfo.setServiceName("testService2");
 288         microServiceFullInfo.setVersion("v1");
 289         microServiceFullInfo.setStatus("1");
 290         microServiceFullInfo.setUrl("/api/testService/v1");
 291         microServiceFullInfo.setVisualRange("1");
 292         microServiceFullInfo.setProtocol("REST");
 293         microServiceFullInfo.setEnable_ssl(true);
 294         Set<Node> nodeSet = new HashSet<>();
 295         nodeSet.add(new Node("10.74.148.89", "8080"));
 296         microServiceFullInfo.setNodes(nodeSet);
 297
 298         return microServiceFullInfo;
 299     }
 300
 301
 302 }