Example #1
0
 @Test
 public void testRelationshipCreateAndDelete() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship relationship = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   Relationship relArray1[] = getRelationshipArray(node1.getRelationships());
   Relationship relArray2[] = getRelationshipArray(node2.getRelationships());
   assertEquals(1, relArray1.length);
   assertEquals(relationship, relArray1[0]);
   assertEquals(1, relArray2.length);
   assertEquals(relationship, relArray2[0]);
   relArray1 = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST));
   assertEquals(1, relArray1.length);
   assertEquals(relationship, relArray1[0]);
   relArray2 = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST));
   assertEquals(1, relArray2.length);
   assertEquals(relationship, relArray2[0]);
   relArray1 = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING));
   assertEquals(1, relArray1.length);
   relArray2 = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.INCOMING));
   assertEquals(1, relArray2.length);
   relArray1 = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.INCOMING));
   assertEquals(0, relArray1.length);
   relArray2 = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.OUTGOING));
   assertEquals(0, relArray2.length);
   relationship.delete();
   node2.delete();
   node1.delete();
 }
Example #2
0
  @Test
  public void testRelationshipChangeProperty() {
    Integer int1 = new Integer(1);
    Integer int2 = new Integer(2);
    String string1 = new String("1");
    String string2 = new String("2");

    Node node1 = getGraphDb().createNode();
    Node node2 = getGraphDb().createNode();
    Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST);
    Relationship rel2 = node2.createRelationshipTo(node1, MyRelTypes.TEST);
    rel1.setProperty(key1, int1);
    rel2.setProperty(key1, string1);
    rel1.setProperty(key2, string2);
    rel2.setProperty(key2, int2);

    try {
      rel1.setProperty(null, null);
      fail("Null argument should result in exception.");
    } catch (IllegalArgumentException e) {
    } catch (NotFoundException e) {
      fail("wrong exception");
    }

    // test type change of exsisting property
    // cannot test this for now because of exceptions in PL
    rel2.setProperty(key1, int1);

    rel1.delete();
    rel2.delete();
    node2.delete();
    node1.delete();
  }
Example #3
0
  @Test
  public void testRelationshipChangeProperty2() {
    Integer int1 = new Integer(1);
    Integer int2 = new Integer(2);
    String string1 = new String("1");
    String string2 = new String("2");
    Boolean bool1 = new Boolean(true);
    Boolean bool2 = new Boolean(false);

    Node node1 = getGraphDb().createNode();
    Node node2 = getGraphDb().createNode();
    Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST);
    rel1.setProperty(key1, int1);
    rel1.setProperty(key1, int2);
    assertEquals(int2, rel1.getProperty(key1));
    rel1.removeProperty(key1);
    rel1.setProperty(key1, string1);
    rel1.setProperty(key1, string2);
    assertEquals(string2, rel1.getProperty(key1));
    rel1.removeProperty(key1);
    rel1.setProperty(key1, bool1);
    rel1.setProperty(key1, bool2);
    assertEquals(bool2, rel1.getProperty(key1));
    rel1.removeProperty(key1);

    rel1.delete();
    node2.delete();
    node1.delete();
  }
 @Test
 public void testRelationshipCahinIterator() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship rels[] = new Relationship[100];
   for (int i = 0; i < rels.length; i++) {
     if (i < 50) {
       rels[i] = node1.createRelationshipTo(node2, MyRelTypes.TEST);
     } else {
       rels[i] = node2.createRelationshipTo(node1, MyRelTypes.TEST);
     }
   }
   newTransaction();
   getNodeManager().clearCache();
   Iterable<Relationship> relIterable = node1.getRelationships();
   for (Relationship rel : rels) {
     rel.delete();
   }
   newTransaction();
   for (Relationship rel : relIterable) {
     System.out.println(rel);
   }
   node1.delete();
   node2.delete();
 }
 @Test
 public void testRelMultiRemoveProperty() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   rel.setProperty("key0", "0");
   rel.setProperty("key1", "1");
   rel.setProperty("key2", "2");
   rel.setProperty("key3", "3");
   rel.setProperty("key4", "4");
   newTransaction();
   rel.removeProperty("key3");
   rel.removeProperty("key2");
   rel.removeProperty("key3");
   newTransaction();
   getNodeManager().clearCache();
   assertEquals("0", rel.getProperty("key0"));
   assertEquals("1", rel.getProperty("key1"));
   assertEquals("4", rel.getProperty("key4"));
   assertTrue(!rel.hasProperty("key2"));
   assertTrue(!rel.hasProperty("key3"));
   rel.delete();
   node1.delete();
   node2.delete();
 }
