aai-core/src/test/java/org/onap/aai/parsers/query/GremlinPipelineTraversalTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 /*package org.onap.aai.parsers.query;
  22
  23 import static org.hamcrest.CoreMatchers.startsWith;
  24 import static org.junit.Assert.assertEquals;
  25
  26 import java.io.UnsupportedEncodingException;
  27 import java.net.URI;
  28
  29 import javax.ws.rs.core.MultivaluedHashMap;
  30 import javax.ws.rs.core.MultivaluedMap;
  31
  32 import org.junit.BeforeClass;
  33 import org.junit.Rule;
  34 import org.junit.Test;
  35 import org.junit.rules.ExpectedException;
  36
  37 import org.onap.aai.db.AAIProperties;
  38 import org.onap.aai.exceptions.AAIException;
  39 import org.onap.aai.introspection.LoaderFactory;
  40 import org.onap.aai.introspection.ModelType;
  41 import org.onap.aai.introspection.Version;
  42 import org.onap.aai.logging.LogLineBuilder;
  43 import org.onap.aai.serialization.engines.QueryStyle;
  44 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
  45 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  46
  47 import com.tinkerpop.gremlin.java.GremlinPipeline;
  48 import com.tinkerpop.pipes.IdentityPipe;
  49
  50 public class GremlinPipelineTraversalTest {
  51
  52         private TransactionalGraphEngine dbEngine =
  53                         new JanusGraphDBEngine(QueryStyle.GREMLINPIPELINE_TRAVERSAL,
  54                                 LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.v7, new LogLineBuilder("TEST", "TEST")),
  55                                 false);
  56
  57         private TransactionalGraphEngine dbEnginev6 =
  58                         new JanusGraphDBEngine(QueryStyle.GREMLINPIPELINE_TRAVERSAL,
  59                                 LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.v6, new LogLineBuilder("TEST", "TEST")),
  60                                 false);
  61
  62         @Rule
  63         public ExpectedException thrown = ExpectedException.none();
  64
  65         @BeforeClass
  66         public static void configure() {
  67                 System.setProperty("AJSC_HOME", ".");
  68                 System.setProperty("BUNDLECONFIG_DIR", "bundleconfig-local");
  69         }
  70
  71         @Test
  72     public void parentQuery() throws UnsupportedEncodingException, AAIException {
  73                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1").build();
  74
  75                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
  76
  77                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V().has("physical-location-id", "key1").has("aai-node-type", "complex");
  78                 assertEquals(
  79                                 "gremlin query should be " + expected.toString(),
  80                                 expected.toString(),
  81                                 query.getQueryBuilder().getQuery().toString());
  82                 assertEquals(
  83                                 "parent gremlin query should be equal to normal query",
  84                                 expected.toString(),
  85                                 query.getQueryBuilder().getParentQuery().toString());
  86                 assertEquals(
  87                                 "result type should be complex",
  88                                 "complex",
  89                                 query.getResultType());
  90                 assertEquals(
  91                                 "result type should be empty",
  92                                 "",
  93                                 query.getParentResultType());
  94                 assertEquals("dependent",false, query.isDependent());
  95
  96
  97     }
  98
  99         @Test
 100     public void childQuery() throws UnsupportedEncodingException, AAIException {
 101                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/ctag-pools/ctag-pool/key2/key3").build();
 102                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 103                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 104                                 .has("physical-location-id", "key1").has("aai-node-type", "complex")
 105                                 .in("org.onap.relationships.inventory.BelongsTo")
 106                                 .has("target-pe", "key2").has("availability-zone-name", "key3");
 107                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 108                                 .has("physical-location-id", "key1").has("aai-node-type", "complex");
 109                 assertEquals(
 110                                 "gremlin query should be " + expected.toString(),
 111                                 expected.toString(),
 112                                 query.getQueryBuilder().getQuery().toString());
 113                 assertEquals(
 114                                 "parent gremlin query should be equal the query for complex",
 115                                 expectedParent.toString(),
 116                                 query.getQueryBuilder().getParentQuery().toString());
 117                 assertEquals(
 118                                 "result type should be complex",
 119                                 "complex",
 120                                 query.getParentResultType());
 121                 assertEquals(
 122                                 "result type should be ctag-pool",
 123                                 "ctag-pool",
 124                                 query.getResultType());
 125                 assertEquals("dependent",true, query.isDependent());
 126
 127
 128     }
 129
 130         @Test
 131     public void namingExceptions() throws UnsupportedEncodingException, AAIException {
 132                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags/cvlan-tag/655").build();
 133                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 134                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 135                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 136                                 .in("org.onap.relationships.inventory.BelongsTo")
 137                                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 138                                 .has("cvlan-tag", 655);
 139                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 140                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 141                                 .in("org.onap.relationships.inventory.BelongsTo")
 142                                 .has("interface-id", "key2");
 143                 assertEquals(
 144                                 "gremlin query should be " + expected.toString(),
 145                                 expected.toString(),
 146                                 query.getQueryBuilder().getQuery().toString());
 147                 assertEquals(
 148                                 "parent gremlin query should be equal the query for port group",
 149                                 expectedParent.toString(),
 150                                 query.getQueryBuilder().getParentQuery().toString());
 151                 assertEquals(
 152                                 "result type should be cvlan-tag",
 153                                 "cvlan-tag",
 154                                 query.getResultType());
 155                 assertEquals(
 156                                 "result type should be port-group",
 157                                 "port-group",
 158                                 query.getParentResultType());
 159                 assertEquals(
 160                                 "contaner type should be empty",
 161                                 "",
 162                                 query.getContainerType());
 163                 assertEquals("dependent",true, query.isDependent());
 164
 165
 166     }
 167
 168         @Test
 169     public void getAll() throws UnsupportedEncodingException, AAIException {
 170                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 171                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 172                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 173                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 174                                 .in("org.onap.relationships.inventory.BelongsTo")
 175                                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 176                                 .has("aai-node-type", "cvlan-tag");
 177                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 178                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 179                                 .in("org.onap.relationships.inventory.BelongsTo")
 180                                 .has("interface-id", "key2");
 181                 assertEquals(
 182                                 "gremlin query should be " + expected.toString(),
 183                                 expected.toString(),
 184                                 query.getQueryBuilder().getQuery().toString());
 185                 assertEquals(
 186                                 "parent gremlin query should be equal the query for port group",
 187                                 expectedParent.toString(),
 188                                 query.getQueryBuilder().getParentQuery().toString());
 189                 assertEquals(
 190                                 "result type should be port-group",
 191                                 "port-group",
 192                                 query.getParentResultType());
 193                 assertEquals(
 194                                 "result type should be cvlan-tag",
 195                                 "cvlan-tag",
 196                                 query.getResultType());
 197                 assertEquals(
 198                                 "container type should be cvlan-tags",
 199                                 "cvlan-tags",
 200                                 query.getContainerType());
 201                 assertEquals("dependent",true, query.isDependent());
 202
 203
 204     }
 205
 206         @Test
 207         public void getItemAffectedByDefaultCloudRegion() throws UnsupportedEncodingException, AAIException {
 208                 URI uri = UriBuilder.fromPath("cloud-infrastructure/tenants/tenant/key1/vservers/vserver/key2/l-interfaces/l-interface/key3").build();
 209                 QueryParser query = dbEnginev6.getQueryBuilder().createQueryFromURI(uri);
 210                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 211                                 .has("cloud-owner", "att-aic").has("aai-node-type", "cloud-region")
 212                                 .has("cloud-region-id", "AAIAIC25")
 213                                 .in("org.onap.relationships.inventory.BelongsTo")
 214                                 .has("tenant-id", "key1")
 215                                 .in("org.onap.relationships.inventory.BelongsTo")
 216                                 .has("vserver-id", "key2")
 217                                 .in("org.onap.relationships.inventory.BelongsTo")
 218                                 .has("interface-name", "key3");
 219                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 220                                 .has("cloud-owner", "att-aic").has("aai-node-type", "cloud-region")
 221                                 .has("cloud-region-id", "AAIAIC25")
 222                                 .in("org.onap.relationships.inventory.BelongsTo")
 223                                 .has("tenant-id", "key1")
 224                                 .in("org.onap.relationships.inventory.BelongsTo")
 225                                 .has("vserver-id", "key2");
 226                 assertEquals(
 227                                 "gremlin query should be " + expected.toString(),
 228                                 expected.toString(),
 229                                 query.getQueryBuilder().getQuery().toString());
 230                 assertEquals(
 231                                 "parent gremlin query should be equal the query for vserver",
 232                                 expectedParent.toString(),
 233                                 query.getQueryBuilder().getParentQuery().toString());
 234                 assertEquals(
 235                                 "result type should be vserver",
 236                                 "vserver",
 237                                 query.getParentResultType());
 238                 assertEquals(
 239                                 "result type should be l-interface",
 240                                 "l-interface",
 241                                 query.getResultType());
 242                 assertEquals(
 243                                 "container type should be empty",
 244                                 "",
 245                                 query.getContainerType());
 246                 assertEquals("dependent",true, query.isDependent());
 247
 248         }
 249
 250         @Test
 251         public void getViaQueryParam() throws UnsupportedEncodingException, AAIException {
 252                 URI uri = UriBuilder.fromPath("cloud-infrastructure/tenants/tenant").build();
 253                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 254
 255                                 .has("tenant-name", "Tenant1");
 256
 257                                 .has("tenant-name", "Tenant2");
 258
 259                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 260                                 .has("cloud-owner", "att-aic").has("aai-node-type", "cloud-region")
 261                                 .has("cloud-region-id", "AAIAIC25");
 262
 263                 assertEquals(
 264                                 "gremlin query should be " + expected.toString(),
 265                                 expected.toString(),
 266                                 query.getQueryBuilder().getQuery().toString());
 267                 assertEquals(
 268                                 "parent gremlin query should be equal the query for cloud-region",
 269                                 expectedParent.toString(),
 270                                 query.getQueryBuilder().getParentQuery().toString());
 271                 assertEquals(
 272                                 "result type should be cloud-region",
 273                                 "cloud-region",
 274                                 query.getParentResultType());
 275                 assertEquals(
 276                                 "result type should be tenant",
 277                                 "tenant",
 278                                 query.getResultType());
 279                 assertEquals(
 280                                 "container type should be empty",
 281                                 "",
 282                                 query.getContainerType());
 283                 assertEquals("dependent",true, query.isDependent());
 284
 285         }
 286
 287         @Test
 288         public void getPluralViaQueryParam() throws UnsupportedEncodingException, AAIException {
 289                 URI uri = UriBuilder.fromPath("network/vnfcs").build();
 290                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 291                 map.putSingle("prov-status", "up");
 292                 QueryParser query = dbEnginev6.getQueryBuilder().createQueryFromURI(uri, map);
 293                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 294                                 .has("aai-node-type", "vnfc")
 295                                 .has("prov-status", "up");
 296
 297                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 298                                 .has("aai-node-type", "vnfc");
 299
 300                 assertEquals(
 301                                 "gremlin query should be " + expected.toString(),
 302                                 expected.toString(),
 303                                 query.getQueryBuilder().getQuery().toString());
 304                 assertEquals(
 305                                 "parent",
 306                                 expectedParent.toString(),
 307                                 query.getQueryBuilder().getParentQuery().toString());
 308                 assertEquals(
 309                                 "parent result type should be empty",
 310                                 "",
 311                                 query.getParentResultType());
 312                 assertEquals(
 313                                 "result type should be vnfc",
 314                                 "vnfc",
 315                                 query.getResultType());
 316                 assertEquals(
 317                                 "container type should be empty",
 318                                 "vnfcs",
 319                                 query.getContainerType());
 320                 assertEquals("dependent",true, query.isDependent());
 321
 322         }
 323
 324         @Test
 325     public void getAllQueryParamNamingException() throws UnsupportedEncodingException, AAIException {
 326                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 327                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 328                 map.putSingle("cvlan-tag", "333");
 329                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 330
 331                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 332                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 333                                 .in("org.onap.relationships.inventory.BelongsTo")
 334                                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 335                                 .has("aai-node-type", "cvlan-tag")
 336                                 .has("cvlan-tag", 333);
 337                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 338                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 339                                 .in("org.onap.relationships.inventory.BelongsTo")
 340                                 .has("interface-id", "key2");
 341                 assertEquals(
 342                                 "gremlin query should be " + expected.toString(),
 343                                 expected.toString(),
 344                                 query.getQueryBuilder().getQuery().toString());
 345                 assertEquals(
 346                                 "parent gremlin query should be equal the query for port group",
 347                                 expectedParent.toString(),
 348                                 query.getQueryBuilder().getParentQuery().toString());
 349                 assertEquals(
 350                                 "result type should be port-group",
 351                                 "port-group",
 352                                 query.getParentResultType());
 353                 assertEquals(
 354                                 "result type should be cvlan-tag",
 355                                 "cvlan-tag",
 356                                 query.getResultType());
 357                 assertEquals(
 358                                 "container type should be cvlan-tags",
 359                                 "cvlan-tags",
 360                                 query.getContainerType());
 361                 assertEquals("dependent",true, query.isDependent());
 362
 363
 364     }
 365
 366         @Test
 367     public void abstractType() throws UnsupportedEncodingException, AAIException {
 368                 URI uri = UriBuilder.fromPath("vnf/key1").build();
 369
 370                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 371
 372                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 373                                 .has("vnf-id", "key1").or(
 374                                                 new GremlinPipeline(new IdentityPipe()).has(AAIProperties.NODE_TYPE, "vce"),
 375                                                 new GremlinPipeline(new IdentityPipe()).has(AAIProperties.NODE_TYPE, "generic-vnf"));
 376
 377                 GremlinPipeline expectedParent = expected;
 378                 assertEquals(
 379                                 "gremlin query should be " + expected.toString(),
 380                                 expected.toString(),
 381                                 query.getQueryBuilder().getQuery().toString());
 382                 assertEquals(
 383                                 "parent gremlin query should be equal the query for port group",
 384                                 expectedParent.toString(),
 385                                 query.getQueryBuilder().getParentQuery().toString());
 386                 assertEquals(
 387                                 "result type should be empty",
 388                                 "",
 389                                 query.getParentResultType());
 390                 assertEquals(
 391                                 "result type should be vnf",
 392                                 "vnf",
 393                                 query.getResultType());
 394
 395                 assertEquals("dependent",false, query.isDependent());
 396
 397
 398     }
 399
 400         @Test
 401     public void nonParentAbstractType() throws UnsupportedEncodingException, AAIException {
 402                 URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers/pserver/key2/vnf/key1").build();
 403                 thrown.expect(AAIException.class);
 404                 thrown.expectMessage(startsWith("AAI_3001"));
 405                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 406
 407
 408
 409     }
 410
 411         @Test
 412         public void parentAbstractTypeWithNesting() throws UnsupportedEncodingException, AAIException {
 413                 URI uri = UriBuilder.fromPath("vnf/key1/vf-modules/vf-module/key2").build();
 414
 415                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 416
 417                 GremlinPipeline expected = new GremlinPipeline(new IdentityPipe()).V()
 418                                 .has("vnf-id", "key1").or(
 419                                                 new GremlinPipeline(new IdentityPipe()).has(AAIProperties.NODE_TYPE, "vce"),
 420                                                 new GremlinPipeline(new IdentityPipe()).has(AAIProperties.NODE_TYPE, "generic-vnf"))
 421                                 .outE().has("isParent", true).inV().has("vf-module-id", "key2");
 422                 GremlinPipeline expectedParent = new GremlinPipeline(new IdentityPipe()).V()
 423                                 .has("vnf-id", "key1").or(
 424                                                 new GremlinPipeline(new IdentityPipe()).has(AAIProperties.NODE_TYPE, "vce"),
 425                                                 new GremlinPipeline(new IdentityPipe()).has(AAIProperties.NODE_TYPE, "generic-vnf"));
 426                 assertEquals(
 427                                 "gremlin query should be " + expected.toString(),
 428                                 expected.toString(),
 429                                 query.getQueryBuilder().getQuery().toString());
 430                 assertEquals(
 431                                 "parent gremlin query should be equal the query for ",
 432                                 expectedParent.toString(),
 433                                 query.getQueryBuilder().getParentQuery().toString());
 434                 assertEquals(
 435                                 "result type should be vnf",
 436                                 "vnf",
 437                                 query.getParentResultType());
 438                 assertEquals(
 439                                 "result type should be vf-module",
 440                                 "vf-module",
 441                                 query.getResultType());
 442
 443                 assertEquals("dependent",true, query.isDependent());
 444
 445         }
 446 }
 447 */