Examples with Node org.neo4j.graphdb.Node used on opensource projects

Example 31 with Node

use of org.neo4j.graphdb.Node in project neo4j by neo4j.

the class UniqueFactoryTest method shouldNotTouchTransactionsIfAlreadyInIndex.

@Test
public void shouldNotTouchTransactionsIfAlreadyInIndex() {
    GraphDatabaseService graphdb = mock(GraphDatabaseService.class);
    @SuppressWarnings("unchecked") Index<Node> index = mock(Index.class);
    when(index.getGraphDatabase()).thenReturn(graphdb);
    @SuppressWarnings("unchecked") IndexHits<Node> getHits = mock(IndexHits.class);
    when(index.get("key1", "value1")).thenReturn(getHits);
    Node indexedNode = mock(Node.class);
    when(getHits.getSingle()).thenReturn(indexedNode);
    UniqueFactory.UniqueNodeFactory unique = new UniqueFactory.UniqueNodeFactory(index) {

        @Override
        protected void initialize(Node created, Map<String, Object> properties) {
            fail("we did not create the node, so it should not be initialized");
        }
    };
    // when
    Node node = unique.getOrCreate("key1", "value1");
    // then
    assertSame(node, indexedNode);
    verify(index).get("key1", "value1");
}

Example 32 with Node

use of org.neo4j.graphdb.Node in project neo4j by neo4j.

the class SchemaImplTest method testGetIndexPopulationProgress.

@Test
public void testGetIndexPopulationProgress() throws Exception {
    assertFalse(indexExists(Label.label("User")));
    // Create some nodes
    try (Transaction tx = db.beginTx()) {
        Label label = Label.label("User");
        // Create a huge bunch of users so the index takes a while to build
        for (int id = 0; id < 100000; id++) {
            Node userNode = db.createNode(label);
            userNode.setProperty("username", "user" + id + "@neo4j.org");
        }
        tx.success();
    }
    // Create an index
    IndexDefinition indexDefinition;
    try (Transaction tx = db.beginTx()) {
        Schema schema = db.schema();
        indexDefinition = schema.indexFor(Label.label("User")).on("username").create();
        tx.success();
    }
    // Get state and progress
    try (Transaction tx = db.beginTx()) {
        Schema schema = db.schema();
        Schema.IndexState state;
        IndexPopulationProgress progress;
        do {
            state = schema.getIndexState(indexDefinition);
            progress = schema.getIndexPopulationProgress(indexDefinition);
            assertTrue(progress.getCompletedPercentage() >= 0);
            assertTrue(progress.getCompletedPercentage() <= 100);
            Thread.sleep(10);
        } while (state == Schema.IndexState.POPULATING);
        assertTrue(state == Schema.IndexState.ONLINE);
        assertEquals(100.0f, progress.getCompletedPercentage(), 0.0f);
    }
}

Example 33 with Node

use of org.neo4j.graphdb.Node in project neo4j by neo4j.

the class ExpectedTransactionData method compareTo.