Example #6
0
 @Test
 public void testSimple3() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   for (int i = 0; i < 1; i++) {
     node1.createRelationshipTo(node2, MyRelTypes.TEST);
     node1.createRelationshipTo(node2, MyRelTypes.TEST_TRAVERSAL);
     node1.createRelationshipTo(node2, MyRelTypes.TEST2);
   }
   allGetRelationshipMethods2(node1, Direction.OUTGOING);
   allGetRelationshipMethods2(node2, Direction.INCOMING);
   newTransaction();
   allGetRelationshipMethods2(node1, Direction.OUTGOING);
   allGetRelationshipMethods2(node2, Direction.INCOMING);
   node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING).iterator().next().delete();
   node1
       .getRelationships(MyRelTypes.TEST_TRAVERSAL, Direction.OUTGOING)
       .iterator()
       .next()
       .delete();
   node1.getRelationships(MyRelTypes.TEST2, Direction.OUTGOING).iterator().next().delete();
   node1.createRelationshipTo(node2, MyRelTypes.TEST);
   node1.createRelationshipTo(node2, MyRelTypes.TEST_TRAVERSAL);
   node1.createRelationshipTo(node2, MyRelTypes.TEST2);
   allGetRelationshipMethods2(node1, Direction.OUTGOING);
   allGetRelationshipMethods2(node2, Direction.INCOMING);
   newTransaction();
   allGetRelationshipMethods2(node1, Direction.OUTGOING);
   allGetRelationshipMethods2(node2, Direction.INCOMING);
   for (Relationship rel : node1.getRelationships()) {
     rel.delete();
   }
   node1.delete();
   node2.delete();
 }
 @After
 public void deleteTestingGraph() {
   Node node1 = getGraphDb().getNodeById(node1Id);
   Node node2 = getGraphDb().getNodeById(node2Id);
   node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH).delete();
   node1.delete();
   node2.delete();
 }
 @Test
 public void testRelCountInSameTx() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   assertEquals(1, getRelationshipArray(node1.getRelationships()).length);
   assertEquals(1, getRelationshipArray(node2.getRelationships()).length);
   rel.delete();
   assertEquals(0, getRelationshipArray(node1.getRelationships()).length);
   assertEquals(0, getRelationshipArray(node2.getRelationships()).length);
   node1.delete();
   node2.delete();
 }
Example #9
0
 @Test
 public void testAddPropertyThenDelete() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   rel.setProperty("test", "test");
   newTransaction();
   rel.setProperty("test2", "test2");
   rel.delete();
   node1.delete();
   node2.delete();
   newTransaction();
 }
Example #10
0
  @Test
  public void testRelationshipRemoveProperty() {
    Integer int1 = new Integer(1);
    Integer int2 = new Integer(2);
    String string1 = new String("1");
    String string2 = new String("2");

    Node node1 = getGraphDb().createNode();
    Node node2 = getGraphDb().createNode();
    Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST);
    Relationship rel2 = node2.createRelationshipTo(node1, MyRelTypes.TEST);
    // verify that we can rely on PL to reomve non existing properties
    try {
      if (rel1.removeProperty(key1) != null) {
        fail("Remove of non existing property should return null");
      }
    } catch (NotFoundException e) {
    }
    try {
      rel1.removeProperty(null);
      fail("Remove null property should throw exception.");
    } catch (IllegalArgumentException e) {
    }

    rel1.setProperty(key1, int1);
    rel2.setProperty(key1, string1);
    rel1.setProperty(key2, string2);
    rel2.setProperty(key2, int2);
    try {
      rel1.removeProperty(null);
      fail("Null argument should result in exception.");
    } catch (IllegalArgumentException e) {
    }

    // test remove property
    assertEquals(int1, rel1.removeProperty(key1));
    assertEquals(string1, rel2.removeProperty(key1));
    // test remove of non exsisting property
    try {
      if (rel2.removeProperty(key1) != null) {
        fail("Remove of non existing property should return null");
      }
    } catch (NotFoundException e) {
      // have to set rollback only here
      getTransaction().failure();
    }
    rel1.delete();
    rel2.delete();
    node1.delete();
    node2.delete();
  }
