src/test/java/org/openecomp/crud/dao/champ/ChampDaoTest.java

   1 package org.openecomp.crud.dao.champ;
   2
   3 import org.junit.After;
   4 import org.junit.Before;
   5 import org.junit.Ignore;
   6 import org.junit.Test;
   7 import org.openecomp.aai.champcore.graph.impl.InMemoryChampGraphImpl;
   8 import org.openecomp.crud.dao.GraphDao;
   9 import org.openecomp.crud.entity.Edge;
  10 import org.openecomp.crud.entity.Vertex;
  11 import org.openecomp.crud.exception.CrudException;
  12
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Properties;
  17
  18 import static org.junit.Assert.*;
  19
  20
  21 /**
  22  * This suite of tests validates the basic functionality of the {@link ChampDao}.
  23  */
  24 public class ChampDaoTest {
  25
  26 //  private static final String GRAPH_NAME = "my_test_graph";
  27 //
  28 //  private GraphDao champDao = null;
  29 //
  30 //
  31 //  /**
  32 //   * Perform setup steps that must be done prior to executing each test.
  33 //   */
  34 //  @Before
  35 //  public void setup() {
  36 //
  37 //    // Create an instance of the Champ DAO, backed by the Champ library's in-memory back end
  38 //    // for testing purposes.
  39 //        Map<String, Object> champDaoProperties = new HashMap<String, Object>();
  40 //    champDaoProperties.put(ChampDao.CONFIG_STORAGE_BACKEND, "in-memory");
  41 //    champDaoProperties.put(ChampDao.CONFIG_GRAPH_NAME, GRAPH_NAME);
  42 //    champDao = new ChampDao(new InMemoryChampGraphImpl.Builder().properties(champDaoProperties).build());
  43 //  }
  44 //
  45 //
  46 //  /**
  47 //   * Perform tear down steps that must be done after executing each test.
  48 //   */
  49 //  @After
  50 //  public void tearDown() {
  51 //
  52 //    // Release the Champ DAO instance that we were using for the test.
  53 //    if (champDao != null) {
  54 //      ((ChampDao) champDao).close();
  55 //    }
  56 //  }
  57 //
  58 //
  59 //  /**
  60 //   * Tests the ability of the {@link ChampDao} to create a vertex.
  61 //   *
  62 //   * @throws CrudException
  63 //   */
  64 //  @Test
  65 //  public void createVertexTest() throws CrudException {
  66 //
  67 //    String VERTEX_TYPE = "Test_Vertex";
  68 //
  69 //    Map<String, Object> properties = new HashMap<String, Object>();
  70 //    properties.put("property1", "something");
  71 //    properties.put("property2", "something else");
  72 //
  73 //    // Create the vertex.
  74 //    Vertex createdVertex = champDao.addVertex(VERTEX_TYPE, properties);
  75 //
  76 //    // Validate that the returned {@link Vertex} has the right label assigned to it.
  77 //    assertTrue("Unexpected vertex type '" + createdVertex.getType() + "' returned from DAO",
  78 //        createdVertex.getType().equals(VERTEX_TYPE));
  79 //
  80 //    // Validate that all of the properties that we provided to the DAO are in fact assigned
  81 //    // to the {@link Vertex} that we got back.
  82 //    assertTrue("Vertex property list returned from DAO did not contain all expected properties - expected: " +
  83 //            properties.keySet() + " actual: " + createdVertex.getProperties().keySet(),
  84 //        createdVertex.getProperties().keySet().containsAll(properties.keySet()));
  85 //
  86 //    // Validate that the values assigned to the properties in the returned {@link Vertex}
  87 //    // match the ones that we provided.
  88 //    for (String propertyKey : properties.keySet()) {
  89 //
  90 //      assertTrue(createdVertex.getProperties().get(propertyKey).equals(properties.get(propertyKey)));
  91 //    }
  92 //  }
  93 //
  94 //
  95 //  /**
  96 //   * Tests the ability of the {@link ChampDao} to retrieve a vertex from the graph data store
  97 //   * by its unique identifier.
  98 //   *
  99 //   * @throws CrudException
 100 //   */
 101 //  @Test
 102 //  public void getVertexByIdTest() throws CrudException {
 103 //
 104 //    String VERTEX_TYPE = "Test_Vertex";
 105 //
 106 //    Map<String, Object> properties = new HashMap<String, Object>();
 107 //    properties.put("property1", "something");
 108 //    properties.put("property2", "something else");
 109 //
 110 //    // Create the vertex.
 111 //    Vertex createdVertex = champDao.addVertex(VERTEX_TYPE, properties);
 112 //
 113 //    // Make sure the {@link Vertex} returned from the create method includes an id that we can
 114 //    // use to retrieve it.
 115 //    assertTrue("No valid id returned for the created vertex", createdVertex.getId().isPresent());
 116 //
 117 //    // Now, retrieve the {@link Vertex} by its identifier.
 118 //    Vertex retrievedVertex = champDao.getVertex(createdVertex.getId().get(), VERTEX_TYPE);
 119 //
 120 //    // Validate that the retrieved {@link Vertex} has the right label assigned to it.
 121 //    assertTrue("Unexpected vertex type '" + retrievedVertex.getType() + "' returned from DAO",
 122 //        retrievedVertex.getType().equals(VERTEX_TYPE));
 123 //
 124 //    // Validate that all of the properties that we provided when we created the {@link Vertex}
 125 //    // are present in the {@link Vertex} that we retrieved.
 126 //    assertTrue("Vertex property list returned from DAO did not contain all expected properties - expected: " +
 127 //            properties.keySet() + " actual: " + retrievedVertex.getProperties().keySet(),
 128 //        retrievedVertex.getProperties().keySet().containsAll(properties.keySet()));
 129 //
 130 //    // Validate that the values assigned to the properties in the retrieved {@link Vertex}
 131 //    // match the ones that we provided when we created it.
 132 //    for (String propertyKey : properties.keySet()) {
 133 //
 134 //      assertTrue(retrievedVertex.getProperties().get(propertyKey).equals(properties.get(propertyKey)));
 135 //    }
 136 //  }
 137 //
 138 //
 139 //  /**
 140 //   * Tests the ability of the {@link ChampDao} to update an already existing vertex.
 141 //   *
 142 //   * @throws CrudException
 143 //   */
 144 //  @Test
 145 //  public void updateVertexTest() throws CrudException {
 146 //
 147 //    final String VERTEX_TYPE = "Test_Vertex";
 148 //
 149 //    Map<String, Object> properties = new HashMap<String, Object>();
 150 //    properties.put("property1", "something");
 151 //    properties.put("property2", "something else");
 152 //
 153 //    // Create the vertex.
 154 //    Vertex createdVertex = champDao.addVertex(VERTEX_TYPE, properties);
 155 //
 156 //    // Make sure the {@link Vertex} returned from the create method includes an id that we can
 157 //    // use to retrieve it.
 158 //    assertTrue("No valid id returned for the created vertex", createdVertex.getId().isPresent());
 159 //
 160 //    // Modify the properties list...
 161 //    properties.put("property3", "a new property");
 162 //    properties.remove("property1");
 163 //
 164 //    // ...and apply it to our vertex.
 165 //    Vertex updatedVertex = champDao.updateVertex(createdVertex.getId().get(), createdVertex.getType(), properties);
 166 //
 167 //    assertTrue("Vertex property list returned from DAO update operation did not contain all expected properties - expected: " +
 168 //            properties.keySet() + " actual: " + updatedVertex.getProperties().keySet(),
 169 //        updatedVertex.getProperties().keySet().containsAll(properties.keySet()));
 170 //
 171 //    // Validate that the values assigned to the properties in the updated {@link Vertex}
 172 //    // match the ones that we provided when we created it.
 173 //    for (String propertyKey : properties.keySet()) {
 174 //
 175 //      assertTrue("Unexpected value for property '" + propertyKey + "' - Expected: " +
 176 //              properties.get(propertyKey) + "  Actual: " +
 177 //              updatedVertex.getProperties().get(propertyKey),
 178 //          updatedVertex.getProperties().get(propertyKey).equals(properties.get(propertyKey)));
 179 //    }
 180 //
 181 //    // Validate that the property that we removed is NOT in the set of properties from our
 182 //    // updated {@link Vertex}.
 183 //    assertFalse("Property 'property1' should no longer be associated with updated vertex",
 184 //        updatedVertex.getProperties().containsKey("property1"));
 185 //  }
 186 //
 187 //
 188 //  /**
 189 //   * Tests the ability of the {@link ChampDao} to retrieve multiple vertices which match
 190 //   * a particular set of supplied properties.
 191 //   *
 192 //   * @throws CrudException
 193 //   */
 194 //  @Test
 195 //  public void getVerticesTest() throws CrudException {
 196 //
 197 //    final String FIRST_VERTEX_TYPE = "pserver";
 198 //    final String SECOND_VERTEX_TYPE = "complex";
 199 //
 200 //    // Create some vertices.
 201 //
 202 //    Map<String, Object> vertex1Properties = new HashMap<String, Object>();
 203 //    vertex1Properties.put("O/S", "Linux");
 204 //    vertex1Properties.put("version", "6.5");
 205 //    vertex1Properties.put("hostname", "kll0001");
 206 //    champDao.addVertex(FIRST_VERTEX_TYPE, vertex1Properties);
 207 //
 208 //    Map<String, Object> vertex2Properties = new HashMap<String, Object>();
 209 //    vertex2Properties.put("O/S", "Linux");
 210 //    vertex2Properties.put("version", "6.5");
 211 //    vertex2Properties.put("hostname", "kll0002");
 212 //    champDao.addVertex(FIRST_VERTEX_TYPE, vertex2Properties);
 213 //
 214 //    Map<String, Object> vertex3Properties = new HashMap<String, Object>();
 215 //    vertex3Properties.put("O/S", "Linux");
 216 //    vertex3Properties.put("version", "7.2");
 217 //    vertex3Properties.put("hostname", "kll0003");
 218 //    champDao.addVertex(FIRST_VERTEX_TYPE, vertex3Properties);
 219 //
 220 //    Map<String, Object> vertex4Properties = new HashMap<String, Object>();
 221 //    vertex4Properties.put("O/S", "Windows");
 222 //    vertex4Properties.put("version", "10");
 223 //    vertex4Properties.put("hostname", "Dev Laptop");
 224 //    champDao.addVertex(FIRST_VERTEX_TYPE, vertex4Properties);
 225 //
 226 //    Map<String, Object> vertex5Properties = new HashMap<String, Object>();
 227 //    vertex5Properties.put("Street", "Baker");
 228 //    vertex5Properties.put("Number", "222B");
 229 //    champDao.addVertex(SECOND_VERTEX_TYPE, vertex5Properties);
 230 //
 231 //    // Create a set of properties to use for our query.
 232 //    Map<String, Object> queryProperties = new HashMap<String, Object>();
 233 //    queryProperties.put("O/S", "Linux");
 234 //    queryProperties.put("version", "6.5");
 235 //
 236 //    // Validate that we filter our 'get vertices' results by type
 237 //    List<Vertex> allVerticesByType = champDao.getVertices(FIRST_VERTEX_TYPE, MapBuilder.builder().build());
 238 //    for (Vertex v : allVerticesByType) {
 239 //      assertTrue("Unexpected vertex type returned from query.  Expected: " +
 240 //              FIRST_VERTEX_TYPE + " Actual: " + v.getType(),
 241 //          v.getType().equals(FIRST_VERTEX_TYPE));
 242 //    }
 243 //
 244 //    // Now, request the vertices that match our parameters.
 245 //    List<Vertex> vertices = champDao.getVertices(FIRST_VERTEX_TYPE, queryProperties);
 246 //
 247 //    // Validate that got back the expected number of vertices.
 248 //    assertEquals(vertices.size(), 2);
 249 //
 250 //    // Validate that the vertices we got back contain the expected parameters.
 251 //    for (Vertex v : vertices) {
 252 //
 253 //      assertTrue("Vertex from query result does not contain expected vertex 'O/S'",
 254 //          v.getProperties().containsKey("O/S"));
 255 //      assertTrue("Vertex from query result contains unexpected value for 'O/S' parameter - Expected: 'Linux'  Actual: '" +
 256 //              v.getProperties().get("O/S") + "'",
 257 //          v.getProperties().get("O/S").equals("Linux"));
 258 //
 259 //      assertTrue("Vertex from query result does not contain expected vertex 'O/S'",
 260 //          v.getProperties().containsKey("version"));
 261 //      assertTrue("Vertex from query result contains unexpected value for 'O/S' parameter - Expected: 'Linux'  Actual: '" +
 262 //              v.getProperties().get("O/S") + "'",
 263 //          v.getProperties().get("version").equals("6.5"));
 264 //    }
 265 //  }
 266 //
 267 //  @Test
 268 //  public void deleteVertexTest() throws CrudException {
 269 //
 270 //    boolean deletedVertexNotFound = false;
 271 //
 272 //    // Create a vertex.
 273 //    Vertex createdVertex = champDao.addVertex("test_type", MapBuilder.builder()
 274 //        .withKeyValue("O/S", "Linux")
 275 //        .withKeyValue("version", "6.5")
 276 //        .withKeyValue("hostname", "kll0001")
 277 //        .build());
 278 //
 279 //    // Verify that we can retrieve the vertex from the graph data base.
 280 //    Vertex retrievedVertex = champDao.getVertex(createdVertex.getId().get(), "test_type");
 281 //
 282 //    // Now, delete the vertex.
 283 //    champDao.deleteVertex(createdVertex.getId().get(), "test_type");
 284 //
 285 //    // Now, try to retrieve it again.  This time we should fail to find it.
 286 //    try {
 287 //      champDao.getVertex(createdVertex.getId().get(), "test_type");
 288 //
 289 //    } catch (CrudException e) {
 290 //      assertTrue(e.getMessage().contains("No vertex with id"));
 291 //      deletedVertexNotFound = true;
 292 //    }
 293 //
 294 //    assertTrue("Should not have been able to retrieve deleted vertex", deletedVertexNotFound);
 295 //  }
 296 //
 297 //  @Test
 298 //  public void createEdgeTest() throws CrudException {
 299 //
 300 //    String EDGE_TYPE = "has";
 301 //
 302 //    // Create the source vertex for the edge.
 303 //    Map<String, Object> srcVertexProperties = new HashMap<String, Object>();
 304 //    srcVertexProperties.put("O/S", "Linux");
 305 //    srcVertexProperties.put("version", "6.5");
 306 //    srcVertexProperties.put("hostname", "kll0001");
 307 //    Vertex sourceVertex = champDao.addVertex("vserver", srcVertexProperties);
 308 //
 309 //    // Create the target vertex for the edge.
 310 //    Map<String, Object> dstVertexProperties = new HashMap<String, Object>();
 311 //    dstVertexProperties.put("O/S", "Linux");
 312 //    dstVertexProperties.put("version", "6.5");
 313 //    dstVertexProperties.put("hostname", "kll0002");
 314 //    Vertex destVertex = champDao.addVertex("VNF", dstVertexProperties);
 315 //
 316 //    // Now, create the edge itself.
 317 //    Map<String, Object> edgeProperties = new HashMap<String, Object>();
 318 //    edgeProperties.put("prop", "val");
 319 //    Edge createdEdge = champDao.addEdge("has", sourceVertex, destVertex, edgeProperties);
 320 //
 321 //    // Validate that the Edge object returned from the create method matches what we were
 322 //    // trying to create.
 323 //    assertTrue("Unexpected type for Edge returned from create method.  Expected: " + EDGE_TYPE
 324 //            + " Actual: " + createdEdge.getType(),
 325 //        createdEdge.getType().equals("has"));
 326 //    assertTrue("Unexpected properties for Edge returned from create method.  Expected: " + edgeProperties
 327 //            + " Actual: " + createdEdge.getProperties(),
 328 //        createdEdge.getProperties().equals(edgeProperties));
 329 //
 330 //  }
 331 //
 332 //  @Test
 333 //  public void createEdgeWithMissingSrcOrTargetTest() throws CrudException {
 334 //
 335 //    String EDGE_TYPE = "has";
 336 //
 337 //    // Create the source vertex for the edge.
 338 //    Map<String, Object> srcVertexProperties = new HashMap<String, Object>();
 339 //    srcVertexProperties.put("O/S", "Linux");
 340 //    srcVertexProperties.put("version", "6.5");
 341 //    srcVertexProperties.put("hostname", "kll0001");
 342 //    Vertex sourceVertex = champDao.addVertex("vserver", srcVertexProperties);
 343 //
 344 //    // Create the target vertex for the edge.
 345 //    Map<String, Object> dstVertexProperties = new HashMap<String, Object>();
 346 //    dstVertexProperties.put("O/S", "Linux");
 347 //    dstVertexProperties.put("version", "6.5");
 348 //    dstVertexProperties.put("hostname", "kll0002");
 349 //    Vertex destVertex = champDao.addVertex("VNF", dstVertexProperties);
 350 //
 351 //    // Now, try creating the Edge but specify an id for the source vertex that does
 352 //    // not exist.
 353 //    Map<String, Object> edgeProperties = new HashMap<String, Object>();
 354 //    edgeProperties.put("prop", "val");
 355 //    try {
 356 //      champDao.addEdge(EDGE_TYPE, new Vertex.Builder("miss").id("99").build(), destVertex, edgeProperties);
 357 //    } catch (CrudException e) {
 358 //      assertTrue(e.getMessage().contains("Error creating edge - source vertex"));
 359 //    }
 360 //
 361 //    // Now, try created the Edge with a valid source vertex, but specify an id for the
 362 //    // target vertex that does not exist.
 363 //    try {
 364 //      champDao.addEdge(EDGE_TYPE, sourceVertex, new Vertex.Builder("miss").id("99").build(), edgeProperties);
 365 //    } catch (CrudException e) {
 366 //      assertTrue(e.getMessage().contains("Error creating edge - target vertex"));
 367 //    }
 368 //
 369 //  }
 370 //
 371 //  @Test
 372 //  public void getEdgeByIdTest() throws CrudException {
 373 //
 374 //    String EDGE_TYPE = "has";
 375 //
 376 //    // Create the source vertex for the edge.
 377 //    Map<String, Object> srcVertexProperties = new HashMap<String, Object>();
 378 //    srcVertexProperties.put("O/S", "Linux");
 379 //    srcVertexProperties.put("version", "6.5");
 380 //    srcVertexProperties.put("hostname", "kll0001");
 381 //    Vertex sourceVertex = champDao.addVertex("vserver", srcVertexProperties);
 382 //
 383 //    // Create the target vertex for the edge.
 384 //    Map<String, Object> dstVertexProperties = new HashMap<String, Object>();
 385 //    dstVertexProperties.put("O/S", "Linux");
 386 //    dstVertexProperties.put("version", "6.5");
 387 //    dstVertexProperties.put("hostname", "kll0002");
 388 //    Vertex destVertex = champDao.addVertex("VNF", dstVertexProperties);
 389 //
 390 //    // Now, create the edge itself.
 391 //    Map<String, Object> edgeProperties = new HashMap<String, Object>();
 392 //    edgeProperties.put("prop", "val");
 393 //    Edge createdEdge = champDao.addEdge("has", sourceVertex, destVertex, edgeProperties);
 394 //
 395 //    // Retrieve the edge we just created by specifying its unique identifier.
 396 //    Edge retrievedEdge = champDao.getEdge(createdEdge.getId().get(), "has");
 397 //
 398 //    // Validate that the contents of the object that we got back matches what we thought we
 399 //    // created.
 400 //    assertTrue("Unexpected type for Edge returned from get method.  Expected: " + EDGE_TYPE
 401 //            + " Actual: " + retrievedEdge.getType(),
 402 //        retrievedEdge.getType().equals(EDGE_TYPE));
 403 //    assertTrue("Unexpected properties for Edge returned from get method.  Expected: " + edgeProperties
 404 //            + " Actual: " + retrievedEdge.getProperties(),
 405 //        retrievedEdge.getProperties().equals(edgeProperties));
 406 //  }
 407 //
 408 //  @Test
 409 //  public void getEdgesTest() throws CrudException {
 410 //
 411 //    final String EDGE_TYPE_HAS = "has";
 412 //    final String EDGE_TYPE_RUNS = "runs";
 413 //
 414 //    // Create some vertices and edges that we can query agains.
 415 //    Vertex complex = champDao.addVertex("complex", MapBuilder.builder()
 416 //        .withKeyValue("Province", "Ontario")
 417 //        .withKeyValue("City", "Ottawa")
 418 //        .withKeyValue("Street", "303 Terry Fox")
 419 //        .build());
 420 //
 421 //    Vertex vserver = champDao.addVertex("vserver", MapBuilder.builder()
 422 //        .withKeyValue("O/S", "Linux")
 423 //        .withKeyValue("version", "6.5")
 424 //        .withKeyValue("hostname", "kll0001")
 425 //        .build());
 426 //
 427 //    Vertex vnf1 = champDao.addVertex("vserver", MapBuilder.builder()
 428 //        .withKeyValue("Application", "OpenDaylight")
 429 //        .build());
 430 //
 431 //    Vertex vnf2 = champDao.addVertex("vserver", MapBuilder.builder()
 432 //        .withKeyValue("Application", "Cammunda")
 433 //        .build());
 434 //
 435 //    Edge edge1 = champDao.addEdge(EDGE_TYPE_HAS, complex, vserver,
 436 //        MapBuilder.builder()
 437 //            .withKeyValue("usesResource", "false")
 438 //            .withKeyValue("hasDelTarget", "false")
 439 //            .build());
 440 //
 441 //    Edge edge2 = champDao.addEdge(EDGE_TYPE_RUNS, vserver, vnf1,
 442 //        MapBuilder.builder()
 443 //            .withKeyValue("usesResource", "false")
 444 //            .withKeyValue("hasDelTarget", "true")
 445 //            .build());
 446 //
 447 //    Edge edge3 = champDao.addEdge(EDGE_TYPE_RUNS, vserver, vnf2,
 448 //        MapBuilder.builder()
 449 //            .withKeyValue("usesResource", "false")
 450 //            .withKeyValue("hasDelTarget", "false")
 451 //            .build());
 452 //
 453 //    // Query for all HAS edges.
 454 //    List<Edge> hasEdges = champDao.getEdges(EDGE_TYPE_HAS, new HashMap<String, Object>());
 455 //
 456 //    assertEquals("Unexpected number of edges of type 'has' found.  Expected: 1 Actual: " + hasEdges.size(),
 457 //        hasEdges.size(), 1);
 458 //    assertTrue("Result of query for 'has' type edges does not contain the expected results",
 459 //        containsEdge(edge1, hasEdges));
 460 //
 461 //    // Query for all RUNS edges.
 462 //    List<Edge> runsEdges = champDao.getEdges(EDGE_TYPE_RUNS, new HashMap<String, Object>());
 463 //
 464 //    assertEquals("Unexpected number of edges of type 'runs' found.  Expected: 2 Actual: " + runsEdges.size(),
 465 //        runsEdges.size(), 2);
 466 //    assertTrue("Result of query for 'runs' type edges does not contain the expected results",
 467 //        containsEdge(edge2, runsEdges));
 468 //    assertTrue("Result of query for 'runs' type edges does not contain the expected results",
 469 //        containsEdge(edge2, runsEdges));
 470 //
 471 //    // Query for all HAS edges with the property 'hasDelTarget' equal to 'true'.
 472 //    List<Edge> runsEdgesWithDelTargetTrue =
 473 //        champDao.getEdges(EDGE_TYPE_RUNS, MapBuilder.builder()
 474 //            .withKeyValue("hasDelTarget", "true")
 475 //            .build());
 476 //
 477 //    assertEquals("Unexpected number of edges of type 'has' with 'hasDelTarget=true' found.  Expected: 1 Actual: "
 478 //            + runsEdgesWithDelTargetTrue.size(),
 479 //        runsEdgesWithDelTargetTrue.size(), 1);
 480 //    assertTrue("Result of query for 'runs' type edges with delTarget set to TRUE does not contain the expected results",
 481 //        containsEdge(edge2, runsEdgesWithDelTargetTrue));
 482 //  }
 483 //
 484 //  @Test
 485 //  @Ignore   // For now - pending some expected fixes to the Champ library.
 486 //  public void updateEdgeTest() throws CrudException {
 487 //
 488 //    // Create the source vertex for the edge.
 489 //    Vertex sourceVertex = champDao.addVertex("vserver", MapBuilder.builder()
 490 //        .withKeyValue("O/S", "Linux")
 491 //        .withKeyValue("version", "6.5")
 492 //        .withKeyValue("hostname", "kll0001")
 493 //        .build());
 494 //
 495 //    // Create the target vertex for the edge.
 496 //    Vertex destVertex = champDao.addVertex("VNF", MapBuilder.builder()
 497 //        .withKeyValue("O/S", "Linux")
 498 //        .withKeyValue("version", "6.5")
 499 //        .withKeyValue("hostname", "kll0002")
 500 //        .build());
 501 //
 502 //    // Now, create the edge itself.
 503 //    Edge createdEdge = champDao.addEdge("has",
 504 //        sourceVertex,
 505 //        destVertex,
 506 //        MapBuilder.builder()
 507 //            .withKeyValue("key1", "value1")
 508 //            .withKeyValue("key2", "value2")
 509 //            .withKeyValue("key3", "value3")
 510 //            .build());
 511 //
 512 //    // Make sure the Edge returned from the create method includes an id that we can
 513 //    // use to retrieve it.
 514 //    assertTrue("No valid id returned for the created edge", createdEdge.getId().isPresent());
 515 //
 516 //    // Retrieve the properties map for our edge and make some changes.
 517 //    Map<String, Object> properties = createdEdge.getProperties();
 518 //    properties.put("key4", "value4");
 519 //    properties.remove("key2");
 520 //
 521 //    // Now update the edge with the new properties map.
 522 //    Edge updatedEdge = champDao.updateEdge(createdEdge);
 523 //
 524 //    assertTrue("Edge property list returned from DAO update operation did not contain all expected properties - expected: " +
 525 //            properties.keySet() + " actual: " + updatedEdge.getProperties().keySet(),
 526 //        updatedEdge.getProperties().keySet().containsAll(properties.keySet()));
 527 //
 528 //    // Validate that the values assigned to the properties in the updated Edge
 529 //    // match the ones that we provided when we created it.
 530 //    for (String propertyKey : properties.keySet()) {
 531 //
 532 //      assertTrue("Unexpected value for property '" + propertyKey + "' - Expected: " +
 533 //              properties.get(propertyKey) + "  Actual: " +
 534 //              updatedEdge.getProperties().get(propertyKey),
 535 //          updatedEdge.getProperties().get(propertyKey).equals(properties.get(propertyKey)));
 536 //    }
 537 //
 538 //    // Validate that the property that we removed is NOT in the set of properties from our
 539 //    // updated edge.
 540 //    // *** We will leave this validation commented out for now, as the Champ library actually
 541 //    //     merges update properties instead of replacing them...
 542 ////            assertFalse("Property 'key2' should no longer be associated with updated edge",
 543 ////                                updatedEdge.getProperties().containsKey("key2"));
 544 //  }
 545 //
 546 //  @Test
 547 //  public void deleteEdgeTest() throws CrudException {
 548 //
 549 //    boolean deletedEdgeNotFound = false;
 550 //
 551 //    // Create the source vertex for the edge.
 552 //    Vertex sourceVertex = champDao.addVertex("vserver", MapBuilder.builder()
 553 //        .withKeyValue("O/S", "Linux")
 554 //        .withKeyValue("version", "6.5")
 555 //        .withKeyValue("hostname", "kll0001")
 556 //        .build());
 557 //
 558 //    // Create the target vertex for the edge.
 559 //    Vertex destVertex = champDao.addVertex("VNF", MapBuilder.builder()
 560 //        .withKeyValue("O/S", "Linux")
 561 //        .withKeyValue("version", "6.5")
 562 //        .withKeyValue("hostname", "kll0002")
 563 //        .build());
 564 //
 565 //    // Now, create the edge itself.
 566 //    Edge createdEdge = champDao.addEdge("has",
 567 //        sourceVertex,
 568 //        destVertex,
 569 //        MapBuilder.builder()
 570 //            .withKeyValue("key1", "value1")
 571 //            .withKeyValue("key2", "value2")
 572 //            .withKeyValue("key3", "value3")
 573 //            .build());
 574 //
 575 //    // Verify that we can retrieve the edge that we just created.
 576 //    Edge retrievedEdge = champDao.getEdge(createdEdge.getId().get(), "has");
 577 //
 578 //    // Now, delete it.
 579 //    champDao.deleteEdge(createdEdge.getId().get(), "has");
 580 //
 581 //    // Try retrieving it again.  This time we should not find it.
 582 //    try {
 583 //      champDao.getEdge(createdEdge.getId().get(), "has");
 584 //    } catch (CrudException e) {
 585 //
 586 //      assertTrue(e.getMessage().contains("No edge with id"));
 587 //      deletedEdgeNotFound = true;
 588 //    }
 589 //
 590 //    assertTrue("Should not have been able to retrieve deleted edge.", deletedEdgeNotFound);
 591 //  }
 592 //
 593 //  private boolean containsEdge(Edge anEdge, List<Edge> edges) {
 594 //
 595 //    for (Edge e : edges) {
 596 //      if (e.getId().isPresent() && anEdge.getId().isPresent() && (e.getId().get().equals(anEdge.getId().get()))) {
 597 //        return true;
 598 //      }
 599 //
 600 //    }
 601 //    return false;
 602 //  }
 603 //
 604 //  public static class MapBuilder {
 605 //
 606 //    private Map<String, Object> map;
 607 //
 608 //    private MapBuilder() {
 609 //      map = new HashMap<String, Object>();
 610 //    }
 611 //
 612 //    public static MapBuilder builder() {
 613 //      return new MapBuilder();
 614 //    }
 615 //
 616 //    public MapBuilder withKeyValue(String key, Object value) {
 617 //      map.put(key, value);
 618 //      return this;
 619 //    }
 620 //
 621 //    public Map<String, Object> build() {
 622 //      return map;
 623 //    }
 624 //  }
 625 }