apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RouteUtilTest.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.util;
  15
  16 import java.util.HashSet;
  17 import java.util.Set;
  18
  19 import org.junit.Assert;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.onap.msb.apiroute.api.MicroServiceFullInfo;
  23 import org.onap.msb.apiroute.api.Node;
  24 import org.onap.msb.apiroute.api.RouteInfo;
  25 import org.onap.msb.apiroute.api.RouteServer;
  26 import org.onap.msb.apiroute.api.exception.UnprocessableEntityException;
  27 import org.powermock.api.mockito.PowerMockito;
  28 import org.powermock.core.classloader.annotations.PrepareForTest;
  29 import org.powermock.modules.junit4.PowerMockRunner;
  30 import org.powermock.core.classloader.annotations.PowerMockIgnore;
  31
  32 @RunWith(PowerMockRunner.class)
  33 @PrepareForTest({ConfigUtil.class})
  34 @PowerMockIgnore("jdk.internal.reflect.*")
  35 public class RouteUtilTest {
  36
  37     @Test
  38     public void test_getPrefixedKey() {
  39         Assert.assertEquals("msb:routing:test:v1", RouteUtil.getPrefixedKey("", "test", "v1"));
  40         Assert.assertEquals("msb:5656:test:v1", RouteUtil.getPrefixedKey("5656", "test", "v1"));
  41
  42     }
  43
  44     @Test
  45     public void test_getPrefixedKey4Host() {
  46         Assert.assertEquals("msb:host:test:v1", RouteUtil.getPrefixedKey4Host("test", "v1"));
  47
  48     }
  49
  50
  51
  52     @Test
  53     public void test_checkRouteWay() {
  54         try {
  55             RouteUtil.checkRouteWay("ipp");
  56         } catch (Exception e) {
  57             Assert.assertTrue(e instanceof UnprocessableEntityException);
  58         }
  59
  60     }
  61
  62     @Test
  63     public void test_checkServiceNameAndVersion() {
  64         try {
  65             RouteUtil.checkServiceNameAndVersion("", "v1");
  66         } catch (Exception e) {
  67             Assert.assertTrue(e instanceof UnprocessableEntityException);
  68         }
  69
  70         try {
  71             RouteUtil.checkServiceNameAndVersion("test", "ve1");
  72         } catch (Exception e) {
  73             Assert.assertTrue(e instanceof UnprocessableEntityException);
  74         }
  75     }
  76
  77     @Test
  78     public void test_checkServiceStatus() {
  79         try {
  80             RouteUtil.checkServiceStatus("2");
  81         } catch (Exception e) {
  82             Assert.assertTrue(e instanceof UnprocessableEntityException);
  83         }
  84     }
  85
  86     @Test
  87     public void test_checkRouterInfoFormat() {
  88         RouteInfo routeInfo = new RouteInfo();
  89
  90         try {
  91             RouteUtil.checkRouterInfoFormat(routeInfo);
  92         } catch (Exception e) {
  93             Assert.assertTrue(e instanceof UnprocessableEntityException);
  94         }
  95     }
  96
  97     @Test
  98     public void test_checkMicroServiceInfoFormat() {
  99         MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
 100
 101         try {
 102             RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, "");
 103         } catch (Exception e) {
 104             Assert.assertTrue(e instanceof UnprocessableEntityException);
 105         }
 106     }
 107
 108     @Test
 109     public void test_checkMicroServiceInfoFormat_ip() {
 110         MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
 111         microServiceInfo.setServiceName("name");
 112         microServiceInfo.setProtocol("REST");
 113         Set<Node> nodeSet = new HashSet<>();
 114         nodeSet.add(new Node("10.74.148.88.22", "8080"));
 115         microServiceInfo.setNodes(nodeSet);
 116
 117         try {
 118             RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, "");
 119         } catch (Exception e) {
 120             Assert.assertTrue(e instanceof UnprocessableEntityException);
 121         }
 122     }
 123
 124     @Test
 125     public void test_checkMicroServiceInfoFormat_port() {
 126         MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
 127         microServiceInfo.setServiceName("name");
 128         microServiceInfo.setProtocol("REST");
 129         Set<Node> nodeSet = new HashSet<>();
 130         nodeSet.add(new Node("10.74.148.88.22", "808770"));
 131         microServiceInfo.setNodes(nodeSet);
 132
 133         try {
 134             RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, "");
 135         } catch (Exception e) {
 136             Assert.assertTrue(e instanceof UnprocessableEntityException);
 137         }
 138     }
 139
 140     @Test
 141     public void test_checkMicroServiceInfoFormat_version() {
 142         MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
 143         microServiceInfo.setServiceName("name");
 144         microServiceInfo.setProtocol("REST");
 145         Set<Node> nodeSet = new HashSet<>();
 146         nodeSet.add(new Node("", "8089"));
 147         microServiceInfo.setNodes(nodeSet);
 148         microServiceInfo.setVersion("cv2");
 149
 150         try {
 151             RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, "10.74.55.36");
 152         } catch (Exception e) {
 153             Assert.assertTrue(e instanceof UnprocessableEntityException);
 154         }
 155     }
 156
 157     @Test
 158     public void test_checkMicroServiceInfoFormat_url() {
 159         MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
 160         microServiceInfo.setServiceName("name");
 161         microServiceInfo.setProtocol("REST");
 162         Set<Node> nodeSet = new HashSet<>();
 163         nodeSet.add(new Node("", "8089"));
 164         microServiceInfo.setNodes(nodeSet);
 165         microServiceInfo.setVersion("v2");
 166         microServiceInfo.setUrl("url");
 167
 168         try {
 169             RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, "10.74.55.36");
 170         } catch (Exception e) {
 171             Assert.assertTrue(e instanceof UnprocessableEntityException);
 172         }
 173     }
 174
 175     @Test
 176     public void test_checkMicroServiceInfoFormat_protocol() {
 177         MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
 178         microServiceInfo.setServiceName("name");
 179         microServiceInfo.setProtocol("REST2");
 180         Set<Node> nodeSet = new HashSet<>();
 181         nodeSet.add(new Node("", "8089"));
 182         microServiceInfo.setNodes(nodeSet);
 183         microServiceInfo.setVersion("v2");
 184         microServiceInfo.setUrl("/url");
 185
 186         try {
 187             RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, "10.74.55.36");
 188         } catch (Exception e) {
 189             Assert.assertTrue(e instanceof UnprocessableEntityException);
 190         }
 191     }
 192
 193     @Test
 194     public void test_getAPIRedisPrefixedKey() {
 195         Assert.assertEquals("msb:20081:api:testApi:v1",
 196                         RouteUtil.getAPIRedisPrefixedKey("testApi", "v1", "testHost", "20081", "ip"));
 197         Assert.assertEquals("msb:routing:api:testApi:v1",
 198                         RouteUtil.getAPIRedisPrefixedKey("testApi", "v1", "testHost", "", "ip"));
 199         Assert.assertEquals("msb:host:testHost:api:testApi:v1",
 200                         RouteUtil.getAPIRedisPrefixedKey("testApi", "v1", "testHost", "20081", "domain"));
 201     }
 202
 203     @Test
 204     public void test_getRedisPrefixedKey() {
 205         Assert.assertEquals("msb:20081:custom:/testName/v1", RouteUtil.getRedisPrefixedKey(RouteUtil.CUSTOMROUTE,
 206                         "/testName/v1", "testHost", "20081", "ip"));
 207         Assert.assertEquals("msb:routing:custom:/testName/v1",
 208                         RouteUtil.getRedisPrefixedKey(RouteUtil.CUSTOMROUTE, "/testName/v1", "testHost", "", "ip"));
 209         Assert.assertEquals("msb:host:testHost:custom:/testName/v1", RouteUtil
 210                         .getRedisPrefixedKey(RouteUtil.CUSTOMROUTE, "/testName/v1", "testHost", "20081", "domain"));
 211
 212         Assert.assertEquals("msb:20081:iui:testName",
 213                         RouteUtil.getRedisPrefixedKey(RouteUtil.IUIROUTE, "testName", "testHost", "20081", "ip"));
 214         Assert.assertEquals("msb:routing:iui:testName",
 215                         RouteUtil.getRedisPrefixedKey(RouteUtil.IUIROUTE, "testName", "testHost", "", "ip"));
 216         Assert.assertEquals("msb:host:testHost:iui:testName",
 217                         RouteUtil.getRedisPrefixedKey(RouteUtil.IUIROUTE, "testName", "testHost", "20081", "domain"));
 218     }
 219
 220     @Test
 221     public void test_getMutiRedisKey() {
 222         Assert.assertEquals("msb:[^h]*:api:*", RouteUtil.getMutiRedisKey(RouteUtil.APIROUTE, "ip"));
 223         Assert.assertEquals("msb:[^h]*:iui:*", RouteUtil.getMutiRedisKey(RouteUtil.IUIROUTE, "ip"));
 224         Assert.assertEquals("msb:[^h]*:custom:*", RouteUtil.getMutiRedisKey(RouteUtil.CUSTOMROUTE, "ip"));
 225
 226         Assert.assertEquals("msb:host:*:api:*", RouteUtil.getMutiRedisKey(RouteUtil.APIROUTE, "domain"));
 227         Assert.assertEquals("msb:host:*:iui:*", RouteUtil.getMutiRedisKey(RouteUtil.IUIROUTE, "domain"));
 228         Assert.assertEquals("msb:host:*:custom:*", RouteUtil.getMutiRedisKey(RouteUtil.CUSTOMROUTE, "domain"));
 229     }
 230
 231     @Test
 232     public void test_getRouteNameByns() {
 233         Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName", "", ""));
 234         Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName-ns", "", "ns"));
 235         Assert.assertEquals("serviceName-ns", RouteUtil.getRouteNameByns("serviceName-ns-ns", "", "ns"));
 236         Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName", "", "default"));
 237         Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName-v1-ns", "v1", "ns"));
 238     }
 239
 240     @Test
 241     public void test_getVisualRangeByRouter() {
 242         Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0|1"));
 243         Assert.assertEquals("1", RouteUtil.getVisualRangeByRouter("1"));
 244         Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0"));
 245
 246
 247     }
 248
 249     @Test
 250     public void test_getVisualRangeByRouter_muti() {
 251         PowerMockito.mockStatic(System.class);
 252         PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("lab1:val,visualRange:0|1");
 253         ConfigUtil.getInstance().initRouteLabelsMatches();
 254         Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0|1"));
 255     }
 256
 257     @Test
 258     public void test_checkRouterInfoFormat_url() {
 259         RouteInfo routeInfo = new RouteInfo();
 260         routeInfo.setServiceName("name");
 261         routeInfo.setUrl("url");
 262         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 263
 264         try {
 265             RouteUtil.checkRouterInfoFormat(routeInfo);
 266         } catch (Exception e) {
 267             Assert.assertTrue(e instanceof UnprocessableEntityException);
 268         }
 269     }
 270
 271     @Test
 272     public void test_checkRouterInfoFormat_visualRangeRange() {
 273         RouteInfo routeInfo = new RouteInfo();
 274         routeInfo.setServiceName("name");
 275         routeInfo.setUrl("/url");
 276         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 277         routeInfo.setVisualRange("2");
 278
 279         try {
 280             RouteUtil.checkRouterInfoFormat(routeInfo);
 281         } catch (Exception e) {
 282             Assert.assertTrue(e instanceof UnprocessableEntityException);
 283         }
 284     }
 285
 286
 287     @Test
 288     public void test_checkRouterInfoFormat_controlRangeMatches() {
 289         RouteInfo routeInfo = new RouteInfo();
 290         routeInfo.setServiceName("name");
 291         routeInfo.setUrl("/url");
 292         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 293         routeInfo.setVisualRange("0");
 294         routeInfo.setControl("3");
 295
 296         try {
 297             RouteUtil.checkRouterInfoFormat(routeInfo);
 298         } catch (Exception e) {
 299             Assert.assertTrue(e instanceof UnprocessableEntityException);
 300         }
 301     }
 302
 303     @Test
 304     public void test_checkRouterInfoFormat_statusRangeMatches() {
 305         RouteInfo routeInfo = new RouteInfo();
 306         routeInfo.setServiceName("name");
 307         routeInfo.setUrl("/url");
 308         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 309         routeInfo.setVisualRange("0");
 310         routeInfo.setControl("0");
 311         routeInfo.setStatus("3");
 312
 313         try {
 314             RouteUtil.checkRouterInfoFormat(routeInfo);
 315         } catch (Exception e) {
 316             Assert.assertTrue(e instanceof UnprocessableEntityException);
 317         }
 318     }
 319
 320
 321     @Test
 322     public void test_checkRouterInfoFormat_useOwnUpstreamRangeMatches() {
 323         RouteInfo routeInfo = new RouteInfo();
 324         routeInfo.setServiceName("name");
 325         routeInfo.setUrl("/url");
 326         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 327         routeInfo.setVisualRange("0");
 328         routeInfo.setControl("0");
 329         routeInfo.setStatus("0");
 330         routeInfo.setUseOwnUpstream("3");
 331
 332         try {
 333             RouteUtil.checkRouterInfoFormat(routeInfo);
 334         } catch (Exception e) {
 335             Assert.assertTrue(e instanceof UnprocessableEntityException);
 336         }
 337     }
 338
 339     @Test
 340     public void test_checkRouterInfoFormat_ip() {
 341         RouteInfo routeInfo = new RouteInfo();
 342         routeInfo.setServiceName("name");
 343         routeInfo.setUrl("/url");
 344         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88.6", "8080")});
 345         routeInfo.setVisualRange("0");
 346         routeInfo.setControl("0");
 347         routeInfo.setStatus("0");
 348         routeInfo.setUseOwnUpstream("1");
 349
 350         try {
 351             RouteUtil.checkRouterInfoFormat(routeInfo);
 352         } catch (Exception e) {
 353             Assert.assertTrue(e instanceof UnprocessableEntityException);
 354         }
 355     }
 356
 357
 358     @Test
 359     public void test_checkRouterInfoFormat_port() {
 360         RouteInfo routeInfo = new RouteInfo();
 361         routeInfo.setServiceName("name");
 362         routeInfo.setUrl("/url");
 363         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88.6", "757577")});
 364         routeInfo.setVisualRange("0");
 365         routeInfo.setControl("0");
 366         routeInfo.setStatus("0");
 367         routeInfo.setUseOwnUpstream("1");
 368
 369         try {
 370             RouteUtil.checkRouterInfoFormat(routeInfo);
 371         } catch (Exception e) {
 372             Assert.assertTrue(e instanceof UnprocessableEntityException);
 373         }
 374     }
 375
 376
 377
 378 }