Example #11
0
 @Test
 public void testDeletedRelationship() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship relationship = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   relationship.delete();
   try {
     relationship.setProperty("key1", new Integer(1));
     fail("Adding property to deleted rel should throw exception.");
   } catch (Exception e) { // good
   }
   node1.delete();
   node2.delete();
 }
Example #12
0
 @Test
 public void testRollbackDeleteRelationship() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   newTransaction();
   node1.delete();
   rel1.delete();
   getTransaction().failure();
   getTransaction().finish();
   setTransaction(getGraphDb().beginTx());
   node1.delete();
   node2.delete();
   rel1.delete();
 }
Example #13
0
  @Test
  public void deletingNodeWithLabelsShouldHaveRemovalReflectedInLabelScans() throws Exception {
    // GIVEN
    Transaction tx = db.beginTx();
    Label label = label("labello");
    Node node = db.createNode(label);
    tx.success();
    tx.finish();

    // AND GIVEN I DELETE IT
    tx = db.beginTx();
    node.delete();
    tx.success();
    tx.finish();

    // WHEN
    tx = db.beginTx();
    Statement statement = statementContextProvider.instance();
    int labelId = statement.readOperations().labelGetForName(label.name());
    PrimitiveLongIterator nodes = statement.readOperations().nodesGetForLabel(labelId);
    Set<Long> nodeSet = asSet(nodes);
    tx.success();
    tx.finish();

    // THEN
    assertThat(nodeSet, equalTo(Collections.<Long>emptySet()));
  }
Example #14
0
  public void removeAll() throws ApplicationException {

    log.info("Removing all nodes and references.");

    Transaction tx = graphDb.beginTx();
    try {
      GlobalGraphOperations ops = GlobalGraphOperations.at(graphDb);

      for (Relationship relationship : ops.getAllRelationships()) {
        relationship.delete();
      }
      for (Node node : ops.getAllNodes()) {
        node.delete();
      }

      tx.success();
      log.info("Deleted all relationships and nodes");

    } catch (Exception e) {
      log.error(e.toString());
      tx.failure();
      throw new ApplicationException(e);
    } finally {
      tx.finish();
    }
  }
Example #15
0
 @Override
 /**
  * Delete a record from the database.
  *
  * @param table The name of the table
  * @param key The record key of the record to delete.
  * @return Zero on success, a non-zero error code on error. See this class's description for a
  *     discussion of error codes.
  */
 public int delete(String table, String key) {
   Transaction tx = gds.beginTx();
   try {
     IndexHits<Node> hits = index().get("_id", key);
     Node node = hits.getSingle();
     index().remove(node);
     node.delete();
     tx.success();
     return 0;
   } catch (Exception e) {
     e.printStackTrace();
     return 1;
   } finally {
     tx.finish();
   }
 }
  @Test
  public void shouldRecoverTransactionWhereNodeIsDeletedInTheFuture() throws Exception {
    // GIVEN
    Node node;
    try (Transaction tx = db.beginTx()) {
      node = db.createNode(label);
      node.setProperty("key", "value");
      tx.success();
    }
    rotateLog();
    try (Transaction tx = db.beginTx()) {
      node.setProperty("other-key", 1);
      tx.success();
    }
    try (Transaction tx = db.beginTx()) {
      node.delete();
      tx.success();
    }
    flushAll();

    // WHEN
    FileSystemAbstraction uncleanFs = fsRule.snapshot(shutdownDb(db));
    db =
        (GraphDatabaseAPI)
            new TestGraphDatabaseFactory().setFileSystem(uncleanFs).newImpermanentDatabase();

    // THEN
    // -- really the problem was that recovery threw exception, so mostly assert that.
    try (Transaction tx = db.beginTx()) {
      node = db.getNodeById(node.getId());
      fail("Should not exist");
    } catch (NotFoundException e) {
      assertEquals("Node " + node.getId() + " not found", e.getMessage());
    }
  }
 public void delete(ConstructionZoneNode zone) {
   Node n = zone.getNode();
   for (Relationship rel : n.getRelationships()) {
     rel.delete();
   }
   n.delete();
 }
  @Test
  public void removeNodesWithARelation() {
    int originalNodeCount = countNodesOf(graphDb);
    int removedNodeCount = 0;

    Transaction tx = graphDb.beginTx();
    try {
      Set<Node> toRemove = new HashSet<Node>();
      for (Node node : graphDb.getAllNodes()) {
        for (Relationship relationship : node.getRelationships(RelationType.ON)) {
          toRemove.add(relationship.getStartNode());
          toRemove.add(relationship.getEndNode());
          relationship.delete();
        }
      }
      for (Node node : toRemove) {
        node.delete();
        removedNodeCount++;
      }
      tx.success();
    } finally {
      tx.finish();
    }

    int finalNodeCount = countNodesOf(graphDb);
    assertEquals(
        Integer.valueOf(originalNodeCount), Integer.valueOf(finalNodeCount + removedNodeCount));
  }
