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

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 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 package org.onap.aai.parsers.query;
  21
  22 import org.apache.tinkerpop.gremlin.process.traversal.P;
  23 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  24 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  25 import org.apache.tinkerpop.gremlin.structure.Vertex;
  26 import org.junit.Before;
  27 import org.junit.Rule;
  28 import org.junit.Test;
  29 import org.junit.rules.ExpectedException;
  30 import org.junit.runner.RunWith;
  31 import org.junit.runners.Parameterized;
  32 import org.onap.aai.AAISetup;
  33 import org.onap.aai.DataLinkSetup;
  34 import org.onap.aai.db.props.AAIProperties;
  35 import org.onap.aai.exceptions.AAIException;
  36 import org.onap.aai.introspection.ModelType;
  37 import org.onap.aai.rest.RestTokens;
  38 import org.onap.aai.serialization.engines.QueryStyle;
  39 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
  40 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  41 import org.springframework.test.annotation.DirtiesContext;
  42
  43 import javax.ws.rs.core.MultivaluedHashMap;
  44 import javax.ws.rs.core.MultivaluedMap;
  45 import javax.ws.rs.core.UriBuilder;
  46 import java.io.UnsupportedEncodingException;
  47 import java.net.URI;
  48 import java.util.ArrayList;
  49 import java.util.Arrays;
  50 import java.util.Collection;
  51 import java.util.List;
  52
  53 import static org.hamcrest.CoreMatchers.containsString;
  54 import static org.hamcrest.Matchers.hasProperty;
  55 import static org.hamcrest.Matchers.is;
  56 import static org.junit.Assert.assertEquals;
  57
  58 @RunWith(value = Parameterized.class)
  59 @DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
  60 public class GraphTraversalTest extends DataLinkSetup {
  61
  62         private TransactionalGraphEngine dbEngine;
  63         private TransactionalGraphEngine dbEngineDepthVersion;
  64
  65         @Parameterized.Parameter(value = 0)
  66         public QueryStyle queryStyle;
  67
  68         @Parameterized.Parameters(name = "QueryStyle.{0}")
  69         public static Collection<Object[]> data() {
  70                 return Arrays.asList(new Object[][]{
  71                                 {QueryStyle.TRAVERSAL},
  72                                 {QueryStyle.TRAVERSAL_URI}
  73                 });
  74         }
  75
  76         @Rule public ExpectedException thrown = ExpectedException.none();
  77
  78
  79         /**
  80          * Configure.
  81          * @throws Exception
  82          * @throws SecurityException
  83          * @throws NoSuchFieldException
  84          */
  85         @Before
  86         public void configure() throws Exception {
  87                 dbEngine =
  88                                 new JanusGraphDBEngine(queryStyle,
  89                                         loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDefaultVersion()),
  90                                         false);
  91
  92                 dbEngineDepthVersion =
  93                                 new JanusGraphDBEngine(queryStyle,
  94                                         loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDepthVersion()),
  95                                         false);
  96         }
  97
  98         /**
  99          * Parent query.
 100          *
 101          * @throws UnsupportedEncodingException the unsupported encoding exception
 102          * @throws AAIException the AAI exception
 103          */
 104         @Test
 105     public void parentQuery() throws UnsupportedEncodingException, AAIException {
 106                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1").build();
 107
 108                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 109
 110                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start().has("physical-location-id", "key1").has("aai-node-type", "complex");
 111                 assertEquals(
 112                                 "gremlin query should be " + expected.toString(),
 113                                 expected.toString(),
 114                                 query.getQueryBuilder().getQuery().toString());
 115                 assertEquals(
 116                                 "parent gremlin query should be equal to normal query",
 117                                 expected.toString(),
 118                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 119                 assertEquals(
 120                                 "result type should be complex",
 121                                 "complex",
 122                                 query.getResultType());
 123                 assertEquals(
 124                                 "result type should be empty",
 125                                 "",
 126                                 query.getParentResultType());
 127                 assertEquals("dependent",false, query.isDependent());
 128
 129
 130     }
 131
 132         /**
 133          * Child query.
 134          *
 135          * @throws UnsupportedEncodingException the unsupported encoding exception
 136          * @throws AAIException the AAI exception
 137          */
 138         @Test
 139     public void childQuery() throws UnsupportedEncodingException, AAIException {
 140                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/ctag-pools/ctag-pool/key2/key3").build();
 141                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 142                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 143                                 .has("physical-location-id", "key1").has("aai-node-type", "complex")
 144                                 .in("org.onap.relationships.inventory.BelongsTo")
 145                                 .has("aai-node-type", "ctag-pool")
 146                                 .has("target-pe", "key2").has("availability-zone-name", "key3");
 147                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 148                                 .has("physical-location-id", "key1").has("aai-node-type", "complex");
 149                 assertEquals(
 150                                 "gremlin query should be " + expected.toString(),
 151                                 expected.toString(),
 152                                 query.getQueryBuilder().getQuery().toString());
 153                 assertEquals(
 154                                 "parent gremlin query should be equal the query for complex",
 155                                 expectedParent.toString(),
 156                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 157                 assertEquals(
 158                                 "result type should be complex",
 159                                 "complex",
 160                                 query.getParentResultType());
 161                 assertEquals(
 162                                 "result type should be ctag-pool",
 163                                 "ctag-pool",
 164                                 query.getResultType());
 165                 assertEquals("dependent",true, query.isDependent());
 166
 167
 168     }
 169
 170         /**
 171          * Naming exceptions.
 172          *
 173          * @throws UnsupportedEncodingException the unsupported encoding exception
 174          * @throws AAIException the AAI exception
 175          */
 176         @Test
 177     public void namingExceptions() throws UnsupportedEncodingException, AAIException {
 178                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags/cvlan-tag/655").build();
 179                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 180                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 181                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 182                                 .in("org.onap.relationships.inventory.BelongsTo")
 183                                 .has("aai-node-type", "port-group")
 184                                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 185                                 .has("aai-node-type", "cvlan-tag")
 186                                 .has("cvlan-tag", 655);
 187                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 188                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 189                                 .in("org.onap.relationships.inventory.BelongsTo")
 190                                 .has("aai-node-type", "port-group")
 191                                 .has("interface-id", "key2");
 192                 assertEquals(
 193                                 "gremlin query should be " + expected.toString(),
 194                                 expected.toString(),
 195                                 query.getQueryBuilder().getQuery().toString());
 196                 assertEquals(
 197                                 "parent gremlin query should be equal the query for port group",
 198                                 expectedParent.toString(),
 199                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 200                 assertEquals(
 201                                 "result type should be cvlan-tag",
 202                                 "cvlan-tag",
 203                                 query.getResultType());
 204                 assertEquals(
 205                                 "result type should be port-group",
 206                                 "port-group",
 207                                 query.getParentResultType());
 208                 assertEquals(
 209                                 "contaner type should be empty",
 210                                 "",
 211                                 query.getContainerType());
 212                 assertEquals("dependent",true, query.isDependent());
 213
 214
 215     }
 216
 217         /**
 218          * Gets the all.
 219          *
 220          * @return the all
 221          * @throws UnsupportedEncodingException the unsupported encoding exception
 222          * @throws AAIException the AAI exception
 223          */
 224         @Test
 225     public void getAll() throws UnsupportedEncodingException, AAIException {
 226                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 227                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 228                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 229                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 230                                 .in("org.onap.relationships.inventory.BelongsTo")
 231                                 .has("aai-node-type", "port-group")
 232                                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 233                                 .has("aai-node-type", "cvlan-tag");
 234                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 235                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 236                                 .in("org.onap.relationships.inventory.BelongsTo")
 237                                 .has("aai-node-type", "port-group")
 238                                 .has("interface-id", "key2");
 239                 assertEquals(
 240                                 "gremlin query should be " + expected.toString(),
 241                                 expected.toString(),
 242                                 query.getQueryBuilder().getQuery().toString());
 243                 assertEquals(
 244                                 "parent gremlin query should be equal the query for port group",
 245                                 expectedParent.toString(),
 246                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 247                 assertEquals(
 248                                 "result type should be port-group",
 249                                 "port-group",
 250                                 query.getParentResultType());
 251                 assertEquals(
 252                                 "result type should be cvlan-tag",
 253                                 "cvlan-tag",
 254                                 query.getResultType());
 255                 assertEquals(
 256                                 "container type should be cvlan-tags",
 257                                 "cvlan-tags",
 258                                 query.getContainerType());
 259                 assertEquals("dependent",true, query.isDependent());
 260
 261
 262     }
 263
 264         @Test
 265     public void getAllParent() throws UnsupportedEncodingException, AAIException {
 266                 URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers").build();
 267                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 268                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 269                                 .has("aai-node-type", "pserver");
 270                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 271                                 .has("aai-node-type", "pserver");
 272                 assertEquals(
 273                                 "gremlin query should be " + expected.toString(),
 274                                 expected.toString(),
 275                                 query.getQueryBuilder().getQuery().toString());
 276                 assertEquals(
 277                                 "parent gremlin query should be equal the query for pserver",
 278                                 expectedParent.toString(),
 279                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 280                 assertEquals(
 281                                 "parent result type should be empty",
 282                                 "",
 283                                 query.getParentResultType());
 284                 assertEquals(
 285                                 "result type should be pserver",
 286                                 "pserver",
 287                                 query.getResultType());
 288                 assertEquals(
 289                                 "container type should be pservers",
 290                                 "pservers",
 291                                 query.getContainerType());
 292                 assertEquals("dependent",false, query.isDependent());
 293
 294
 295     }
 296
 297
 298         /**
 299          * Gets the via query param.
 300          *
 301          * @return the via query param
 302          * @throws UnsupportedEncodingException the unsupported encoding exception
 303          * @throws AAIException the AAI exception
 304          */
 305         @Test
 306         public void getViaQueryParam() throws UnsupportedEncodingException, AAIException {
 307                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/mycloudowner/mycloudregionid/tenants/tenant").build();
 308                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 309                 map.putSingle("tenant-name", "Tenant1");
 310                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 311                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 312                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 313                                 .has("aai-node-type", "cloud-region")
 314                                 .in("org.onap.relationships.inventory.BelongsTo")
 315                                 .has("aai-node-type", "tenant")
 316                                 .has("tenant-name", "Tenant1");
 317
 318                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 319                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 320                                 .has("aai-node-type", "cloud-region");
 321
 322                 assertEquals(
 323                                 "gremlin query should be " + expected.toString(),
 324                                 expected.toString(),
 325                                 query.getQueryBuilder().getQuery().toString());
 326                 assertEquals(
 327                                 "parent gremlin query should be equal the query for cloud-region",
 328                                 expectedParent.toString(),
 329                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 330                 assertEquals(
 331                                 "result type should be cloud-region",
 332                                 "cloud-region",
 333                                 query.getParentResultType());
 334                 assertEquals(
 335                                 "result type should be tenant",
 336                                 "tenant",
 337                                 query.getResultType());
 338                 assertEquals(
 339                                 "container type should be empty",
 340                                 "",
 341                                 query.getContainerType());
 342                 assertEquals("dependent",true, query.isDependent());
 343
 344         }
 345
 346         @Test
 347         public void getViaDuplicateQueryParam() throws UnsupportedEncodingException, AAIException {
 348                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/mycloudowner/mycloudregionid/tenants/tenant").build();
 349                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 350                 List<String> values = new ArrayList<>();
 351                 values.add("Tenant1");
 352                 values.add("Tenant2");
 353                 map.put("tenant-name", values);
 354                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 355                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 356                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 357                                 .has("aai-node-type", "cloud-region")
 358                                 .in("org.onap.relationships.inventory.BelongsTo")
 359                                 .has("aai-node-type", "tenant")
 360                                 .has("tenant-name", P.within(values));
 361
 362                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 363                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 364                                 .has("aai-node-type", "cloud-region");
 365
 366                 assertEquals(
 367                                 "gremlin query should be " + expected.toString(),
 368                                 expected.toString(),
 369                                 query.getQueryBuilder().getQuery().toString());
 370                 assertEquals(
 371                                 "parent gremlin query should be equal the query for cloud-region",
 372                                 expectedParent.toString(),
 373                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 374                 assertEquals(
 375                                 "result type should be cloud-region",
 376                                 "cloud-region",
 377                                 query.getParentResultType());
 378                 assertEquals(
 379                                 "result type should be tenant",
 380                                 "tenant",
 381                                 query.getResultType());
 382                 assertEquals(
 383                                 "container type should be empty",
 384                                 "",
 385                                 query.getContainerType());
 386                 assertEquals("dependent",true, query.isDependent());
 387
 388         }
 389
 390         /**
 391          * Gets the plural via query param.
 392          *
 393          * @return the plural via query param
 394          * @throws UnsupportedEncodingException the unsupported encoding exception
 395          * @throws AAIException the AAI exception
 396          */
 397         @Test
 398         public void getPluralViaQueryParam() throws UnsupportedEncodingException, AAIException {
 399                 URI uri = UriBuilder.fromPath("network/vnfcs").build();
 400                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 401                 map.putSingle("prov-status", "up");
 402                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 403                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 404                                 .has("aai-node-type", "vnfc")
 405                                 .has("prov-status", "up");
 406
 407                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 408                                 .has("aai-node-type", "vnfc");
 409
 410                 assertEquals(
 411                                 "gremlin query should be " + expected.toString(),
 412                                 expected.toString(),
 413                                 query.getQueryBuilder().getQuery().toString());
 414                 assertEquals(
 415                                 "parent",
 416                                 expectedParent.toString(),
 417                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 418                 assertEquals(
 419                                 "parent result type should be empty",
 420                                 "",
 421                                 query.getParentResultType());
 422                 assertEquals(
 423                                 "result type should be vnfc",
 424                                 "vnfc",
 425                                 query.getResultType());
 426                 assertEquals(
 427                                 "container type should be empty",
 428                                 "vnfcs",
 429                                 query.getContainerType());
 430                 assertEquals("dependent",true, query.isDependent());
 431
 432         }
 433
 434         /**
 435          * Gets the all query param naming exception.
 436          *
 437          * @return the all query param naming exception
 438          * @throws UnsupportedEncodingException the unsupported encoding exception
 439          * @throws AAIException the AAI exception
 440          */
 441         @Test
 442     public void getAllQueryParamNamingException() throws UnsupportedEncodingException, AAIException {
 443                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 444                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 445                 map.putSingle("cvlan-tag", "333");
 446                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 447
 448                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 449                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 450                                 .in("org.onap.relationships.inventory.BelongsTo")
 451                                 .has("aai-node-type", "port-group")
 452                                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 453                                 .has("aai-node-type", "cvlan-tag")
 454                                 .has("cvlan-tag", 333);
 455                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 456                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 457                                 .in("org.onap.relationships.inventory.BelongsTo")
 458                                 .has("aai-node-type", "port-group")
 459                                 .has("interface-id", "key2");
 460                 assertEquals(
 461                                 "gremlin query should be " + expected.toString(),
 462                                 expected.toString(),
 463                                 query.getQueryBuilder().getQuery().toString());
 464                 assertEquals(
 465                                 "parent gremlin query should be equal the query for port group",
 466                                 expectedParent.toString(),
 467                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 468                 assertEquals(
 469                                 "result type should be port-group",
 470                                 "port-group",
 471                                 query.getParentResultType());
 472                 assertEquals(
 473                                 "result type should be cvlan-tag",
 474                                 "cvlan-tag",
 475                                 query.getResultType());
 476                 assertEquals(
 477                                 "container type should be cvlan-tags",
 478                                 "cvlan-tags",
 479                                 query.getContainerType());
 480                 assertEquals("dependent",true, query.isDependent());
 481
 482
 483     }
 484
 485         /**
 486          * Abstract type.
 487          *
 488          * @throws UnsupportedEncodingException the unsupported encoding exception
 489          * @throws AAIException the AAI exception
 490          */
 491         @Test
 492     public void abstractType() throws UnsupportedEncodingException, AAIException {
 493                 URI uri = UriBuilder.fromPath("vnf/key1").build();
 494
 495                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 496
 497                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 498                                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "generic-vnf"));
 499
 500                 GraphTraversal<Vertex, Vertex> expectedParent = expected;
 501                 assertEquals(
 502                                 "gremlin query should be " + expected.toString(),
 503                                 expected.toString(),
 504                                 query.getQueryBuilder().getQuery().toString());
 505                 assertEquals(
 506                                 "parent gremlin query should be equal the query for port group",
 507                                 expectedParent.toString(),
 508                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 509                 assertEquals(
 510                                 "result type should be empty",
 511                                 "",
 512                                 query.getParentResultType());
 513                 assertEquals(
 514                                 "result type should be vnf",
 515                                 "vnf",
 516                                 query.getResultType());
 517
 518                 assertEquals("dependent",false, query.isDependent());
 519
 520
 521     }
 522
 523         /**
 524          * Non parent abstract type.
 525          *
 526          * @throws UnsupportedEncodingException the unsupported encoding exception
 527          * @throws AAIException the AAI exception
 528          */
 529         @Test
 530     public void nonParentAbstractType() throws UnsupportedEncodingException, AAIException {
 531                 URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers/pserver/key2/vnf/key1").build();
 532                 thrown.expect(AAIException.class);
 533                 thrown.expectMessage(containsString("not a valid path"));
 534                 dbEngine.getQueryBuilder().createQueryFromURI(uri);
 535     }
 536
 537         @Test
 538         public void parentAbstractTypeWithNesting() throws UnsupportedEncodingException, AAIException {
 539                 URI uri = UriBuilder.fromPath("vnf/key1/vf-modules/vf-module/key2").build();
 540
 541                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 542
 543                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 544                                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "generic-vnf"))
 545                                 .union(__.in("org.onap.relationships.inventory.BelongsTo").has(AAIProperties.NODE_TYPE, "vf-module")).has("vf-module-id", "key2");
 546
 547                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 548                                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "generic-vnf"));
 549                 assertEquals(
 550                                 "gremlin query should be " + expected.toString(),
 551                                 expected.toString(),
 552                                 query.getQueryBuilder().getQuery().toString());
 553                 assertEquals(
 554                                 "parent gremlin query should be equal the query for ",
 555                                 expectedParent.toString(),
 556                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 557                 assertEquals(
 558                                 "result type should be vnf",
 559                                 "vnf",
 560                                 query.getParentResultType());
 561                 assertEquals(
 562                                 "result type should be vf-module",
 563                                 "vf-module",
 564                                 query.getResultType());
 565
 566                 assertEquals("dependent",true, query.isDependent());
 567
 568         }
 569
 570         @Test
 571         public void getViaBadQueryParam() throws UnsupportedEncodingException, AAIException {
 572                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/a/b/tenants/tenant").build();
 573                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 574                 map.putSingle("tenant-n231ame", "Tenant1");
 575                 thrown.expect(AAIException.class);
 576                 thrown.expect(hasProperty("code", is("AAI_3000")));
 577
 578                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 579
 580         }
 581
 582         @Test
 583         public void getPluralViaBadQueryParam() throws UnsupportedEncodingException, AAIException {
 584                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/a/b/tenants").build();
 585                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 586                 map.putSingle("tenant-n231ame", "Tenant1");
 587                 thrown.expect(AAIException.class);
 588                 thrown.expect(hasProperty("code", is("AAI_3000")));
 589
 590                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 591
 592         }
 593
 594         @Test
 595         public void getPluralViaDuplicateQueryParam() throws UnsupportedEncodingException, AAIException {
 596                 URI uri = UriBuilder.fromPath("network/vnfcs").build();
 597                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 598                 List<String> values = new ArrayList<>();
 599                 values.add("up");
 600                 values.add("down");
 601                 values.add("left");
 602                 values.add("right");
 603                 values.add("start");
 604                 map.put("prov-status", values);
 605                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 606                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 607                                 .has("aai-node-type", "vnfc")
 608                                 .has("prov-status", P.within(values));
 609
 610                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 611                                 .has("aai-node-type", "vnfc");
 612
 613                 assertEquals(
 614                                 "gremlin query should be " + expected.toString(),
 615                                 expected.toString(),
 616                                 query.getQueryBuilder().getQuery().toString());
 617                 assertEquals(
 618                                 "parent",
 619                                 expectedParent.toString(),
 620                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 621                 assertEquals(
 622                                 "parent result type should be empty",
 623                                 "",
 624                                 query.getParentResultType());
 625                 assertEquals(
 626                                 "result type should be vnfc",
 627                                 "vnfc",
 628                                 query.getResultType());
 629                 assertEquals(
 630                                 "container type should be empty",
 631                                 "vnfcs",
 632                                 query.getContainerType());
 633                 assertEquals("dependent",true, query.isDependent());
 634
 635         }
 636
 637         @Test
 638         public void dbAliasedSearch() throws UnsupportedEncodingException, AAIException {
 639                 URI uri = UriBuilder.fromPath("network/generic-vnfs").build();
 640                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 641                 map.putSingle("persona-model-customization-id", "key2");
 642                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri, map);
 643                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 644                                 .has("aai-node-type", "generic-vnf")
 645                                 .has("model-customization-id", "key2");
 646                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 647                                 .has("aai-node-type", "generic-vnf");
 648
 649                 assertEquals(
 650                                 "gremlin query should be " + expected.toString(),
 651                                 expected.toString(),
 652                                 query.getQueryBuilder().getQuery().toString());
 653                 assertEquals(
 654                                 "parent",
 655                                 expectedParent.toString(),
 656                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 657
 658                 assertEquals(
 659                                 "result type should be",
 660                                 "generic-vnf",
 661                                 query.getResultType());
 662                 assertEquals(
 663                                 "result type should be empty",
 664                                 "",
 665                                 query.getParentResultType());
 666                 assertEquals("dependent",true, query.isDependent());
 667
 668
 669         }
 670
 671         @Test
 672         public void dataLinkedSearch() throws UnsupportedEncodingException, AAIException {
 673                 URI uri = UriBuilder.fromPath("network/vpn-bindings").build();
 674                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 675                 map.putSingle("global-route-target", "key2");
 676                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri, map);
 677                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 678                                 .has("aai-node-type", "vpn-binding")
 679                                 .where(__.in("org.onap.relationships.inventory.BelongsTo").has(AAIProperties.NODE_TYPE, "route-target").has("global-route-target", "key2"));
 680                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 681                                 .has("aai-node-type", "vpn-binding");
 682
 683                 assertEquals(
 684                                 "gremlin query should be " + expected.toString(),
 685                                 expected.toString(),
 686                                 query.getQueryBuilder().getQuery().toString());
 687                 assertEquals(
 688                                 "parent",
 689                                 expectedParent.toString(),
 690                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 691
 692                 assertEquals(
 693                                 "result type should be",
 694                                 "vpn-binding",
 695                                 query.getResultType());
 696                 assertEquals(
 697                                 "result type should be empty",
 698                                 "",
 699                                 query.getParentResultType());
 700                 assertEquals("dependent",true, query.isDependent());
 701         }
 702
 703         @Test
 704         public void pluralCousin() throws UnsupportedEncodingException, AAIException {
 705                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to/pservers").build();
 706
 707                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 708                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 709                                 .has("physical-location-id", "key1")
 710                                 .has("aai-node-type", "complex")
 711                                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver");
 712                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 713                                 .has("physical-location-id", "key1")
 714                                 .has("aai-node-type", "complex");
 715
 716                 assertEquals(
 717                                 "gremlin query should be " + expected.toString(),
 718                                 expected.toString(),
 719                                 query.getQueryBuilder().getQuery().toString());
 720                 assertEquals(
 721                                 "parent",
 722                                 expectedParent.toString(),
 723                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 724
 725                 assertEquals(
 726                                 "result type should be",
 727                                 "pserver",
 728                                 query.getResultType());
 729                 assertEquals(
 730                                 "result type should be",
 731                                 "complex",
 732                                 query.getParentResultType());
 733                 //this is controversial but we're not allowing writes on this currently
 734                 assertEquals("dependent",true, query.isDependent());
 735         }
 736
 737         @Test
 738         public void specificCousin() throws UnsupportedEncodingException, AAIException {
 739                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to/pservers/pserver/key2").build();
 740
 741                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 742                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 743                                 .has("physical-location-id", "key1")
 744                                 .has("aai-node-type", "complex")
 745                                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver")
 746                                 .has("hostname", "key2");
 747                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 748                                 .has("physical-location-id", "key1")
 749                                 .has("aai-node-type", "complex");
 750
 751                 assertEquals(
 752                                 "gremlin query should be " + expected.toString(),
 753                                 expected.toString(),
 754                                 query.getQueryBuilder().getQuery().toString());
 755                 assertEquals(
 756                                 "parent",
 757                                 expectedParent.toString(),
 758                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 759
 760                 assertEquals(
 761                                 "result type should be",
 762                                 "pserver",
 763                                 query.getResultType());
 764                 assertEquals(
 765                                 "result type should be",
 766                                 "complex",
 767                                 query.getParentResultType());
 768                 //this is controversial but we're not allowing writes on this currently
 769                 assertEquals("dependent",true, query.isDependent());
 770         }
 771
 772         @Test
 773         public void doubleSpecificCousin() throws UnsupportedEncodingException, AAIException {
 774                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to/pservers/pserver/key2/related-to/vservers/vserver/key3").build();
 775
 776                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 777                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 778                                 .has("physical-location-id", "key1")
 779                                 .has("aai-node-type", "complex")
 780                                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver")
 781                                 .has("hostname", "key2")
 782                                 .in("tosca.relationships.HostedOn").has("aai-node-type", "vserver")
 783                                 .has("vserver-id", "key3");
 784                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 785                                 .has("physical-location-id", "key1")
 786                                 .has("aai-node-type", "complex")
 787                                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver")
 788                                 .has("hostname", "key2");
 789
 790                 assertEquals(
 791                                 "gremlin query should be " + expected.toString(),
 792                                 expected.toString(),
 793                                 query.getQueryBuilder().getQuery().toString());
 794                 assertEquals(
 795                                 "parent",
 796                                 expectedParent.toString(),
 797                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 798
 799                 assertEquals(
 800                                 "result type should be",
 801                                 "vserver",
 802                                 query.getResultType());
 803                 assertEquals(
 804                                 "result type should be",
 805                                 "pserver",
 806                                 query.getParentResultType());
 807                 //this is controversial but we're not allowing writes on this currently
 808                 assertEquals("dependent",true, query.isDependent());
 809         }
 810
 811         @Test
 812         public void traversalEndsInRelatedTo() throws UnsupportedEncodingException, AAIException {
 813                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to").build();
 814
 815                 thrown.expect(AAIException.class);
 816                 thrown.expectMessage(containsString(RestTokens.COUSIN.toString()));
 817                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 818
 819         }
 820
 821         @Test
 822         public void pluralCousinToPluralCousin() throws UnsupportedEncodingException, AAIException {
 823                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/related-to/pservers").build();
 824
 825                 thrown.expect(AAIException.class);
 826                 thrown.expectMessage(containsString("chain plurals"));
 827                 QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 828
 829         }
 830 }