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