Example #19
0
  private void createSomeTransactions(GraphDatabaseService db) {
    Transaction tx = db.beginTx();
    Node node1 = db.createNode();
    Node node2 = db.createNode();
    node1.createRelationshipTo(node2, DynamicRelationshipType.withName("relType1"));
    tx.success();
    tx.finish();

    tx = db.beginTx();
    node1.delete();
    tx.success();
    try {
      // Will throw exception, causing the tx to be rolledback.
      tx.finish();
    } catch (Exception nothingToSeeHereMoveAlong) {
      // InvalidRecordException coming, node1 has rels
    }
    /*
     *  The damage has already been done. The following just makes sure
     *  the corrupting tx is flushed to disk, since we will exit
     *  uncleanly.
     */
    tx = db.beginTx();
    node1.setProperty("foo", "bar");
    tx.success();
    tx.finish();
  }
  /**
   * Removes all nodes with non-valid resource classes from the graph.
   *
   * @param docGraph
   * @param validResourceClasses
   */
  private void preProcessGraph(DocGraph docGraph, Set<String> validResourceClasses) {
    log.info(String.format("Preprocessing DocGraph[%d]", docGraph.getId()));
    Node n;
    int cnt = 0;
    try (Transaction tx = graphDB.beginTx()) {
      for (Long nodeId : docGraph.getNodes()) {
        n = graphDB.getNodeById(nodeId);
        // node's class is resource class and it's not in the valid set
        if (n.hasProperty(Constants.NODE_SUPER_CLASS_KEY)
            && n.getProperty(Constants.NODE_SUPER_CLASS_KEY)
                .equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)
            && !validResourceClasses.contains(getNodeClass(n))) {
          try (Transaction innerTx = graphDB.beginTx()) {

            log.info("Deleting " + n);
            for (Relationship e : n.getRelationships()) {
              e.delete();
            }
            n.delete();
            innerTx.success();
            cnt++;
          }
        }
      }
      tx.success();
    }

    log.info(
        String.format("Preprocessing removed %d nodes from DocGraph[%d]", cnt, docGraph.getId()));
  }
 /*
  * It will remove a property from an embedded node if it exists.
  * After deleting the property, if the node does not have any more properties and relationships (except for an incoming one),
  * it will delete the embedded node as well.
  */
 private void removePropertyForEmbedded(Node embeddedNode, String[] embeddedColumnSplit, int i) {
   if (i == embeddedColumnSplit.length - 1) {
     // Property
     String property = embeddedColumnSplit[embeddedColumnSplit.length - 1];
     if (embeddedNode.hasProperty(property)) {
       embeddedNode.removeProperty(property);
     }
   } else {
     Iterator<Relationship> iterator =
         embeddedNode
             .getRelationships(Direction.OUTGOING, withName(embeddedColumnSplit[i]))
             .iterator();
     if (iterator.hasNext()) {
       removePropertyForEmbedded(iterator.next().getEndNode(), embeddedColumnSplit, i + 1);
     }
   }
   if (!embeddedNode.getPropertyKeys().iterator().hasNext()) {
     // Node without properties
     Iterator<Relationship> iterator = embeddedNode.getRelationships().iterator();
     if (iterator.hasNext()) {
       Relationship relationship = iterator.next();
       if (!iterator.hasNext()) {
         // Node with only one relationship and no properties,
         // we can remove it:
         // It means we have removed all the properties from the embedded node
         // and it is NOT an intermediate node like
         // (entity) --> (embedded1) --> (embedded2)
         relationship.delete();
         embeddedNode.delete();
       }
     }
   }
 }
  public void testIt() throws Exception {
    String key = "mykey";
    String value = "myvalue";
    Collection<Node> nodes = new ArrayList<Node>();
    for (int i = 0; i < 20000; i++) {
      Node node = graphDb().createNode();
      indexService.index(node, key, value);
      nodes.add(node);
      if (i == 2000) {
        Iterable<Node> itr = indexService.getNodes(key, value);
        assertCollection(asCollection(itr), nodes.toArray(new Node[0]));
      }

      if (i % 10000 == 0) {
        restartTx();
      }
    }
    restartTx();

    Node[] nodeArray = nodes.toArray(new Node[0]);
    long total = 0;
    long totalTotal = 0;
    int counter = 0;
    for (int i = 0; i < 10; i++) {
      // So that it'll get the nodes in the synchronous way
      ((LuceneIndexService) indexService).setLazySearchResultThreshold(nodes.size() + 10);
      long time = System.currentTimeMillis();
      Iterable<Node> itr = indexService.getNodes(key, value);
      long syncTime = System.currentTimeMillis() - time;
      assertCollection(asCollection(itr), nodeArray);
      long syncTotalTime = System.currentTimeMillis() - time;

      // So that it'll get the nodes in the lazy way
      ((LuceneIndexService) indexService).setLazySearchResultThreshold(nodes.size() - 10);
      time = System.currentTimeMillis();
      itr = indexService.getNodes(key, value);
      long lazyTime = System.currentTimeMillis() - time;
      assertCollection(asCollection(itr), nodeArray);
      long lazyTotalTime = System.currentTimeMillis() - time;
      //            System.out.println( "lazy:" + lazyTime + " (" + lazyTotalTime +
      //                "), sync:" + syncTime + " (" + syncTotalTime + ")" );

      if (i > 0) {
        total += syncTime;
        totalTotal += syncTotalTime;
        counter++;
      }

      // At the very least
      assertTrue(lazyTime < syncTime / 3);
    }

    //        System.out.println( "avg:" + ( total / counter ) + ", " +
    //            ( totalTotal / counter ) );

    for (Node node : nodes) {
      node.delete();
    }
  }