void compareTo(TransactionData data) {
    Set<Node> expectedCreatedNodes = new HashSet<>(this.expectedCreatedNodes);
    Set<Relationship> expectedCreatedRelationships = new HashSet<>(this.expectedCreatedRelationships);
    Set<Node> expectedDeletedNodes = new HashSet<Node>(this.expectedDeletedNodes);
    Set<Relationship> expectedDeletedRelationships = new HashSet<>(this.expectedDeletedRelationships);
    Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedAssignedNodeProperties = clone(this.expectedAssignedNodeProperties);
    Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedAssignedRelationshipProperties = clone(this.expectedAssignedRelationshipProperties);
    Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedRemovedNodeProperties = clone(this.expectedRemovedNodeProperties);
    Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedRemovedRelationshipProperties = clone(this.expectedRemovedRelationshipProperties);
    Map<Node, Set<String>> expectedAssignedLabels = cloneLabelData(this.expectedAssignedLabels);
    Map<Node, Set<String>> expectedRemovedLabels = cloneLabelData(this.expectedRemovedLabels);
    for (Node node : data.createdNodes()) {
        assertTrue(expectedCreatedNodes.remove(node));
        assertFalse(data.isDeleted(node));
    }
    assertTrue("Expected some created nodes that weren't seen: " + expectedCreatedNodes, expectedCreatedNodes.isEmpty());
    for (Relationship rel : data.createdRelationships()) {
        assertTrue(expectedCreatedRelationships.remove(rel));
        assertFalse(data.isDeleted(rel));
    }
    assertTrue("Expected created relationships not encountered " + expectedCreatedRelationships, expectedCreatedRelationships.isEmpty());
    for (Node node : data.deletedNodes()) {
        assertTrue("Unexpected deleted node " + node, expectedDeletedNodes.remove(node));
        assertTrue(data.isDeleted(node));
    }
    assertTrue("Expected deleted nodes: " + expectedDeletedNodes, expectedDeletedNodes.isEmpty());
    for (Relationship rel : data.deletedRelationships()) {
        assertTrue(expectedDeletedRelationships.remove(rel));
        assertTrue(data.isDeleted(rel));
    }
    assertTrue("Expected deleted relationships not encountered " + expectedDeletedRelationships, expectedDeletedRelationships.isEmpty());
    for (PropertyEntry<Node> entry : data.assignedNodeProperties()) {
        checkAssigned(expectedAssignedNodeProperties, entry);
        assertFalse(data.isDeleted(entry.entity()));
    }
    assertTrue("Expected assigned node properties not encountered " + expectedAssignedNodeProperties, expectedAssignedNodeProperties.isEmpty());
    for (PropertyEntry<Relationship> entry : data.assignedRelationshipProperties()) {
        checkAssigned(expectedAssignedRelationshipProperties, entry);
        assertFalse(data.isDeleted(entry.entity()));
    }
    assertTrue("Expected assigned relationship properties not encountered " + expectedAssignedRelationshipProperties, expectedAssignedRelationshipProperties.isEmpty());
    for (PropertyEntry<Node> entry : data.removedNodeProperties()) {
        checkRemoved(expectedRemovedNodeProperties, entry);
    }
    assertTrue("Expected removed node properties not encountered " + expectedRemovedNodeProperties, expectedRemovedNodeProperties.isEmpty());
    for (PropertyEntry<Relationship> entry : data.removedRelationshipProperties()) {
        checkRemoved(expectedRemovedRelationshipProperties, entry);
    }
    assertTrue("Expected removed relationship properties not encountered " + expectedRemovedRelationshipProperties, expectedRemovedRelationshipProperties.isEmpty());
    for (LabelEntry entry : data.assignedLabels()) {
        check(expectedAssignedLabels, entry);
    }
    assertTrue("Expected assigned labels not encountered " + expectedAssignedLabels, expectedAssignedLabels.isEmpty());
    for (LabelEntry entry : data.removedLabels()) {
        check(expectedRemovedLabels, entry);
    }
    assertTrue("Expected removed labels not encountered " + expectedRemovedLabels, expectedRemovedLabels.isEmpty());
}

Example 34 with Node

use of org.neo4j.graphdb.Node in project neo4j by neo4j.

the class TestTransactionEvents method shouldAccessAssignedLabels.

@Test
public void shouldAccessAssignedLabels() throws Exception {
    // given
    GraphDatabaseService db = dbRule.getGraphDatabaseAPI();
    ChangedLabels labels = (ChangedLabels) db.registerTransactionEventHandler(new ChangedLabels());
    try {
        // when
        try (Transaction tx = db.beginTx()) {
            Node node1 = db.createNode(), node2 = db.createNode(), node3 = db.createNode();
            labels.add(node1, "Foo");
            labels.add(node2, "Bar");
            labels.add(node3, "Baz");
            labels.add(node3, "Bar");
            labels.activate();
            tx.success();
        }
        // then
        assertTrue(labels.isEmpty());
    } finally {
        db.unregisterTransactionEventHandler(labels);
    }
}

Example 35 with Node

use of org.neo4j.graphdb.Node in project neo4j by neo4j.

the class TestTransactionEvents method shouldGetCorrectTransactionDataUponCommit.

