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

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