Example #23
0
 @Test
 public void testCreateRelationshipWithCommitts() // throws NotFoundException
     {
   Node n1 = getGraphDb().createNode();
   newTransaction();
   clearCache();
   n1 = getGraphDb().getNodeById((int) n1.getId());
   Node n2 = getGraphDb().createNode();
   n1.createRelationshipTo(n2, MyRelTypes.TEST);
   newTransaction();
   Relationship[] relArray = getRelationshipArray(n1.getRelationships());
   assertEquals(1, relArray.length);
   relArray = getRelationshipArray(n1.getRelationships());
   relArray[0].delete();
   n1.delete();
   n2.delete();
 }
 @Override
 protected void doSomething() throws Throwable {
   Pair<Integer, Node> pair = getNode(random, true);
   int index = pair.first();
   Node node = pair.other();
   node.delete();
   setNode(index, db.createNode());
 }
Example #25
0
 @Test
 public void testDeleteWithRelationship() {
   // do some evil stuff
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship relationship = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   node1.delete();
   node2.delete();
   try {
     getTransaction().success();
     getTransaction().finish();
     fail("deleting node with relaitonship should not commit.");
   } catch (Exception e) {
     // good
   }
   setTransaction(getGraphDb().beginTx());
 }
Example #26
0
 public void removeVertex(final Vertex vertex) {
   this.autoStartTransaction();
   final Node node = ((Neo4jVertex) vertex).getRawVertex();
   for (final Relationship relationship :
       node.getRelationships(org.neo4j.graphdb.Direction.BOTH)) {
     relationship.delete();
   }
   node.delete();
 }