@Test
public void shouldGetCorrectTransactionDataUponCommit() {
    // Create new data, nothing modified, just added/created
    ExpectedTransactionData expectedData = new ExpectedTransactionData();
    VerifyingTransactionEventHandler handler = new VerifyingTransactionEventHandler(expectedData);
    GraphDatabaseService db = dbRule.getGraphDatabaseAPI();
    db.registerTransactionEventHandler(handler);
    Node node1, node2, node3;
    Relationship rel1, rel2;
    try {
        try (Transaction tx = db.beginTx()) {
            node1 = db.createNode();
            expectedData.expectedCreatedNodes.add(node1);
            node2 = db.createNode();
            expectedData.expectedCreatedNodes.add(node2);
            rel1 = node1.createRelationshipTo(node2, RelTypes.TXEVENT);
            expectedData.expectedCreatedRelationships.add(rel1);
            node1.setProperty("name", "Mattias");
            expectedData.assignedProperty(node1, "name", "Mattias", null);
            node1.setProperty("last name", "Persson");
            expectedData.assignedProperty(node1, "last name", "Persson", null);
            node1.setProperty("counter", 10);
            expectedData.assignedProperty(node1, "counter", 10, null);
            rel1.setProperty("description", "A description");
            expectedData.assignedProperty(rel1, "description", "A description", null);
            rel1.setProperty("number", 4.5D);
            expectedData.assignedProperty(rel1, "number", 4.5D, null);
            node3 = db.createNode();
            expectedData.expectedCreatedNodes.add(node3);
            rel2 = node3.createRelationshipTo(node2, RelTypes.TXEVENT);
            expectedData.expectedCreatedRelationships.add(rel2);
            node3.setProperty("name", "Node 3");
            expectedData.assignedProperty(node3, "name", "Node 3", null);
            tx.success();
        }
        assertTrue("Should have been invoked", handler.hasBeenCalled());
        Throwable failure = handler.failure();
        if (failure != null) {
            throw new RuntimeException(failure);
        }
    } finally {
        db.unregisterTransactionEventHandler(handler);
    }
    // Use the above data and modify it, change properties, delete stuff
    expectedData = new ExpectedTransactionData();
    handler = new VerifyingTransactionEventHandler(expectedData);
    db.registerTransactionEventHandler(handler);
    try {
        try (Transaction tx = db.beginTx()) {
            Node newNode = db.createNode();
            expectedData.expectedCreatedNodes.add(newNode);
            Node tempNode = db.createNode();
            Relationship tempRel = tempNode.createRelationshipTo(node1, RelTypes.TXEVENT);
            tempNode.setProperty("something", "Some value");
            tempRel.setProperty("someproperty", 101010);
            tempNode.removeProperty("nothing");
            node3.setProperty("test", "hello");
            node3.setProperty("name", "No name");
            node3.delete();
            expectedData.expectedDeletedNodes.add(node3);
            expectedData.removedProperty(node3, "name", "Node 3");
            node1.setProperty("new name", "A name");
            node1.setProperty("new name", "A better name");
            expectedData.assignedProperty(node1, "new name", "A better name", null);
            node1.setProperty("name", "Nothing");
            node1.setProperty("name", "Mattias Persson");
            expectedData.assignedProperty(node1, "name", "Mattias Persson", "Mattias");
            node1.removeProperty("counter");
            expectedData.removedProperty(node1, "counter", 10);
            node1.removeProperty("last name");
            node1.setProperty("last name", "Hi");
            expectedData.assignedProperty(node1, "last name", "Hi", "Persson");
            rel2.delete();
            expectedData.expectedDeletedRelationships.add(rel2);
            rel1.removeProperty("number");
            expectedData.removedProperty(rel1, "number", 4.5D);
            rel1.setProperty("description", "Ignored");
            rel1.setProperty("description", "New");
            expectedData.assignedProperty(rel1, "description", "New", "A description");
            tempRel.delete();
            tempNode.delete();
            tx.success();
        }
        assertTrue("Should have been invoked", handler.hasBeenCalled());
        Throwable failure = handler.failure();
        if (failure != null) {
            throw new RuntimeException(failure);
        }
    } finally {
        db.unregisterTransactionEventHandler(handler);
    }
}