@Test
public void testRelationshipAutoIndexFromAPISanity() {
final String propNameToIndex = "test";
AutoIndexer<Relationship> autoIndexer = graphDb.index().getRelationshipAutoIndexer();
autoIndexer.startAutoIndexingProperty(propNameToIndex);
autoIndexer.setEnabled(true);
newTransaction();
Node node1 = graphDb.createNode();
Node node2 = graphDb.createNode();
Node node3 = graphDb.createNode();
Relationship rel12 =
node1.createRelationshipTo(node2, DynamicRelationshipType.withName("DYNAMIC"));
Relationship rel23 =
node2.createRelationshipTo(node3, DynamicRelationshipType.withName("DYNAMIC"));
rel12.setProperty(propNameToIndex, "rel12");
rel23.setProperty(propNameToIndex, "rel23");
newTransaction();
assertEquals(rel12, autoIndexer.getAutoIndex().get(propNameToIndex, "rel12").getSingle());
assertEquals(rel23, autoIndexer.getAutoIndex().get(propNameToIndex, "rel23").getSingle());
}
@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();
}
@Before
public void createTestingGraph() {
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST);
node1Id = (int) node1.getId();
node2Id = (int) node2.getId();
node1.setProperty(key1, int1);
node1.setProperty(key2, string1);
node2.setProperty(key1, int2);
node2.setProperty(key2, string2);
rel.setProperty(key1, int1);
rel.setProperty(key2, string1);
node1.setProperty(arrayKey, array);
node2.setProperty(arrayKey, array);
rel.setProperty(arrayKey, array);
Transaction tx = getTransaction();
tx.success();
tx.finish();
NodeManager nodeManager =
((EmbeddedGraphDatabase) getGraphDb()).getConfig().getGraphDbModule().getNodeManager();
nodeManager.clearCache();
tx = getGraphDb().beginTx();
setTransaction(tx);
}
@Test
public void testRelationshipAddProperty() {
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST);
Relationship rel2 = node2.createRelationshipTo(node1, MyRelTypes.TEST);
try {
rel1.setProperty(null, null);
fail("Null argument should result in exception.");
} catch (IllegalArgumentException e) {
}
Integer int1 = new Integer(1);
Integer int2 = new Integer(2);
String string1 = new String("1");
String string2 = new String("2");
// add property
rel1.setProperty(key1, int1);
rel2.setProperty(key1, string1);
rel1.setProperty(key2, string2);
rel2.setProperty(key2, int2);
assertTrue(rel1.hasProperty(key1));
assertTrue(rel2.hasProperty(key1));
assertTrue(rel1.hasProperty(key2));
assertTrue(rel2.hasProperty(key2));
assertTrue(!rel1.hasProperty(key3));
assertTrue(!rel2.hasProperty(key3));
assertEquals(int1, rel1.getProperty(key1));
assertEquals(string1, rel2.getProperty(key1));
assertEquals(string2, rel1.getProperty(key2));
assertEquals(int2, rel2.getProperty(key2));
getTransaction().failure();
}
private void addMutantToDB(
Individual original, Individual mutant, int generationNumber, Location location) {
final GraphDatabaseService graphDB = GraphDB.graphDB();
IndexManager index = graphDB.index();
Index<Node> individualNodes = index.forNodes("individuals");
Index<Node> locationNodes = index.forNodes("locations");
Transaction tx = graphDB.beginTx();
Relationship mutantRelationship;
Relationship node;
Node individualNode;
try {
individualNode = graphDB.createNode();
individualNode.setProperty("fitness", mutant.getGlobalFitness());
individualNode.setProperty("id", mutant.uid.toString());
Node locationNode = locationNodes.get("locationID", location.getPosition()).next();
node = individualNode.createRelationshipTo(locationNode, RelTypes.LOCATEDIN);
node.setProperty("generation", generationNumber);
Node originalNode = individualNodes.get("id", original.uid.toString()).next();
mutantRelationship = individualNode.createRelationshipTo(originalNode, RelTypes.MUTANTOF);
mutantRelationship.setProperty("generation", generationNumber);
individualNodes.add(individualNode, "id", mutant.uid.toString());
tx.success();
} finally {
tx.finish();
}
}
@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();
}
public void rn() throws IOException {
List<RoadLink> links = loadToDatabase("/Users/duduba/gj.mif", "/Users/duduba/gj.mid", false);
GraphDatabaseService graphDb = neo.getDb();
Index<Node> nodeIndex = neo.getNodeIndex();
for (RoadLink link : links) {
Transaction tx = graphDb.beginTx();
try {
Node fromNode = nodeIndex.get("id", link.fromNode).getSingle();
if (fromNode == null) {
fromNode = graphDb.createNode();
fromNode.setProperty("id", link.fromNode);
nodeIndex.add(fromNode, "id", link.fromNode);
}
Node toNode = nodeIndex.get("id", link.toNode).getSingle();
if (toNode == null) {
toNode = graphDb.createNode();
toNode.setProperty("id", link.toNode);
nodeIndex.add(toNode, "id", link.toNode);
}
Relationship r = fromNode.createRelationshipTo(toNode, Neo.RelTypes.TO);
r.setProperty("no", link.no);
r.setProperty("name", link.name);
tx.success();
} finally {
tx.finish();
}
}
logger.debug("haha, it's ok!");
}
@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();
}
@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();
}
@Test
public void shouldProvideTheCorrectRelationshipData() {
GraphDatabaseService db = dbRule.getGraphDatabaseService();
// create a rel type so the next type id is non zero
try (Transaction tx = db.beginTx()) {
db.createNode()
.createRelationshipTo(db.createNode(), DynamicRelationshipType.withName("TYPE"));
}
RelationshipType livesIn = DynamicRelationshipType.withName("LIVES_IN");
long relId;
try (Transaction tx = db.beginTx()) {
Node person = db.createNode(DynamicLabel.label("Person"));
Node city = db.createNode(DynamicLabel.label("City"));
Relationship rel = person.createRelationshipTo(city, livesIn);
rel.setProperty("since", 2009);
relId = rel.getId();
tx.success();
}
final Set<String> changedRelationships = new HashSet<>();
db.registerTransactionEventHandler(
new TransactionEventHandler.Adapter<Void>() {
@Override
public Void beforeCommit(TransactionData data) throws Exception {
for (PropertyEntry<Relationship> entry : data.assignedRelationshipProperties()) {
changedRelationships.add(entry.entity().getType().name());
}
return null;
}
});
try (Transaction tx = db.beginTx()) {
Relationship rel = db.getRelationshipById(relId);
rel.setProperty("since", 2010);
tx.success();
}
assertEquals(1, changedRelationships.size());
assertTrue(
livesIn + " not in " + changedRelationships.toString(),
changedRelationships.contains(livesIn.name()));
}
@Test
public void testNodeChangeProperty() {
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
// test change property
node1.setProperty(key1, int2);
node2.setProperty(key1, int1);
rel.setProperty(key1, int2);
int[] newIntArray = new int[] {3, 2, 1};
node1.setProperty(arrayKey, newIntArray);
node2.setProperty(arrayKey, newIntArray);
rel.setProperty(arrayKey, newIntArray);
}
private void putAssociationOperation(
Association association,
AssociationKey associationKey,
AssociationOperation action,
AssociatedEntityKeyMetadata associatedEntityKeyMetadata) {
Relationship relationship =
associationQueries
.get(associationKey.getMetadata())
.findRelationship(dataBase, associationKey, action.getKey());
if (relationship != null) {
for (String relationshipProperty : associationKey.getMetadata().getRowKeyIndexColumnNames()) {
relationship.setProperty(relationshipProperty, action.getValue().get(relationshipProperty));
}
for (String column :
associationKey
.getMetadata()
.getColumnsWithoutKeyColumns(action.getValue().getColumnNames())) {
if (!isRowKeyColumn(associationKey.getMetadata(), column)) {
relationship.getEndNode().setProperty(column, action.getValue().get(column));
}
}
GraphLogger.log("Updated relationship: %1$s", relationship);
} else {
relationship =
createRelationship(associationKey, action.getValue(), associatedEntityKeyMetadata);
GraphLogger.log("Created relationship: %1$s", relationship);
}
}
@Test
public void shouldBeAbleToGetPropertiesOnRelationship() throws Exception {
long relationshipId;
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("foo", "bar");
properties.put("neo", "Thomas A. Anderson");
properties.put("number", 15L);
Transaction tx = database.getGraph().beginTx();
try {
Node startNode = database.getGraph().createNode();
Node endNode = database.getGraph().createNode();
Relationship relationship =
startNode.createRelationshipTo(endNode, DynamicRelationshipType.withName("knows"));
for (Map.Entry<String, Object> entry : properties.entrySet()) {
relationship.setProperty(entry.getKey(), entry.getValue());
}
relationshipId = relationship.getId();
tx.success();
} finally {
tx.finish();
}
Map<String, Object> readProperties =
serialize(actions.getAllRelationshipProperties(relationshipId));
assertEquals(properties, readProperties);
}
@Test
public void testRemoveRelationshipRemovesDocument() {
AutoIndexer<Relationship> autoIndexer = graphDb.index().getRelationshipAutoIndexer();
autoIndexer.startAutoIndexingProperty("foo");
autoIndexer.setEnabled(true);
newTransaction();
Node node1 = graphDb.createNode();
Node node2 = graphDb.createNode();
Relationship rel = node1.createRelationshipTo(node2, DynamicRelationshipType.withName("foo"));
rel.setProperty("foo", "bar");
newTransaction();
assertThat(
graphDb.index().forRelationships("relationship_auto_index").query("_id_:*").size(),
equalTo(1));
newTransaction();
rel.delete();
newTransaction();
assertThat(
graphDb.index().forRelationships("relationship_auto_index").query("_id_:*").size(),
equalTo(0));
}
@Test
public void testDefaultsAreSeparateForNodesAndRelationships() throws Exception {
stopDb();
config = new HashMap<>();
config.put(GraphDatabaseSettings.node_keys_indexable.name(), "propName");
config.put(GraphDatabaseSettings.node_auto_indexing.name(), "true");
// Now only node properties named propName should be indexed.
startDb();
newTransaction();
Node node1 = graphDb.createNode();
Node node2 = graphDb.createNode();
node1.setProperty("propName", "node1");
node2.setProperty("propName", "node2");
node2.setProperty("propName_", "node2");
Relationship rel =
node1.createRelationshipTo(node2, DynamicRelationshipType.withName("DYNAMIC"));
rel.setProperty("propName", "rel1");
newTransaction();
ReadableIndex<Node> autoIndex = graphDb.index().getNodeAutoIndexer().getAutoIndex();
assertEquals(node1, autoIndex.get("propName", "node1").getSingle());
assertEquals(node2, autoIndex.get("propName", "node2").getSingle());
assertFalse(
graphDb
.index()
.getRelationshipAutoIndexer()
.getAutoIndex()
.get("propName", "rel1")
.hasNext());
}
@Test
public void testAddProperty() {
String key3 = "key3";
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
// add new property
node2.setProperty(key3, int1);
rel.setProperty(key3, int2);
assertTrue(node1.hasProperty(key1));
assertTrue(node2.hasProperty(key1));
assertTrue(node1.hasProperty(key2));
assertTrue(node2.hasProperty(key2));
assertTrue(node1.hasProperty(arrayKey));
assertTrue(node2.hasProperty(arrayKey));
assertTrue(rel.hasProperty(arrayKey));
assertTrue(!node1.hasProperty(key3));
assertTrue(node2.hasProperty(key3));
assertEquals(int1, node1.getProperty(key1));
assertEquals(int2, node2.getProperty(key1));
assertEquals(string1, node1.getProperty(key2));
assertEquals(string2, node2.getProperty(key2));
assertEquals(int1, rel.getProperty(key1));
assertEquals(string1, rel.getProperty(key2));
assertEquals(int2, rel.getProperty(key3));
}
@Test
public void testChangeProperty() {
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST);
rel.setProperty("test", "test1");
newTransaction();
rel.setProperty("test", "test2");
rel.removeProperty("test");
rel.setProperty("test", "test3");
assertEquals("test3", rel.getProperty("test"));
rel.removeProperty("test");
rel.setProperty("test", "test4");
newTransaction();
assertEquals("test4", rel.getProperty("test"));
}
private long createDb() {
GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH);
long firstNodeId = -1;
Transaction tx = graphDb.beginTx();
try {
Node firstNode = graphDb.createNode();
firstNodeId = firstNode.getId();
firstNode.setProperty("message", "Hello, ");
firstNode.setProperty(
"someJson", "{\n \"is\" : \"vcard\",\n \"name\" : \"Jim Barritt\"\n}");
Node secondNode = graphDb.createNode();
secondNode.setProperty("message", "World!");
Relationship relationship = firstNode.createRelationshipTo(secondNode, KNOWS);
relationship.setProperty("message", "brave Neo4j ");
tx.success();
return firstNodeId;
} finally {
tx.finish();
graphDb.shutdown();
}
}
public static void main(String[] args) {
GraphDatabaseFactory neodb = new GraphDatabaseFactory();
// Direccion de la Base de datos Neo4j
GraphDatabaseService graphDb =
neodb.newEmbeddedDatabase("C:\\Users\\Administrador\\Documents\\Neo4j\\default.graphdb");
try (Transaction tx = graphDb.beginTx()) {
// Creacion de nodos con sus propiedades
Node bobNode = graphDb.createNode(NodeType.Person); // Tipo del nodo Person
bobNode.setProperty("Pid", 5001);
bobNode.setProperty("Name", "Bob");
bobNode.setProperty("Age", 23);
Node aliceNode = graphDb.createNode(NodeType.Person);
aliceNode.setProperty("Pid", 5002);
aliceNode.setProperty("Name", "Eve");
Node eveNode = graphDb.createNode(NodeType.Person);
eveNode.setProperty("Name", "Eve");
Node itNode = graphDb.createNode(NodeType.Course); // TIpo del nodo Course
itNode.setProperty("Id", 1);
itNode.setProperty("Name", "IT Beginners");
itNode.setProperty("Location", "Room 153");
Node electronicNode = graphDb.createNode(NodeType.Course);
electronicNode.setProperty("Name", "Electronics Advanced");
// Creacion de relaciones entre los nodos
bobNode.createRelationshipTo(aliceNode, RelationType.Knows); // Tipo de relacion Knows
Relationship bobRelIt =
bobNode.createRelationshipTo(
itNode, RelationType.BelongsTo); // Tipo de relacion BelongsTo
bobRelIt.setProperty("Function", "Student");
Relationship bobRelElectronics =
bobNode.createRelationshipTo(electronicNode, RelationType.BelongsTo);
bobRelElectronics.setProperty("Function", "Supply Teacher");
Relationship aliceRelIt = aliceNode.createRelationshipTo(itNode, RelationType.BelongsTo);
aliceRelIt.setProperty("Function", "Teacher");
tx.success(); // Proceso termino de forma exitosa
}
graphDb.shutdown(); // Cerrar base
}
/**
* The only properties added to a relationship are the columns representing the index of the
* association.
*/
private void applyProperties(
AssociationKey associationKey, Tuple associationRow, Relationship relationship) {
String[] indexColumns = associationKey.getMetadata().getRowKeyIndexColumnNames();
for (int i = 0; i < indexColumns.length; i++) {
String propertyName = indexColumns[i];
Object propertyValue = associationRow.get(propertyName);
relationship.setProperty(propertyName, propertyValue);
}
}
@Test
public void canAddShortStringToRelationship() throws Exception {
long recordCount = dynamicRecordsInUse();
GraphDatabaseService db = graphdb.getGraphDatabaseService();
Relationship rel = db.createNode().createRelationshipTo(db.createNode(), withName("REL_TYPE"));
rel.setProperty("type", "dimsedut");
commit();
assertEquals(recordCount, dynamicRecordsInUse());
assertThat(rel, inTx(db, hasProperty("type").withValue("dimsedut")));
}
private static Relationship arco(Node n1, Node n2) {
Relationship relationship;
try (Transaction tx = graphDb.beginTx()) {
relationship = n1.createRelationshipTo(n2, RelTypes.STD);
relationship.setProperty("type", "normal ");
tx.success();
}
System.out.println("arc created");
return relationship;
}
@Test
public void testAddCacheCleared() {
Node nodeA = getGraphDb().createNode();
nodeA.setProperty("1", 1);
Node nodeB = getGraphDb().createNode();
Relationship rel = nodeA.createRelationshipTo(nodeB, MyRelTypes.TEST);
rel.setProperty("1", 1);
getTransaction().success();
getTransaction().finish();
newTransaction();
NodeManager nodeManager =
((EmbeddedGraphDatabase) getGraphDb()).getConfig().getGraphDbModule().getNodeManager();
nodeManager.clearCache();
nodeA.createRelationshipTo(nodeB, MyRelTypes.TEST);
int count = 0;
for (Relationship relToB : nodeA.getRelationships(MyRelTypes.TEST)) {
count++;
}
assertEquals(2, count);
nodeA.setProperty("2", 2);
assertEquals(1, nodeA.getProperty("1"));
rel.setProperty("2", 2);
assertEquals(1, rel.getProperty("1"));
nodeManager.clearCache();
// trigger empty load
getGraphDb().getNodeById(nodeA.getId());
getGraphDb().getRelationshipById(rel.getId());
// apply COW maps
getTransaction().success();
getTransaction().finish();
newTransaction();
count = 0;
for (Relationship relToB : nodeA.getRelationships(MyRelTypes.TEST)) {
count++;
}
assertEquals(2, count);
assertEquals(1, nodeA.getProperty("1"));
assertEquals(1, rel.getProperty("1"));
assertEquals(2, nodeA.getProperty("2"));
assertEquals(2, rel.getProperty("2"));
}
@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();
}
public void setRelationshipProperties(long relationshipId, Map<String, Object> properties)
throws DatabaseBlockedException {
Transaction tx = database.graph.beginTx();
try {
Relationship relationship = database.graph.getRelationshipById(relationshipId);
for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
relationship.setProperty(propertyEntry.getKey(), propertyEntry.getValue());
}
tx.success();
} finally {
tx.finish();
}
}
@Test
public void deleteNodeRelTriggerPropertyRemoveEvents() {
GraphDatabaseService db = dbRule.getGraphDatabaseService();
Node node1;
Node node2;
Relationship rel;
try (Transaction tx = db.beginTx()) {
node1 = db.createNode();
node2 = db.createNode();
rel = node1.createRelationshipTo(node2, RelTypes.TXEVENT);
node1.setProperty("test1", "stringvalue");
node1.setProperty("test2", 1l);
rel.setProperty("test1", "stringvalue");
rel.setProperty("test2", 1l);
rel.setProperty("test3", new int[] {1, 2, 3});
tx.success();
}
MyTxEventHandler handler = new MyTxEventHandler();
db.registerTransactionEventHandler(handler);
try (Transaction tx = db.beginTx()) {
GraphDatabaseAPI dbApi = dbRule.getGraphDatabaseAPI();
dbApi.getDependencyResolver().resolveDependency(NodeManager.class).clearCache();
rel.delete();
node1.delete();
node2.delete();
dbApi.getDependencyResolver().resolveDependency(NodeManager.class).clearCache();
tx.success();
}
assertEquals("stringvalue", handler.nodeProps.get("test1"));
assertEquals("stringvalue", handler.relProps.get("test1"));
assertEquals(1l, handler.nodeProps.get("test2"));
assertEquals(1l, handler.relProps.get("test2"));
int[] intArray = (int[]) handler.relProps.get("test3");
assertEquals(3, intArray.length);
assertEquals(1, intArray[0]);
assertEquals(2, intArray[1]);
assertEquals(3, intArray[2]);
}
@Test
public void testRelGetProperties() {
Integer int1 = new Integer(1);
Integer int2 = new Integer(2);
String string = new String("3");
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST);
try {
rel1.getProperty(key1);
fail("get non existing property din't throw exception");
} catch (NotFoundException e) {
}
try {
rel1.getProperty(null);
fail("get of null key din't throw exception");
} catch (IllegalArgumentException e) {
}
assertTrue(!rel1.hasProperty(key1));
assertTrue(!rel1.hasProperty(null));
rel1.setProperty(key1, int1);
rel1.setProperty(key2, int2);
rel1.setProperty(key3, string);
assertTrue(rel1.hasProperty(key1));
assertTrue(rel1.hasProperty(key2));
assertTrue(rel1.hasProperty(key3));
try {
rel1.removeProperty(key3);
} catch (NotFoundException e) {
fail("Remove of property failed.");
}
assertTrue(!rel1.hasProperty(key3));
assertTrue(!rel1.hasProperty(null));
rel1.delete();
node2.delete();
node1.delete();
}
@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();
}
public void setRelationshipProperty(long relationshipId, String key, Object value)
throws PropertyValueException, RelationshipNotFoundException {
Relationship relationship = relationship(relationshipId);
value = property(value);
Transaction tx = graphDb.beginTx();
try {
relationship.setProperty(key, value);
tx.success();
} catch (IllegalArgumentException e) {
throw new PropertyValueException(key, value);
} finally {
tx.finish();
}
}
public Relationship createLink(Map<String, Node> nodes) {
Node sourceNode = nodes.get(sourceNodeId);
Node targetNode = nodes.get(targetNodeId);
Relationship relationship =
sourceNode.createRelationshipTo(targetNode, DynamicRelationshipType.withName(label));
Set<String> keys = props.keySet();
for (String key : keys) {
relationship.setProperty(key, props.get(key));
}
return relationship;
}