Example #27
0
 @Test
 public void testRelationshipIsType() {
   Node node1 = getGraphDb().createNode();
   Node node2 = getGraphDb().createNode();
   Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST);
   assertTrue(rel.isType(MyRelTypes.TEST));
   assertTrue(
       rel.isType(
           new RelationshipType() {
             public String name() {
               return MyRelTypes.TEST.name();
             }
           }));
   assertFalse(rel.isType(MyRelTypes.TEST_TRAVERSAL));
   rel.delete();
   node1.delete();
   node2.delete();
 }
  @Test
  public void testTxCacheLoadIsolation() throws Exception {
    Node node = getGraphDb().createNode();
    node.setProperty("someproptest", "testing");
    Node node1 = getGraphDb().createNode();
    node1.setProperty("someotherproptest", 2);
    commit();
    EmbeddedGraphDatabase graphDb = (EmbeddedGraphDatabase) getGraphDb();
    TransactionManager txManager = graphDb.getConfig().getTxModule().getTxManager();
    NodeManager nodeManager = graphDb.getConfig().getGraphDbModule().getNodeManager();

    txManager.begin();
    node.setProperty("someotherproptest", "testing2");
    Relationship rel = node.createRelationshipTo(node1, MyRelTypes.TEST);
    javax.transaction.Transaction txA = txManager.suspend();
    txManager.begin();
    assertEquals("testing", node.getProperty("someproptest"));
    assertTrue(!node.hasProperty("someotherproptest"));
    assertTrue(!node.hasRelationship());
    nodeManager.clearCache();
    assertEquals("testing", node.getProperty("someproptest"));
    assertTrue(!node.hasProperty("someotherproptest"));
    javax.transaction.Transaction txB = txManager.suspend();
    txManager.resume(txA);
    assertEquals("testing", node.getProperty("someproptest"));
    assertTrue(node.hasProperty("someotherproptest"));
    assertTrue(node.hasRelationship());
    nodeManager.clearCache();
    assertEquals("testing", node.getProperty("someproptest"));
    assertTrue(node.hasProperty("someotherproptest"));
    assertTrue(node.hasRelationship());
    txManager.suspend();
    txManager.resume(txB);
    assertEquals("testing", node.getProperty("someproptest"));
    assertTrue(!node.hasProperty("someotherproptest"));
    assertTrue(!node.hasRelationship());
    txManager.rollback();
    txManager.resume(txA);
    node.delete();
    node1.delete();
    rel.delete();
    txManager.commit();
    newTransaction();
  }
  @Test
  public void testIndexedSet() throws Exception {
    Node rootNode = graphDb().createNode();
    Collection<AnItem> collection =
        new SortedNodeCollection<AnItem>(rootNode, new AnItemComparator(), AnItem.class);

    List<String> strings =
        new ArrayList<String>(
            Arrays.asList(
                "Mattias",
                "Persson",
                "Went",
                "And",
                "Implemented",
                "An",
                "Indexed",
                "GraphDb",
                "Set",
                "And",
                "How",
                "About",
                "That"));

    for (String string : strings) {
      assertTrue(collection.add(new AnItem(string)));
    }

    // Compare the indexed node collection against a natural sorting order
    Collections.sort(strings);
    assertCollectionSame(strings, collection);

    String toRemove = "Persson";
    AnItem toRemoveItem = findItem(collection, toRemove);
    assertTrue(collection.remove(toRemoveItem));
    assertTrue(strings.remove(toRemove));
    assertCollectionSame(strings, collection);

    collection.clear();
    ((SortedNodeCollection<AnItem>) collection).delete();
    rootNode.delete();
    for (Node node : AnItem.createdNodes) {
      node.delete();
    }
  }
 @Test(expected = org.neo4j.graphdb.NotFoundException.class)
 public void testDeleteNode() {
   final Transaction tx = restAPI.beginTx();
   Node n1 = restAPI.createNode(map("name", "node1"));
   n1.delete();
   Node n2 = restAPI.createNode(map("name", "node2"));
   tx.success();
   tx.finish();
   loadRealNode(n1);
 }