diff --git a/jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImpl.java b/jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImpl.java index 0b0cbfa11..65f514324 100644 --- a/jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImpl.java +++ b/jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImpl.java @@ -82,8 +82,10 @@ public synchronized void replicaRemoved(KnowledgeManager km) { .values()) { toRemove.clear(); for (KnowledgeManagerTriggerListener tListener : tListeners) - if (tListener.getKnowledgeManager().equals(km)) + if (tListener.getKnowledgeManager().equals(km)) { + km.unregister(tListener.getTrigger(), tListener); toRemove.add(tListener); + } tListeners.removeAll(toRemove); } } @@ -161,7 +163,7 @@ private void registerTriggerAtKnowledgeManager(KnowledgeManager km, Trigger trigger, ShadowsTriggerListener triggerListener) { List tListeners; KnowledgeManagerTriggerListener tListener = new KnowledgeManagerTriggerListener( - km, triggerListener); + km, triggerListener, trigger); // Update map of listenerToTriggerListeners if (listenerToTriggerListeners.containsKey(triggerListener)) tListeners = listenerToTriggerListeners.get(triggerListener); @@ -179,12 +181,14 @@ private class KnowledgeManagerTriggerListener implements TriggerListener { private final KnowledgeManager knowledgeManager; private final ShadowsTriggerListener listener; + private final Trigger trigger; public KnowledgeManagerTriggerListener( KnowledgeManager knowledgeManager, - ShadowsTriggerListener listener) { + ShadowsTriggerListener listener, Trigger trigger) { this.knowledgeManager = knowledgeManager; this.listener = listener; + this.trigger = trigger; } @Override @@ -195,6 +199,10 @@ public void triggered(Trigger trigger) { public KnowledgeManager getKnowledgeManager() { return knowledgeManager; } + + public Trigger getTrigger() { + return trigger; + } } } diff --git a/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImplTest.java b/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImplTest.java index 0bad83cf4..79173bfb1 100644 --- a/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImplTest.java +++ b/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImplTest.java @@ -1,6 +1,22 @@ package cz.cuni.mff.d3s.deeco.knowledge; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.mockito.MockitoAnnotations.initMocks; + +import java.util.Collection; +import java.util.LinkedList; +import java.util.List; + +import org.junit.Before; import org.junit.Test; +import org.mockito.Mock; + +import cz.cuni.mff.d3s.deeco.model.runtime.api.KnowledgeChangeTrigger; /** * @author Michal Kit @@ -8,87 +24,181 @@ */ public class KnowledgeManagerViewImplTest { + @Mock + private KnowledgeManagerContainer container; + + @Mock + private KnowledgeManager knowledgeManager; + @Mock + private KnowledgeManager local; + @Mock + private KnowledgeManager replica; + + @Mock + private ShadowsTriggerListener listener; + @Mock + private KnowledgeChangeTrigger trigger; + + private KnowledgeManagerViewImpl tested; + + @Before + public void setUp() { + initMocks(this); + tested = new KnowledgeManagerViewImpl(knowledgeManager, container); + } + @Test public void getOtherKnowledgeManagersTest() { // WHEN the container already consists of some local and replica // knowledge managers + List locals = new LinkedList<>(); + locals.add(local); + locals.add(knowledgeManager); + List replicas = new LinkedList<>(); + replicas.add(replica); + when(container.getLocals()).thenReturn(locals); + when(container.getReplicas()).thenReturn(replicas); // and WHEN the 'getOtherKnowledgeManagers' is called on the // KnowledgeManagerView instance - // THEN the KnowledgeManagerView instance returns all container's + Collection result = tested.getOtherKnowledgeManagers(); + + // THEN the container is accessed for local and replica knowledge + // managers + + verify(container).getLocals(); + verify(container).getReplicas(); + + // and THEN the KnowledgeManagerView instance returns all container's // knowledge managers apart of the one referenced by the // KnowledgeManagerView instance + + assertTrue(result.size() == 2); + assertTrue(!result.contains(knowledgeManager)); + } @Test public void registerTest() { // WHEN the container already consists of some local and replica // knowledge managers + + List locals = new LinkedList<>(); + locals.add(knowledgeManager); + List replicas = new LinkedList<>(); + replicas.add(replica); + when(container.getLocals()).thenReturn(locals); + when(container.getReplicas()).thenReturn(replicas); // and WHEN the 'register' is called on the // KnowledgeManagerView instance + + tested.register(trigger, listener); // THEN each of the KnowledgeManager instance hosted by the container is // registered with the trigger - // and any other knowledge manager added later is also registered with - // the respective trigger + verify(knowledgeManager).register(eq(trigger), any(TriggerListener.class)); + verify(replica).register(eq(trigger), any(TriggerListener.class)); } @Test public void unregisterTest() { // WHEN the container already consists of some local and replica // knowledge managers + List locals = new LinkedList<>(); + locals.add(knowledgeManager); + List replicas = new LinkedList<>(); + replicas.add(replica); + when(container.getLocals()).thenReturn(locals); + when(container.getReplicas()).thenReturn(replicas); + // and WHEN the 'register' is called on the + // KnowledgeManagerView instance + + tested.register(trigger, listener); + // and WHEN the 'unregister' is called on the // KnowledgeManagerView instance + tested.unregister(trigger, listener); + // THEN each of the KnowledgeManager instance hosted by the container is // unregistered with the respective trigger + verify(knowledgeManager).unregister(eq(trigger), any(TriggerListener.class)); + verify(replica).unregister(eq(trigger), any(TriggerListener.class)); + // and any other knowledge manager added later is not registered with // the trigger + + tested.localCreated(local); + verify(local, never()).register(eq(trigger), any(TriggerListener.class)); } @Test public void localCreatedTest() { // WHEN the container has created a new local knowledge manager + // and WHEN the KnowledgeManagerView instance is notified about this + + tested.register(trigger, listener); + tested.localCreated(local); - // THEN the KnowledgeManagerView instance is notified about this - - // and all memorised triggers are registered with the new knowledge + // THEN all memorised triggers are registered with the new knowledge // manager + + verify(local).register(eq(trigger), any(TriggerListener.class)); } @Test public void replicaCreatedTest() { // WHEN the container has created a new replica knowledge manager + // and WHEN the KnowledgeManagerView instance is notified about this - // THEN the KnowledgeManagerView instance is notified about this - + tested.register(trigger, listener); + tested.replicaCreated(replica); + // and all memorised triggers are registered with the new knowledge // manager + + verify(replica).register(eq(trigger), any(TriggerListener.class)); } @Test public void localRemovedTest() { // WHEN the container has removed a local knowledge manager - - // THEN the KnowledgeManagerView instance is notified about this - - // and all triggers registered by the KnowledgeManagerView instance are + // and WHEN the KnowledgeManagerView instance is notified about this + List locals = new LinkedList<>(); + locals.add(local); + locals.add(knowledgeManager); + when(container.getLocals()).thenReturn(locals); + + tested.register(trigger, listener); + tested.localRemoved(local); + + // THEN all triggers registered by the KnowledgeManagerView instance are // removed from the knowledge manager being removed + + verify(local).unregister(eq(trigger), any(TriggerListener.class)); } @Test public void replicaRemovedTest() { // WHEN the container has removed a replica knowledge manager - - // THEN the KnowledgeManagerView instance is notified about this - - // and all triggers registered by the KnowledgeManagerView instance are + // and WHEN the KnowledgeManagerView instance is notified about this + List replicas = new LinkedList<>(); + replicas.add(replica); + when(container.getReplicas()).thenReturn(replicas); + + + tested.register(trigger, listener); + tested.localRemoved(replica); + + // THEN all triggers registered by the KnowledgeManagerView instance are // removed from the knowledge manager being removed + + verify(replica).unregister(eq(trigger), any(TriggerListener.class)); } } diff --git a/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagersViewTest.java b/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagersViewTest.java deleted file mode 100644 index 1ea463629..000000000 --- a/jdeeco-core/test/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagersViewTest.java +++ /dev/null @@ -1,119 +0,0 @@ -package cz.cuni.mff.d3s.deeco.knowledge; - -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.when; - -import java.util.Collection; -import java.util.LinkedList; - -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import cz.cuni.mff.d3s.deeco.model.runtime.api.Trigger; - -/** - * KnowledgeManagersView testing. - * The test checks the correctness of getting the KnowledgeManagers and register/unregister - * the triggers of the others. - * - * @author Rima Al Ali - * - */ -public class KnowledgeManagersViewTest { - - @Mock - private Trigger trigger; - @Mock - private ShadowsTriggerListener shadowsTriggerListener; - @Mock - private ValueSet valueSet; - @Mock - private ReadOnlyKnowledgeManager km; - - private KnowledgeManagersView kmView; - - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - - // FIXME TB: Why do you have the "this." here? - // FIXME TB: Why don't you instantiate this mock using the annotation as the other mocks above? - this.kmView =mock(KnowledgeManagersView.class); - } - - // FIXME TB: The tests below need to be fixed to comply to BDD. - - @Test - public void testGetOtherKnowledgeManager(){ - // WHEN km mocks KnowledgeManager and define a Collection of ReadOnlyKnowledgeManagers that do not have km - this.km = mock(ReadOnlyKnowledgeManager.class); - Collection colKM = new LinkedList(); - // THEN define the behavior of KnowledgeManagerView : - // 1- return "colKM" by calling getOthersKnowledgeManagers() - when(kmView.getOtherKnowledgeManagers()).thenReturn(colKM); - - // WHEN call getOthersKnowledgeManagers() - // THEN check the returned collection do not have km - assertEquals(false, kmView.getOtherKnowledgeManagers().contains(km)); - - } - - @Ignore - @Test - public void testRegisterOthers() { - // WHEN define a new for trigger - // FIXME TB: Why do you call the mock here when the mock has been already created because of the annotation above and the call to initMocks? - this.trigger = mock(Trigger.class); - // THEN add the trigger(s) to a Collection - Collection colTriggers= new LinkedList(); - colTriggers.add(trigger); - - // WHEN mock new TriggerListener - // FIXME TB: Why do you call the mock here when the mock has been already created because of the annotation above and the call to initMocks? - this.shadowsTriggerListener = mock(ShadowsTriggerListener.class); - // THEN define the behavior of the TriggerListener: - // the value "colTriggers" returned by getTriggers() - //when(triggerListener.getTriggers()).thenReturn(colTriggers); - - - // WHEN registering a trigger to triggerListener - kmView.register(trigger,shadowsTriggerListener); - // THEN the triggerListener adds this trigger - // assertEquals(true,triggerListener.getTriggers().contain(trigger)); - - verifyNoMoreInteractions(trigger); - } - - @Ignore - @Test - public void testUnregisterOthers() { - // WHEN define a new for trigger - // FIXME TB: Why do you call the mock here when the mock has been already created because of the annotation above and the call to initMocks? - this.trigger = mock(Trigger.class); - // THEN define a Collection of Triggers without the currentTrigger - Collection colTriggers= new LinkedList(); - - // WHEN mock new TriggerListener - // FIXME TB: Why do you call the mock here when the mock has been already created because of the annotation above and the call to initMocks? - this.shadowsTriggerListener = mock(ShadowsTriggerListener.class); - // THEN define the behavior of the TriggerListener: - // the value "colTriggers" returned by getTriggers() - //when(triggerListener.getTriggers()).thenReturn(colTriggers); - - - // WHEN registering a trigger to triggerListener - kmView.unregister(trigger,shadowsTriggerListener); - // THEN the triggerListener removes this trigger - // assertEquals(false,triggerListener.getTriggers().contain(trigger)); - - verifyNoMoreInteractions(trigger); - - } - -}