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