public SecuredGraphEventManager(final SecuredGraph securedGraph, final Graph baseGraph, final GraphEventManager manager) { this.securedGraph = securedGraph; this.baseGraph = baseGraph; manager.register(this); }
/** Register the listener with this model by registering its GraphListener adaption with the underlying Graph. @param listener A ModelChangedListener to register for model events @return this model, for cascading */ @Override public Model register( ModelChangedListener listener ) { getGraph().getEventManager().register( adapt( listener ) ); return this; }
/** * Test that adding an iterator is reported as adding an iterator. */ @ContractTest public void testAddIterator() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyAddIterator(mockGraph, elems.iterator()); L.assertHas(new Object[] { "addIterator", mockGraph, elems }); }
/** * Test that registering a listener twice and unregistering it once will * result in the listener receiving each event one time. */ @ContractTest public void testUnregisterOnce() { gem.register(L).register(L).unregister(L); gem.notifyDeleteTriple(mockGraph, SPO); L.assertHas(new Object[] { "delete", mockGraph, SPO }); }
/** Utility: get a graph, register L with its manager, return the graph. */ protected Graph getAndRegister( GraphListener gl ) { Graph g = getGraph(); g.getEventManager().register( gl ); return g; }
/** * Test that adding a list is reported as adding a list */ @ContractTest public void testAddList() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyAddList(mockGraph, elems); L.assertHas(new Object[] { "addList", mockGraph, elems }); }
/** * Test that adding a list as an iterator is reported as an add iterator. */ @ContractTest public void testAddListAsIterator() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyAddIterator(mockGraph, elems); L.assertHas(new Object[] { "addIterator", mockGraph, elems }); }
/** * Test that deleting a list as an iterator is reported as deleting an * iterator. */ @ContractTest public void testDeleteListAsIterator() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyDeleteIterator(mockGraph, elems); L.assertHas(new Object[] { "deleteIterator", mockGraph, elems }); }
/** * Test that deleting a list is reported as deleting a list. */ @ContractTest public void testDeleteList() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyDeleteList(mockGraph, elems); L.assertHas(new Object[] { "deleteList", mockGraph, elems }); }
/** * Test that when a listener is registered the same EventManager is * returned. */ @ContractTest public void testEventRegister() { assertSame(gem, gem.register(new RecordingGraphListener())); }
/** * Test that when 2 listeners are added both receive events. */ @ContractTest public void testTwoListeners() { RecordingGraphListener L1 = new RecordingGraphListener(); RecordingGraphListener L2 = new RecordingGraphListener(); gem.register(L1).register(L2); gem.notifyAddTriple(mockGraph, SPO); L2.assertHas(new Object[] { "add", mockGraph, SPO }); L1.assertHas(new Object[] { "add", mockGraph, SPO }); }
/** * Test that adding an array is reported as adding an array. */ @ContractTest public void testAddArray() { gem.register(L); gem.notifyAddArray(mockGraph, tripleArray); L.assertHas(new Object[] { "add[]", mockGraph, tripleArray }); }
/** * Test that sending a general event is reported as an event and the value * is saved. */ @ContractTest public void testGeneralEvent() { gem.register(L); Object value = new int[] {}; gem.notifyEvent(mockGraph, value); L.assertHas(new Object[] { "someEvent", mockGraph, value }); }
/** * Test that unregistering a listener after registering it results in it not * receiving messages. */ @ContractTest public void testUnregisterWorks() { gem.register(L).unregister(L); gem.notifyAddTriple(mockGraph, SPO); L.assertHas(new Object[] {}); }
/** * Test that unregistering a listener after registering it results in it not * receiving messages. */ @ContractTest public void testUnregisterWorks() { gem.register(L).unregister(L); gem.notifyAddTriple(mockGraph, SPO); L.assertHas(new Object[] {}); }
@ContractTest public void testListening() { assertFalse("Should not be listening", gem.listening()); gem.register(L); assertTrue("Should be listening", gem.listening()); gem.unregister(L); assertFalse("Should not be listening", gem.listening()); }
@ContractTest public void testDelete_Triple_FromNothing() { Graph g = producer.newInstance(); g.getEventManager().register(GL); txnBegin(g); g.delete(triple("quint rdf:subject S")); txnCommit(g); GL.assertContains("delete", g, triple("quint rdf:subject S")); }
@ContractTest public void testPerformAdd_Triple() { GraphWithPerform g = (GraphWithPerform) graphWith( producer.newInstance(), "S P O; S2 P2 O2"); g.getEventManager().register(GL); txnBegin(g); g.performAdd(triple("S3 P3 O3")); txnCommit(g); GL.assertEmpty(); txnRun(g, () -> assertTrue(g.contains(triple("S3 P3 O3")))); }
@ContractTest public void testAdd_Triple() { Graph graph = producer.newInstance(); graph.getEventManager().register(GL); txnBegin(graph); graph.add(triple("S P O")); txnCommit(graph); GL.assertHasStart("add", graph, triple("S P O")); txnRun(graph, () -> assertTrue("Graph should contain <S P O>", graph.contains(triple("S P O")))); }