@Test( expected = NullPointerException.class ) public void invalidEdgeTypesWrite() { final GraphManager em = emf.createEdgeManager( scope ); em.writeEdge( null ); }
private List<MarkedEdge> createConnectionSearchEdges( final Entity testEntity, final GraphManager graphManager, final int edgeCount ) { final List<MarkedEdge> connectionSearchEdges = Observable.range( 0, edgeCount ).flatMap( integer -> { //create our connection edge. final Id connectingId = createId( "connecting" ); final Edge connectionEdge = CpNamingUtils.createConnectionEdge( connectingId, "likes", testEntity.getId() ); return graphManager.writeEdge( connectionEdge ).subscribeOn( Schedulers.io() ); }, 20).toList().toBlocking().last(); assertEquals( "All edges saved", edgeCount, connectionSearchEdges.size() ); return connectionSearchEdges; }
@Override public Boolean call() throws Exception { GraphManager manager = factory.createEdgeManager( scope ); final long startTime = System.currentTimeMillis(); for ( long i = 1; i < writeLimit +1 && System.currentTimeMillis() - startTime < minExecutionTime; i++ ) { Edge edge = generator.newEdge(); Edge returned = manager.writeEdge( edge ).toBlocking().last(); assertNotNull( "Returned has a version", returned.getTimestamp() ); writeCounter.incrementAndGet(); if ( i % 100 == 0 ) { logger.info( "wrote: " + i ); } } return true; } }
@Test public void testGetEdgesToTarget() { final GraphManager gm = emf.createEdgeManager( scope ); Id sourceId1 = new SimpleId( "source1" ); Id sourceId2 = new SimpleId( "source2" ); Id targetId1 = new SimpleId( "target" ); Edge testTargetEdge = createEdge( sourceId1, "test", targetId1, System.currentTimeMillis() ); gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); Edge testTarget2Edge = createEdge( sourceId2, "edgeType1", targetId1, System.currentTimeMillis() ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); Edge test2TargetEdge = createEdge( sourceId1, "edgeType1", targetId1, System.currentTimeMillis() ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); Edge test3TargetEdge = createEdge( sourceId1, "edgeType2", targetId1, System.currentTimeMillis() ); gm.writeEdge( test3TargetEdge ).toBlocking().singleOrDefault( null ); int count = gm.getEdgeTypesToTarget( new SimpleSearchEdgeType(targetId1, null, null) ) .count().toBlocking().last(); assertEquals( 3, count ); count = gm.getEdgeTypesToTarget( new SimpleSearchEdgeType(targetId1, "edgeType", null) ) .count().toBlocking().last(); assertEquals( 2, count ); }
@Test public void testWriteReadEdgeTypesSourceTypesPrefix() { final GraphManager gm = emf.createEdgeManager( scope ); Id sourceId = new SimpleId( "source" ); Id targetId = new SimpleId( "target" ); Edge testTargetEdge = createEdge( sourceId, "test1edge1", targetId, System.currentTimeMillis() ); gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); Edge testTarget2Edge = createEdge( sourceId, "test1edge2", targetId, System.currentTimeMillis() ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); Edge test2TargetEdge = createEdge( sourceId, "test2edge1", targetId, System.currentTimeMillis() ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); //get our 2 edge types Observable<String> edges = gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( testTargetEdge.getSourceNode(), "test1", null ) ); Iterator<String> results = edges.toBlocking().getIterator(); assertEquals( "Edges correct", "test1edge1", results.next() ); assertEquals( "Edges correct", "test1edge2", results.next() ); assertFalse( "No more edges", results.hasNext() ); edges = gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( testTargetEdge.getSourceNode(), "test2", null ) ); results = edges.toBlocking().getIterator(); assertEquals( "Edges correct", "test2edge1", results.next() ); assertFalse( "No more edges", results.hasNext() ); }
@Test public void testWriteReadEdgeTypesTargetTypesPrefix() { final GraphManager gm = emf.createEdgeManager( scope ); Id targetId = new SimpleId( "target" ); Id sourceId = new SimpleId( "source" ); Edge testTargetEdge = createEdge( sourceId, "test1edge1", targetId, System.currentTimeMillis() ); gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); Edge testTarget2Edge = createEdge( sourceId, "test1edge2", targetId, System.currentTimeMillis() ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); Edge test2TargetEdge = createEdge( sourceId, "test2edge1", targetId, System.currentTimeMillis() ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); //get our 2 edge types Observable<String> edges = gm.getEdgeTypesToTarget( new SimpleSearchEdgeType( testTargetEdge.getTargetNode(), "test1", null ) ); Iterator<String> results = edges.toBlocking().getIterator(); assertEquals( "Edges correct", "test1edge1", results.next() ); assertEquals( "Edges correct", "test1edge2", results.next() ); assertFalse( "No more edges", results.hasNext() ); edges = gm.getEdgeTypesToTarget( new SimpleSearchEdgeType( testTargetEdge.getTargetNode(), "test2", null ) ); results = edges.toBlocking().getIterator(); assertEquals( "Edges correct", "test2edge1", results.next() ); assertFalse( "No more edges", results.hasNext() ); }
@Test public void testSourceSubTypes() { //now test sub edges final GraphManager gm = emf.createEdgeManager( scope ); Id sourceId = new SimpleId( "source" ); Id targetId1target1 = new SimpleId( "type1target1" ); Id targetId1target2 = new SimpleId( "type1target2" ); Id targetId2 = new SimpleId( "type2target2" ); Edge testTargetEdge = createEdge( sourceId, "test", targetId1target1, System.currentTimeMillis() ); gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); Edge testTarget2Edge = createEdge( sourceId, "test", targetId1target2, System.currentTimeMillis() ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); Edge test2TargetEdge = createEdge( sourceId, "test", targetId2, System.currentTimeMillis() ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); Observable<String> edges = gm.getIdTypesFromSource( new SimpleSearchIdType( testTargetEdge.getSourceNode(), "test", "type1", null ) ); Iterator<String> results = edges.toBlocking().getIterator(); assertEquals( "Types correct", targetId1target1.getType(), results.next() ); assertEquals( "Types correct", targetId1target2.getType(), results.next() ); assertFalse( "No results", results.hasNext() ); //now get types for test2 edges = gm.getIdTypesFromSource( new SimpleSearchIdType( testTargetEdge.getSourceNode(), "test", "type2", null ) ); results = edges.toBlocking().getIterator(); assertEquals( "Types correct", targetId2.getType(), results.next() ); assertFalse( "No results", results.hasNext() ); }
@Test public void testTargetSubTypes() { //now test sub edges final GraphManager gm = emf.createEdgeManager( scope ); Id targetId = new SimpleId( "target" ); Id sourceId1target1 = new SimpleId( "type1source1" ); Id sourceId1target2 = new SimpleId( "type1source2" ); Id sourceId2 = new SimpleId( "type2source2" ); Edge testTargetEdge = createEdge( sourceId1target1, "test", targetId, System.currentTimeMillis() ); gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); Edge testTarget2Edge = createEdge( sourceId1target2, "test", targetId, System.currentTimeMillis() ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); Edge test2TargetEdge = createEdge( sourceId2, "test", targetId, System.currentTimeMillis() ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); Observable<String> edges = gm.getIdTypesToTarget( new SimpleSearchIdType( testTargetEdge.getTargetNode(), "test", "type1", null ) ); Iterator<String> results = edges.toBlocking().getIterator(); assertEquals( "Types correct", sourceId1target1.getType(), results.next() ); assertEquals( "Types correct", sourceId1target2.getType(), results.next() ); assertFalse( "No results", results.hasNext() ); //now get types for test2 edges = gm.getIdTypesToTarget( new SimpleSearchIdType( testTargetEdge.getTargetNode(), "test", "type2", null ) ); results = edges.toBlocking().getIterator(); assertEquals( "Types correct", sourceId2.getType(), results.next() ); assertFalse( "No results", results.hasNext() ); }
@Test public void testSingleIndexFromSource() { final Entity entity = new Entity( createId( "test" ), UUIDGenerator.newTimeUUID() ); entity.setField( new StringField( "string", "foo" ) ); final Edge collectionEdge = createCollectionEdge( applicationScope.getApplication(), "tests", entity.getId() ); //write the edge graphManager.writeEdge( collectionEdge ).toBlocking().last(); //index the edge final Observable<IndexOperationMessage> indexed = indexService.indexEntity( applicationScope, entity ); //real users should never call to blocking, we're not sure what we'll get final IndexOperationMessage results = indexed.toBlocking().last(); indexProducer.put(results).subscribe(); final Set<IndexOperation> indexRequests = results.getIndexRequests(); //ensure our value made it to the index request final IndexOperation indexRequest = indexRequests.iterator().next(); assertNotNull( indexRequest ); }
/** * Creates an entity along with the corresponding collection edge. * @param applicationScope * @param graphManager * @param testEntity * @return */ private Edge createEntityandCollectionEdge( final ApplicationScope applicationScope, final GraphManager graphManager, final Entity testEntity) { final EntityCollectionManager collectionManager = entityCollectionManagerFactory.createCollectionManager( applicationScope ); collectionManager.write( testEntity, null ).toBlocking().last(); //create our collection edge final Edge collectionEdge = CpNamingUtils.createCollectionEdge( applicationScope.getApplication(), testEntity.getId().getType(), testEntity.getId() ); graphManager.writeEdge( collectionEdge ).toBlocking().last(); return collectionEdge; }
@Test public void testWriteReadEdgeTypePagingTarget() { GraphManager gm = emf.createEdgeManager( scope ); final Id targetId = IdGenerator.createId( "target" ); Edge edge1 = createEdge( IdGenerator.createId( "source" ), "test", targetId ); gm.writeEdge( edge1 ).toBlocking().last(); Edge edge2 = createEdge( IdGenerator.createId( "source" ), "test", targetId ); gm.writeEdge( edge2 ).toBlocking().last(); Edge edge3 = createEdge( IdGenerator.createId( "source" ), "test", targetId ); gm.writeEdge( edge3 ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge1.getTargetNode(), edge1.getType(), edge3.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" Iterator<MarkedEdge> returned = edges.toBlocking().getIterator(); //we have 3 edges, but we specified our first edge as the max, we shouldn't get any more results than the first assertEquals( "Correct edge returned", edge3, returned.next() ); assertEquals( "Correct edge returned", edge2, returned.next() ); assertEquals( "Correct edge returned", edge1, returned.next() ); assertFalse( "No more edges", returned.hasNext() ); search = createSearchByEdge( edge1.getTargetNode(), edge1.getType(), edge3.getTimestamp(), edge2 ); edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().getIterator(); assertEquals( "Paged correctly", edge1, returned.next() ); assertFalse( "End of stream", returned.hasNext() ); }
@Override public ConnectionRef createConnection( String connectionType, EntityRef connectedEntityRef ) throws Exception { headEntity = em.validate( headEntity ); connectedEntityRef = em.validate( connectedEntityRef ); ConnectionRefImpl connection = new ConnectionRefImpl( headEntity, connectionType, connectedEntityRef ); if ( logger.isTraceEnabled() ) { logger.trace( "createConnection(): Indexing connection type '{}'\n from source {}:{}]\n to target {}:{}\n app {}", connectionType, headEntity.getType(), headEntity.getUuid(), connectedEntityRef.getType(), connectedEntityRef.getUuid(), applicationScope ); } final Id entityId = new SimpleId( connectedEntityRef.getUuid(), connectedEntityRef.getType() ); final org.apache.usergrid.persistence.model.entity.Entity targetEntity = ( ( CpEntityManager ) em ).load( entityId ); // create graph edge connection from head entity to member entity final Edge edge = createConnectionEdge( cpHeadEntity.getId(), connectionType, targetEntity.getId() ); final GraphManager gm = managerCache.getGraphManager( applicationScope ); //write new edge gm.writeEdge(edge).toBlocking().lastOrDefault(null); //throw an exception if this fails String entityType = targetEntity.getId().getType(); if ( !skipIndexingForType( entityType ) ) { QueueIndexingStrategy queueIndexingStrategy = getIndexingStrategyForType(entityType); indexService.queueNewEdge(applicationScope, targetEntity.getId(), edge, queueIndexingStrategy); } // remove any duplicate edges (keeps the duplicate edge with same timestamp) removeDuplicateEdgesAsync(gm, edge); return connection; }
@Test public void testSingleConnection() { final ApplicationScope applicationScope = new ApplicationScopeImpl( new SimpleId( "application" ) ); final GraphManager gm = graphManagerFactory.createEdgeManager( applicationScope ); //now write a single connection final Id source = new SimpleId( "source" ); //add to a collection final String collectionName = "testCollection"; final Edge collectionEdge = CpNamingUtils.createCollectionEdge( applicationScope.getApplication(), collectionName, source ); final Edge writtenCollection = gm.writeEdge( collectionEdge ).toBlocking().last(); assertNotNull("Collection edge written", writtenCollection); final Id target = new SimpleId( "target" ); final String connectionType = "testConnection"; final Edge connectionEdge = CpNamingUtils.createConnectionEdge( source, connectionType, target ); final Edge writtenConnection = gm.writeEdge( connectionEdge ).toBlocking().last(); //now run the cleanup final int count = connectionService.deDupeConnections( Observable.just( applicationScope ) ).count().toBlocking().last(); assertEquals( "No edges deleted", 0, count ); //now ensure we can read the edge. final SearchByEdge simpleSearchByEdge = new SimpleSearchByEdge( source, connectionEdge.getType(), target, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.absent() ); final List<MarkedEdge> edges = gm.loadEdgeVersions( simpleSearchByEdge ).toList().toBlocking().last(); assertEquals( 1, edges.size() ); assertEquals( writtenConnection, edges.get( 0 ) ); }
/** * Simple test case that tests a single edge and removing the node. The other target node should be removed as well * since it has no other targets */ @Test public void testNoDeletionMarked() { GraphManager em = emf.createEdgeManager( scope ); Edge edge = createEdge( "source", "test", "target" ); //write the edge Edge last = em.writeEdge( edge ).toBlocking().last(); assertEquals( edge, last ); Id sourceNode = edge.getSourceNode(); UUID eventTime = UUIDGenerator.newTimeUUID(); int count = deleteListener.receive( scope, sourceNode, eventTime ).count().toBlocking().last(); assertEquals( "Mark was not set, no delete should be executed", 0, count ); }
@Test public void testWriteReadEdgeTypeVersionSource() throws TimeoutException, InterruptedException { GraphManager gm = emf.createEdgeManager( scope ); final long earlyVersion = 1000l; Edge edge = createEdge( "source", "test", "target", earlyVersion ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesFromSource( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //now test with an earlier version, we shouldn't get the edge back search = createSearchByEdge( edge.getSourceNode(), edge.getType(), earlyVersion - 1, null ); edges = gm.loadEdgesFromSource( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Earlier version should not be returned", returned ); }
@Test public void testWriteReadEdgeTypeTarget() throws TimeoutException, InterruptedException { GraphManager gm = emf.createEdgeManager( scope ); Edge edge = createEdge( "source", "test", "target" ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //change edge type to be invalid, shouldn't get a result search = createSearchByEdge( edge.getTargetNode(), edge.getType() + "invalid", edge.getTimestamp(), null ); edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Invalid type should not be returned", returned ); }
@Test public void testWriteReadEdgeTypeVersionTarget() throws TimeoutException, InterruptedException { GraphManager gm = emf.createEdgeManager( scope ); final long earlyVersion = 10000l; Edge edge = createEdge( "source", "test", "target", earlyVersion ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //change edge type to be invalid, shouldn't get a result search = createSearchByEdge( edge.getTargetNode(), edge.getType(), earlyVersion - 1, null ); edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Earlier version should not be returned", returned ); }
@Test public void testWriteReadEdgeTypeSource() throws TimeoutException, InterruptedException { GraphManager gm = emf.createEdgeManager( scope ); Edge edge = createEdge( "source", "test", "target" ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesFromSource( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().last(); assertEquals( "Correct edge returned", edge, returned ); //change edge type to be invalid, shouldn't get a result search = createSearchByEdge( edge.getSourceNode(), edge.getType() + "invalid", edge.getTimestamp(), null ); edges = gm.loadEdgesFromSource( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Invalid type should not be returned", returned ); }
@Test public void testWriteReadEdgeTypeTargetTypeSource() { GraphManager gm = emf.createEdgeManager( scope ); Edge edge = createEdge( "source", "test", "target" ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByIdType search = createSearchByEdgeAndId( edge.getSourceNode(), edge.getType(), edge.getTimestamp(), edge.getTargetNode().getType(), null ); Observable<MarkedEdge> edges = gm.loadEdgesFromSourceByType( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //change edge type to be invalid, shouldn't get a result search = createSearchByEdgeAndId( edge.getSourceNode(), edge.getType(), edge.getTimestamp(), edge.getTargetNode().getType() + "invalid", null ); edges = gm.loadEdgesFromSourceByType( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Invalid type should not be returned", returned ); }
@Test public void testWriteReadEdgeTypeTargetTypeTarget() { GraphManager gm = emf.createEdgeManager( scope ); ; Edge edge = createEdge( "source", "test", "target" ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByIdType search = createSearchByEdgeAndId( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), edge.getSourceNode().getType(), null ); Observable<MarkedEdge> edges = gm.loadEdgesToTargetByType( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //change edge type to be invalid, shouldn't get a result search = createSearchByEdgeAndId( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), edge.getSourceNode().getType() + "invalid", null ); edges = gm.loadEdgesToTargetByType( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Invalid type should not be returned", returned ); }