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