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     }
 236
 237     @Test
 238     public void test_getVisualRangeByRouter() {
 239         Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0|1"));
 240         Assert.assertEquals("1", RouteUtil.getVisualRangeByRouter("1"));
 241         Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0"));
 242
 243
 244     }
 245
 246     @Test
 247     public void test_getVisualRangeByRouter_muti() {
 248         PowerMockito.mockStatic(System.class);
 249         PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("lab1:val,visualRange:0|1");
 250         ConfigUtil.getInstance().initRouteLabelsMatches();
 251         Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0|1"));
 252     }
 253
 254     @Test
 255     public void test_checkRouterInfoFormat_url() {
 256         RouteInfo routeInfo = new RouteInfo();
 257         routeInfo.setServiceName("name");
 258         routeInfo.setUrl("url");
 259         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 260
 261         try {
 262             RouteUtil.checkRouterInfoFormat(routeInfo);
 263         } catch (Exception e) {
 264             Assert.assertTrue(e instanceof UnprocessableEntityException);
 265         }
 266     }
 267
 268     @Test
 269     public void test_checkRouterInfoFormat_visualRangeRange() {
 270         RouteInfo routeInfo = new RouteInfo();
 271         routeInfo.setServiceName("name");
 272         routeInfo.setUrl("/url");
 273         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 274         routeInfo.setVisualRange("2");
 275
 276         try {
 277             RouteUtil.checkRouterInfoFormat(routeInfo);
 278         } catch (Exception e) {
 279             Assert.assertTrue(e instanceof UnprocessableEntityException);
 280         }
 281     }
 282
 283
 284     @Test
 285     public void test_checkRouterInfoFormat_controlRangeMatches() {
 286         RouteInfo routeInfo = new RouteInfo();
 287         routeInfo.setServiceName("name");
 288         routeInfo.setUrl("/url");
 289         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 290         routeInfo.setVisualRange("0");
 291         routeInfo.setControl("3");
 292
 293         try {
 294             RouteUtil.checkRouterInfoFormat(routeInfo);
 295         } catch (Exception e) {
 296             Assert.assertTrue(e instanceof UnprocessableEntityException);
 297         }
 298     }
 299
 300     @Test
 301     public void test_checkRouterInfoFormat_statusRangeMatches() {
 302         RouteInfo routeInfo = new RouteInfo();
 303         routeInfo.setServiceName("name");
 304         routeInfo.setUrl("/url");
 305         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 306         routeInfo.setVisualRange("0");
 307         routeInfo.setControl("0");
 308         routeInfo.setStatus("3");
 309
 310         try {
 311             RouteUtil.checkRouterInfoFormat(routeInfo);
 312         } catch (Exception e) {
 313             Assert.assertTrue(e instanceof UnprocessableEntityException);
 314         }
 315     }
 316
 317
 318     @Test
 319     public void test_checkRouterInfoFormat_useOwnUpstreamRangeMatches() {
 320         RouteInfo routeInfo = new RouteInfo();
 321         routeInfo.setServiceName("name");
 322         routeInfo.setUrl("/url");
 323         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88", "8080")});
 324         routeInfo.setVisualRange("0");
 325         routeInfo.setControl("0");
 326         routeInfo.setStatus("0");
 327         routeInfo.setUseOwnUpstream("3");
 328
 329         try {
 330             RouteUtil.checkRouterInfoFormat(routeInfo);
 331         } catch (Exception e) {
 332             Assert.assertTrue(e instanceof UnprocessableEntityException);
 333         }
 334     }
 335
 336     @Test
 337     public void test_checkRouterInfoFormat_ip() {
 338         RouteInfo routeInfo = new RouteInfo();
 339         routeInfo.setServiceName("name");
 340         routeInfo.setUrl("/url");
 341         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88.6", "8080")});
 342         routeInfo.setVisualRange("0");
 343         routeInfo.setControl("0");
 344         routeInfo.setStatus("0");
 345         routeInfo.setUseOwnUpstream("1");
 346
 347         try {
 348             RouteUtil.checkRouterInfoFormat(routeInfo);
 349         } catch (Exception e) {
 350             Assert.assertTrue(e instanceof UnprocessableEntityException);
 351         }
 352     }
 353
 354
 355     @Test
 356     public void test_checkRouterInfoFormat_port() {
 357         RouteInfo routeInfo = new RouteInfo();
 358         routeInfo.setServiceName("name");
 359         routeInfo.setUrl("/url");
 360         routeInfo.setServers(new RouteServer[] {new RouteServer("10.74.148.88.6", "757577")});
 361         routeInfo.setVisualRange("0");
 362         routeInfo.setControl("0");
 363         routeInfo.setStatus("0");
 364         routeInfo.setUseOwnUpstream("1");
 365
 366         try {
 367             RouteUtil.checkRouterInfoFormat(routeInfo);
 368         } catch (Exception e) {
 369             Assert.assertTrue(e instanceof UnprocessableEntityException);
 370         }
 371     }
 372
 373
 374
 375 }