diff options
Diffstat (limited to 'policy-management/src/test/java/org/onap')
| -rw-r--r-- | policy-management/src/test/java/org/onap/policy/drools/system/PolicyControllerFactoryTest.java | 421 | ||||
| -rw-r--r-- | policy-management/src/test/java/org/onap/policy/drools/system/PolicyEngineTest.java (renamed from policy-management/src/test/java/org/onap/policy/drools/system/test/PolicyEngineTest.java) | 2 | ||||
| -rw-r--r-- | policy-management/src/test/java/org/onap/policy/drools/system/internal/AggregatedPolicyControllerTest.java | 948 |
3 files changed, 1370 insertions, 1 deletions
diff --git a/policy-management/src/test/java/org/onap/policy/drools/system/PolicyControllerFactoryTest.java b/policy-management/src/test/java/org/onap/policy/drools/system/PolicyControllerFactoryTest.java new file mode 100644 index 00000000..f5c71064 --- /dev/null +++ b/policy-management/src/test/java/org/onap/policy/drools/system/PolicyControllerFactoryTest.java @@ -0,0 +1,421 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.system; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.policy.common.utils.test.PolicyAssert.assertThrows; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Properties; +import org.junit.Before; +import org.junit.Test; +import org.onap.policy.drools.controller.DroolsController; +import org.onap.policy.drools.features.PolicyControllerFeatureAPI; +import org.onap.policy.drools.protocol.configuration.DroolsConfiguration; + +public class PolicyControllerFactoryTest { + + private static final String MY_NAME = "my-name-a"; + private static final String MY_NAME2 = "my-name-b"; + + private static final String ARTIFACT1 = "artifact-a"; + private static final String GROUP1 = "group-a"; + private static final String VERSION1 = "version-a"; + + private static final String ARTIFACT2 = "artifact-b"; + private static final String GROUP2 = "group-b"; + private static final String VERSION2 = "version-b"; + + private static final String FEATURE1 = "feature-a"; + private static final String FEATURE2 = "feature-b"; + + private PolicyController controller; + private PolicyController controller2; + private Properties properties; + private DroolsController drools; + private DroolsController drools2; + private DroolsConfiguration config; + private PolicyControllerFeatureAPI feature1; + private PolicyControllerFeatureAPI feature2; + private List<PolicyControllerFeatureAPI> providers; + private IndexedPolicyControllerFactory ipc; + + /** + * Initializes the object to be tested. + */ + @Before + public void setUp() { + controller = mock(PolicyController.class); + controller2 = mock(PolicyController.class); + properties = new Properties(); + drools = mock(DroolsController.class); + drools2 = mock(DroolsController.class); + config = mock(DroolsConfiguration.class); + feature1 = mock(PolicyControllerFeatureAPI.class); + feature2 = mock(PolicyControllerFeatureAPI.class); + providers = Arrays.asList(feature1, feature2); + + when(feature1.getName()).thenReturn(FEATURE1); + when(feature2.getName()).thenReturn(FEATURE2); + + when(drools.getArtifactId()).thenReturn(ARTIFACT1); + when(drools.getGroupId()).thenReturn(GROUP1); + when(drools.getVersion()).thenReturn(VERSION1); + + when(drools2.getArtifactId()).thenReturn(ARTIFACT2); + when(drools2.getGroupId()).thenReturn(GROUP2); + when(drools2.getVersion()).thenReturn(VERSION2); + + when(controller.getName()).thenReturn(MY_NAME); + when(controller.getDrools()).thenReturn(drools); + when(controller.updateDrools(any())).thenReturn(true); + + when(controller2.getName()).thenReturn(MY_NAME2); + when(controller2.getDrools()).thenReturn(drools2); + when(controller2.updateDrools(any())).thenReturn(true); + + ipc = new IndexedPolicyControllerFactoryImpl(); + } + + @Test + public void testFactory() { + // use a REAL object instead of an Impl + ipc = new IndexedPolicyControllerFactory(); + assertNotNull(ipc.getProviders()); + } + + @Test + public void testBuild() { + assertEquals(controller, ipc.build(MY_NAME, properties)); + + // re-build - should not create another one + assertEquals(controller, ipc.build(MY_NAME, properties)); + + // brained + setUp(); + when(drools.isBrained()).thenReturn(true); + ipc.build(MY_NAME, properties); + } + + @Test + public void testPatchStringDroolsConfiguration() { + // unknown controller + assertThrows(IllegalArgumentException.class, () -> ipc.patch(MY_NAME, config)); + + /* + * Build controller to be used by remaining tests. + */ + ipc.build(MY_NAME, properties); + + // null name + String nullName = null; + assertThrows(IllegalArgumentException.class, () -> ipc.patch(nullName, config)); + + // empty name + assertThrows(IllegalArgumentException.class, () -> ipc.patch("", config)); + + // success + ipc.patch(MY_NAME, config); + verify(controller).updateDrools(config); + + // create a factory whose get() method returns null + ipc = new IndexedPolicyControllerFactory() { + @Override + public PolicyController get(String name) { + return null; + } + }; + ipc.build(MY_NAME, properties); + assertThrows(IllegalArgumentException.class, () -> ipc.patch(MY_NAME, config)); + } + + @Test + public void testPatchPolicyControllerDroolsConfiguration() { + ipc.patch(controller, config); + verify(controller).updateDrools(config); + + // null controller + PolicyController nullCtlr = null; + assertThrows(IllegalArgumentException.class, () -> ipc.patch(nullCtlr, config)); + + // null config + assertThrows(IllegalArgumentException.class, () -> ipc.patch(controller, null)); + + // brained + when(drools.isBrained()).thenReturn(true); + ipc.patch(controller, config); + + // update failed + when(controller.updateDrools(config)).thenReturn(false); + assertThrows(IllegalArgumentException.class, () -> ipc.patch(controller, config)); + } + + @Test + public void testShutdownString() { + // null name + String nullName = null; + assertThrows(IllegalArgumentException.class, () -> ipc.shutdown(nullName)); + + // empty name + assertThrows(IllegalArgumentException.class, () -> ipc.shutdown("")); + + // unknown controller + ipc.shutdown(MY_NAME); + verify(controller, never()).shutdown(); + + // valid controller + ipc.build(MY_NAME, properties); + ipc.shutdown(MY_NAME); + verify(controller).shutdown(); + } + + @Test + public void testShutdownPolicyController() { + ipc.build(MY_NAME, properties); + + ipc.shutdown(controller); + + verify(controller).shutdown(); + + // should no longer be managed + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME)); + } + + @Test + public void testShutdown() { + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + ipc.shutdown(); + + verify(controller).shutdown(); + verify(controller2).shutdown(); + + // should no longer be managed + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME)); + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME2)); + } + + @Test + public void testUnmanage() { + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + ipc.shutdown(MY_NAME); + + verify(controller).shutdown(); + verify(controller2, never()).shutdown(); + + // should no longer be managed + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME)); + + // should still be managed + assertEquals(controller2, ipc.get(MY_NAME2)); + + // null controller + PolicyController nullCtlr = null; + assertThrows(IllegalArgumentException.class, () -> ipc.shutdown(nullCtlr)); + + // unknown controller + ipc.shutdown(controller); + verify(controller, times(2)).shutdown(); + } + + @Test + public void testDestroyString() { + // null name + String nullName = null; + assertThrows(IllegalArgumentException.class, () -> ipc.destroy(nullName)); + + // empty name + assertThrows(IllegalArgumentException.class, () -> ipc.destroy("")); + + // unknown controller + ipc.destroy(MY_NAME); + verify(controller, never()).halt(); + + // valid controller + ipc.build(MY_NAME, properties); + ipc.destroy(MY_NAME); + verify(controller).halt(); + } + + @Test + public void testDestroyPolicyController() { + ipc.build(MY_NAME, properties); + + ipc.destroy(controller); + + verify(controller).halt(); + + // should no longer be managed + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME)); + } + + @Test + public void testDestroy() { + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + ipc.destroy(); + + verify(controller).halt(); + verify(controller2).halt(); + + // should no longer be managed + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME)); + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME2)); + } + + @Test + public void testGetString() { + // unknown name + assertThrows(IllegalArgumentException.class, () -> ipc.get(MY_NAME)); + + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + assertEquals(controller, ipc.get(MY_NAME)); + assertEquals(controller2, ipc.get(MY_NAME2)); + + // null name + String nullName = null; + assertThrows(IllegalArgumentException.class, () -> ipc.get(nullName)); + + // empty name + assertThrows(IllegalArgumentException.class, () -> ipc.get("")); + } + + @Test + public void testGetStringString_testToKey() { + // unknown controller + assertThrows(IllegalArgumentException.class, () -> ipc.get(GROUP1, ARTIFACT1)); + + when(drools.isBrained()).thenReturn(true); + when(drools2.isBrained()).thenReturn(true); + + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + assertEquals(controller, ipc.get(GROUP1, ARTIFACT1)); + assertEquals(controller2, ipc.get(GROUP2, ARTIFACT2)); + + // null group + assertThrows(IllegalArgumentException.class, () -> ipc.get(null, ARTIFACT1)); + + // empty group + assertThrows(IllegalArgumentException.class, () -> ipc.get("", ARTIFACT1)); + + // null artifact + assertThrows(IllegalArgumentException.class, () -> ipc.get(GROUP1, null)); + + // empty artifact + assertThrows(IllegalArgumentException.class, () -> ipc.get(GROUP1, "")); + } + + @Test + public void testGetDroolsController() { + // unknown controller + assertThrows(IllegalStateException.class, () -> ipc.get(drools)); + + when(drools.isBrained()).thenReturn(true); + when(drools2.isBrained()).thenReturn(true); + + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + assertEquals(controller, ipc.get(drools)); + assertEquals(controller2, ipc.get(drools2)); + + // null controller + DroolsController nullDrools = null; + assertThrows(IllegalArgumentException.class, () -> ipc.get(nullDrools)); + } + + @Test + public void testInventory() { + ipc.build(MY_NAME, properties); + ipc.build(MY_NAME2, properties); + + List<PolicyController> lst = ipc.inventory(); + Collections.sort(lst, (left, right) -> left.getName().compareTo(right.getName())); + assertEquals(Arrays.asList(controller, controller2), lst); + } + + @Test + public void testGetFeatures() { + assertEquals(Arrays.asList(FEATURE1, FEATURE2), ipc.getFeatures()); + } + + @Test + public void testGetFeatureProviders() { + assertEquals(providers, ipc.getFeatureProviders()); + } + + @Test + public void testGetFeatureProvider() { + // null name + assertThrows(IllegalArgumentException.class, () -> ipc.getFeatureProvider(null)); + + // empty name + assertThrows(IllegalArgumentException.class, () -> ipc.getFeatureProvider("")); + + // unknown name + assertThrows(IllegalArgumentException.class, () -> ipc.getFeatureProvider("unknown-feature")); + + assertEquals(feature1, ipc.getFeatureProvider(FEATURE1)); + assertEquals(feature2, ipc.getFeatureProvider(FEATURE2)); + } + + /** + * Factory with overrides. + */ + private class IndexedPolicyControllerFactoryImpl extends IndexedPolicyControllerFactory { + + @Override + protected PolicyController newPolicyController(String name, Properties properties) { + if (MY_NAME.equals(name)) { + return controller; + + } else if (MY_NAME2.equals(name)) { + return controller2; + + } else { + throw new IllegalArgumentException("unknown controller name: " + name); + + } + } + + @Override + protected List<PolicyControllerFeatureAPI> getProviders() { + return providers; + } + } +} diff --git a/policy-management/src/test/java/org/onap/policy/drools/system/test/PolicyEngineTest.java b/policy-management/src/test/java/org/onap/policy/drools/system/PolicyEngineTest.java index 7b02d755..cd93d94c 100644 --- a/policy-management/src/test/java/org/onap/policy/drools/system/test/PolicyEngineTest.java +++ b/policy-management/src/test/java/org/onap/policy/drools/system/PolicyEngineTest.java @@ -18,7 +18,7 @@ * ============LICENSE_END========================================================= */ -package org.onap.policy.drools.system.test; +package org.onap.policy.drools.system; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; diff --git a/policy-management/src/test/java/org/onap/policy/drools/system/internal/AggregatedPolicyControllerTest.java b/policy-management/src/test/java/org/onap/policy/drools/system/internal/AggregatedPolicyControllerTest.java new file mode 100644 index 00000000..4f26419f --- /dev/null +++ b/policy-management/src/test/java/org/onap/policy/drools/system/internal/AggregatedPolicyControllerTest.java @@ -0,0 +1,948 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.system.internal; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.policy.common.utils.test.PolicyAssert.assertThrows; + +import java.util.Arrays; +import java.util.List; +import java.util.Properties; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure; +import org.onap.policy.common.endpoints.event.comm.TopicEndpoint; +import org.onap.policy.common.endpoints.event.comm.TopicSink; +import org.onap.policy.common.endpoints.event.comm.TopicSource; +import org.onap.policy.drools.controller.DroolsController; +import org.onap.policy.drools.controller.DroolsControllerFactory; +import org.onap.policy.drools.features.PolicyControllerFeatureAPI; +import org.onap.policy.drools.persistence.SystemPersistence; +import org.onap.policy.drools.protocol.configuration.DroolsConfiguration; +import org.onap.policy.drools.system.internal.AggregatedPolicyController.Factory; +import org.powermock.reflect.Whitebox; + +public class AggregatedPolicyControllerTest { + + /** + * Name of the "factory" field within the {@link AggregatedPolicyController} class. + */ + private static final String FACTORY_FIELD = "factory"; + + private static final String AGG_NAME = "agg-name"; + private static final String SINK_TOPIC1 = "sink-a"; + private static final String SINK_TOPIC2 = "sink-b"; + private static final String SOURCE_TOPIC1 = "source-a"; + private static final String SOURCE_TOPIC2 = "source-b"; + + private static final String EXPECTED = "expected exception"; + + private static final String MY_EVENT = "my-event"; + + private static final String ARTIFACT1 = "artifact-a"; + private static final String GROUP1 = "group-a"; + private static final String VERSION1 = "version-a"; + + private static final String ARTIFACT2 = "artifact-b"; + private static final String GROUP2 = "group-b"; + private static final String VERSION2 = "version-b"; + + private static Factory savedFactory; + + private Properties properties; + private Factory factory; + private TopicEndpoint endpointMgr; + private List<TopicSource> sources; + private TopicSource source1; + private TopicSource source2; + private List<TopicSink> sinks; + private TopicSink sink1; + private TopicSink sink2; + private SystemPersistence persist; + private DroolsControllerFactory droolsFactory; + private DroolsController drools; + private DroolsConfiguration config; + private List<PolicyControllerFeatureAPI> providers; + private PolicyControllerFeatureAPI prov1; + private PolicyControllerFeatureAPI prov2; + private AggregatedPolicyController apc; + + @BeforeClass + public static void setUpBeforeClass() { + savedFactory = Whitebox.getInternalState(AggregatedPolicyController.class, FACTORY_FIELD); + } + + @AfterClass + public static void tearDownAfterClass() { + Whitebox.setInternalState(AggregatedPolicyController.class, FACTORY_FIELD, savedFactory); + } + + /** + * Initializes the object to be tested. + */ + @Before + public void setUp() { + properties = new Properties(); + + source1 = mock(TopicSource.class); + source2 = mock(TopicSource.class); + when(source1.getTopic()).thenReturn(SOURCE_TOPIC1); + when(source2.getTopic()).thenReturn(SOURCE_TOPIC2); + + sink1 = mock(TopicSink.class); + sink2 = mock(TopicSink.class); + when(sink1.getTopic()).thenReturn(SINK_TOPIC1); + when(sink2.getTopic()).thenReturn(SINK_TOPIC2); + + sources = Arrays.asList(source1, source2); + sinks = Arrays.asList(sink1, sink2); + + endpointMgr = mock(TopicEndpoint.class); + when(endpointMgr.addTopicSources(any())).thenReturn(sources); + when(endpointMgr.addTopicSinks(any())).thenReturn(sinks); + + persist = mock(SystemPersistence.class); + + drools = mock(DroolsController.class); + when(drools.start()).thenReturn(true); + when(drools.stop()).thenReturn(true); + when(drools.offer(any(), any())).thenReturn(true); + when(drools.deliver(any(), any())).thenReturn(true); + when(drools.lock()).thenReturn(true); + when(drools.unlock()).thenReturn(true); + when(drools.getArtifactId()).thenReturn(ARTIFACT1); + when(drools.getGroupId()).thenReturn(GROUP1); + when(drools.getVersion()).thenReturn(VERSION1); + + config = mock(DroolsConfiguration.class); + when(config.getArtifactId()).thenReturn(ARTIFACT2); + when(config.getGroupId()).thenReturn(GROUP2); + when(config.getVersion()).thenReturn(VERSION2); + + droolsFactory = mock(DroolsControllerFactory.class); + when(droolsFactory.build(any(), any(), any())).thenReturn(drools); + + prov1 = mock(PolicyControllerFeatureAPI.class); + prov2 = mock(PolicyControllerFeatureAPI.class); + + providers = Arrays.asList(prov1, prov2); + + factory = mock(Factory.class); + Whitebox.setInternalState(AggregatedPolicyController.class, FACTORY_FIELD, factory); + + when(factory.getEndpointManager()).thenReturn(endpointMgr); + when(factory.getPersistenceManager()).thenReturn(persist); + when(factory.getDroolsFactory()).thenReturn(droolsFactory); + when(factory.getFeatureProviders()).thenReturn(providers); + + apc = new AggregatedPolicyController(AGG_NAME, properties); + } + + @Test + public void testFactory() { + assertNotNull(savedFactory); + + Factory factory = new Factory(); + assertNotNull(factory.getDroolsFactory()); + assertNotNull(factory.getEndpointManager()); + assertNotNull(factory.getFeatureProviders()); + assertNotNull(factory.getPersistenceManager()); + } + + @Test + public void testAggregatedPolicyController_() { + verify(persist).storeController(AGG_NAME, properties); + } + + @Test(expected = IllegalArgumentException.class) + public void testInitDrools_Ex() { + when(factory.getDroolsFactory()).thenThrow(new RuntimeException(EXPECTED)); + new AggregatedPolicyController(AGG_NAME, properties); + } + + @Test(expected = IllegalArgumentException.class) + public void testInitDrools_Error() { + when(factory.getDroolsFactory()).thenThrow(new LinkageError(EXPECTED)); + new AggregatedPolicyController(AGG_NAME, properties); + } + + @Test + public void testUpdateDrools_ConfigVariations() { + + // config should return same values as current controller + when(config.getArtifactId()).thenReturn(ARTIFACT1.toUpperCase()); + when(config.getGroupId()).thenReturn(GROUP1.toUpperCase()); + when(config.getVersion()).thenReturn(VERSION1.toUpperCase()); + + assertTrue(apc.updateDrools(config)); + + // number of times store should have been called + int count = 0; + + // invoked once during construction, but shouldn't be invoked during update + verify(persist, times(++count)).storeController(any(), any()); + + + // different artifact + when(config.getArtifactId()).thenReturn(ARTIFACT2); + + assertTrue(apc.updateDrools(config)); + + // should be invoked during update + verify(persist, times(++count)).storeController(any(), any()); + + + // different group + when(config.getArtifactId()).thenReturn(ARTIFACT1); + when(config.getGroupId()).thenReturn(GROUP2); + + assertTrue(apc.updateDrools(config)); + + // should be invoked during update + verify(persist, times(++count)).storeController(any(), any()); + + + // different version + when(config.getGroupId()).thenReturn(GROUP1); + when(config.getVersion()).thenReturn(VERSION2); + + assertTrue(apc.updateDrools(config)); + + // should be invoked during update + verify(persist, times(++count)).storeController(any(), any()); + + + /* + * Exception case. + */ + when(drools.lock()).thenThrow(new IllegalArgumentException(EXPECTED)); + when(drools.unlock()).thenThrow(new IllegalArgumentException(EXPECTED)); + + assertFalse(apc.updateDrools(config)); + } + + @Test + public void testUpdateDrools_LockVariations() { + // not locked + apc.updateDrools(config); + verify(drools, never()).lock(); + verify(drools).unlock(); + + // locked + setUp(); + apc.lock(); + apc.updateDrools(config); + verify(drools, times(2)).lock(); + verify(drools, never()).unlock(); + } + + @Test + public void testUpdateDrools_AliveVariations() { + // not started + apc.updateDrools(config); + verify(drools, never()).start(); + verify(drools).stop(); + + // started + setUp(); + apc.start(); + apc.updateDrools(config); + verify(drools, times(2)).start(); + verify(drools, never()).stop(); + } + + @Test + public void testGetName() { + assertEquals(AGG_NAME, apc.getName()); + } + + @Test + public void testStart() { + // arrange for first provider to throw exceptions + when(prov1.beforeStart(any())).thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterStart(any())).thenThrow(new RuntimeException(EXPECTED)); + + // arrange for first sink to throw exception + when(sink1.start()).thenThrow(new RuntimeException(EXPECTED)); + + // start it + assertTrue(apc.start()); + + assertTrue(apc.isAlive()); + + verify(prov1).beforeStart(apc); + verify(prov2).beforeStart(apc); + + verify(source1).register(apc); + verify(source2).register(apc); + + verify(sink1).start(); + verify(sink2).start(); + + verify(prov1).afterStart(apc); + verify(prov2).afterStart(apc); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeStart(apc)).thenReturn(flag), + (prov, flag) -> when(prov.afterStart(apc)).thenReturn(flag), + () -> apc.start(), + prov -> verify(prov).beforeStart(apc), + () -> verify(source1).register(apc), + prov -> verify(prov).afterStart(apc)); + } + + @Test + public void testStart_AlreadyStarted() { + apc.start(); + + // re-start it + assertTrue(apc.start()); + + assertTrue(apc.isAlive()); + + // these should now have been called twice + verify(prov1, times(2)).beforeStart(apc); + verify(prov2, times(2)).beforeStart(apc); + + // these should still only have been called once + verify(source1).register(apc); + verify(sink1).start(); + verify(prov1).afterStart(apc); + } + + @Test + public void testStart_Locked() { + apc.lock(); + + // start it + assertThrows(IllegalStateException.class, () -> apc.start()); + + assertFalse(apc.isAlive()); + + // should call beforeStart(), but stop after that + verify(prov1).beforeStart(apc); + verify(prov2).beforeStart(apc); + + verify(source1, never()).register(apc); + verify(sink1, never()).start(); + verify(prov1, never()).afterStart(apc); + } + + @Test + public void testStop() { + // arrange for first provider to throw exceptions + when(prov1.beforeStop(any())).thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterStop(any())).thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + + // now stop it + assertTrue(apc.stop()); + + assertFalse(apc.isAlive()); + + verify(prov1).beforeStop(apc); + verify(prov2).beforeStop(apc); + + verify(source1).unregister(apc); + verify(source2).unregister(apc); + + verify(prov1).afterStop(apc); + verify(prov2).afterStop(apc); + + // ensure no shutdown operations were called + verify(prov1, never()).beforeShutdown(apc); + verify(droolsFactory, never()).shutdown(drools); + verify(prov2, never()).afterShutdown(apc); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeStop(apc)).thenReturn(flag), + (prov, flag) -> when(prov.afterStop(apc)).thenReturn(flag), + () -> { + apc.start(); + apc.stop(); + }, + prov -> verify(prov).beforeStop(apc), + () -> verify(source1).unregister(apc), + prov -> verify(prov).afterStop(apc)); + } + + @Test + public void testStop_AlreadyStopped() { + apc.start(); + apc.stop(); + + // now re-stop it + assertTrue(apc.stop()); + + // called again + verify(prov1, times(2)).beforeStop(apc); + verify(prov2, times(2)).beforeStop(apc); + + // should NOT be called again + verify(source1).unregister(apc); + verify(prov1).afterStop(apc); + } + + @Test + public void testShutdown() { + // arrange for first provider to throw exceptions + when(prov1.beforeShutdown(any())).thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterShutdown(any())).thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + + // now shut it down + apc.shutdown(); + + verify(prov1).beforeShutdown(apc); + verify(prov2).beforeShutdown(apc); + + assertFalse(apc.isAlive()); + + verify(prov1).afterStop(apc); + verify(prov2).afterStop(apc); + + verify(droolsFactory).shutdown(drools); + + verify(prov1).afterShutdown(apc); + verify(prov2).afterShutdown(apc); + + // ensure no halt operation was called + verify(prov1, never()).beforeHalt(apc); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeShutdown(apc)).thenReturn(flag), + (prov, flag) -> when(prov.afterShutdown(apc)).thenReturn(flag), + () -> { + apc.start(); + apc.shutdown(); + }, + prov -> verify(prov).beforeShutdown(apc), + () -> verify(source1).unregister(apc), + prov -> verify(prov).afterShutdown(apc)); + } + + @Test + public void testHalt() { + // arrange for first provider to throw exceptions + when(prov1.beforeHalt(any())).thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterHalt(any())).thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + + // now halt it + apc.halt(); + + verify(prov1).beforeHalt(apc); + verify(prov2).beforeHalt(apc); + + assertFalse(apc.isAlive()); + + verify(prov1).beforeStop(apc); + verify(prov2).beforeStop(apc); + + verify(droolsFactory).destroy(drools); + verify(persist).deleteController(AGG_NAME); + + verify(prov1).afterHalt(apc); + verify(prov2).afterHalt(apc); + + // ensure no shutdown operation was called + verify(prov1, never()).beforeShutdown(apc); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeHalt(apc)).thenReturn(flag), + (prov, flag) -> when(prov.afterHalt(apc)).thenReturn(flag), + () -> { + apc.start(); + apc.halt(); + }, + prov -> verify(prov).beforeHalt(apc), + () -> verify(source1).unregister(apc), + prov -> verify(prov).afterHalt(apc)); + } + + @Test + public void testOnTopicEvent() { + // arrange for first provider to throw exceptions + when(prov1.beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT)) + .thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true)) + .thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + + // now offer it + apc.onTopicEvent(CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + + verify(prov1).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + verify(prov2).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + + verify(drools).offer(SOURCE_TOPIC1, MY_EVENT); + + verify(prov1).afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true); + verify(prov2).afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT)) + .thenReturn(flag), + (prov, flag) -> when( + prov.afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true)) + .thenReturn(flag), + () -> { + apc.start(); + apc.onTopicEvent(CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + }, + prov -> verify(prov).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT), + () -> verify(drools).offer(SOURCE_TOPIC1, MY_EVENT), + prov -> verify(prov).afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true)); + } + + @Test + public void testOnTopicEvent_Locked() { + // start it + apc.start(); + + apc.lock(); + + // now offer it + apc.onTopicEvent(CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + + verify(prov1).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + verify(prov2).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + + // never gets this far + verify(drools, never()).offer(SOURCE_TOPIC1, MY_EVENT); + verify(prov1, never()).afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true); + } + + @Test + public void testOnTopicEvent_NotStarted() { + + // offer it + apc.onTopicEvent(CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + + verify(prov1).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + verify(prov2).beforeOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT); + + // never gets this far + verify(drools, never()).offer(SOURCE_TOPIC1, MY_EVENT); + verify(prov1, never()).afterOffer(apc, CommInfrastructure.NOOP, SOURCE_TOPIC1, MY_EVENT, true); + } + + @Test + public void testDeliver_testInitSinks() { + // arrange for first provider to throw exceptions + when(prov1.beforeDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT)) + .thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT, true)) + .thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + + // now offer it + assertTrue(apc.deliver(CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT)); + + verify(prov1).beforeDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT); + verify(prov2).beforeDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT); + + verify(drools).deliver(sink1, MY_EVENT); + verify(drools, never()).deliver(sink2, MY_EVENT); + + verify(prov1).afterDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT, true); + verify(prov2).afterDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT, true); + + // offer to the other topic + assertTrue(apc.deliver(CommInfrastructure.NOOP, SINK_TOPIC2, MY_EVENT)); + + // now both topics should show one message delivered + verify(drools).deliver(sink1, MY_EVENT); + verify(drools).deliver(sink2, MY_EVENT); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT)) + .thenReturn(flag), + (prov, flag) -> when( + prov.afterDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT, true)) + .thenReturn(flag), + () -> { + apc.start(); + apc.deliver(CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT); + }, + prov -> verify(prov).beforeDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT), + () -> verify(drools).deliver(sink1, MY_EVENT), + prov -> verify(prov).afterDeliver(apc, CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT, true)); + } + + @Test(expected = IllegalArgumentException.class) + public void testDeliver_NullTopic() { + apc.start(); + apc.deliver(CommInfrastructure.NOOP, null, MY_EVENT); + } + + @Test(expected = IllegalArgumentException.class) + public void testDeliver_EmptyTopic() { + apc.start(); + apc.deliver(CommInfrastructure.NOOP, "", MY_EVENT); + } + + @Test(expected = IllegalArgumentException.class) + public void testDeliver_NullEvent() { + apc.start(); + apc.deliver(CommInfrastructure.NOOP, SINK_TOPIC1, null); + } + + @Test(expected = IllegalStateException.class) + public void testDeliver_NotStarted() { + // do NOT start + apc.deliver(CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT); + } + + @Test(expected = IllegalStateException.class) + public void testDeliver_Locked() { + apc.start(); + apc.lock(); + apc.deliver(CommInfrastructure.NOOP, SINK_TOPIC1, MY_EVENT); + } + + @Test(expected = IllegalArgumentException.class) + public void testDeliver_UnknownTopic() { + apc.start(); + apc.deliver(CommInfrastructure.NOOP, "unknown-topic", MY_EVENT); + } + + @Test + public void testIsAlive() { + assertFalse(apc.isAlive()); + + apc.start(); + assertTrue(apc.isAlive()); + + apc.stop(); + assertFalse(apc.isAlive()); + } + + @Test + public void testLock() { + // arrange for first provider to throw exceptions + when(prov1.beforeLock(any())).thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterLock(any())).thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + + // now lock it + assertTrue(apc.lock()); + + verify(prov1).beforeLock(apc); + verify(prov2).beforeLock(apc); + + assertTrue(apc.isLocked()); + + verify(drools).lock(); + + verify(prov1).afterLock(apc); + verify(prov2).afterLock(apc); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeLock(apc)).thenReturn(flag), + (prov, flag) -> when(prov.afterLock(apc)).thenReturn(flag), + () -> { + apc.start(); + apc.lock(); + }, + prov -> verify(prov).beforeLock(apc), + () -> verify(drools).lock(), + prov -> verify(prov).afterLock(apc)); + } + + @Test + public void testLock_AlreadyLocked() { + apc.start(); + apc.lock(); + + // now re-lock it + assertTrue(apc.lock()); + + // these should be invoked a second time + verify(prov1, times(2)).beforeLock(apc); + verify(prov2, times(2)).beforeLock(apc); + + assertTrue(apc.isLocked()); + + // these shouldn't be invoked a second time + verify(drools).lock(); + verify(prov1).afterLock(apc); + } + + @Test + public void testUnlock() { + // arrange for first provider to throw exceptions + when(prov1.beforeUnlock(any())).thenThrow(new RuntimeException(EXPECTED)); + when(prov1.afterUnlock(any())).thenThrow(new RuntimeException(EXPECTED)); + + // start it + apc.start(); + apc.lock(); + + // now unlock it + assertTrue(apc.unlock()); + + verify(prov1).beforeUnlock(apc); + verify(prov2).beforeUnlock(apc); + + assertFalse(apc.isLocked()); + + verify(drools).unlock(); + + verify(prov1).afterUnlock(apc); + verify(prov2).afterUnlock(apc); + + checkBeforeAfter( + (prov, flag) -> when(prov.beforeUnlock(apc)).thenReturn(flag), + (prov, flag) -> when(prov.afterUnlock(apc)).thenReturn(flag), + () -> { + apc.start(); + apc.lock(); + apc.unlock(); + }, + prov -> verify(prov).beforeUnlock(apc), + () -> verify(drools).unlock(), + prov -> verify(prov).afterUnlock(apc)); + } + + @Test + public void testUnlock_NotLocked() { + apc.start(); + + // now unlock it + assertTrue(apc.unlock()); + + verify(prov1).beforeUnlock(apc); + verify(prov2).beforeUnlock(apc); + + assertFalse(apc.isLocked()); + + // these shouldn't be invoked + verify(drools, never()).unlock(); + verify(prov1, never()).afterLock(apc); + } + + @Test + public void testIsLocked() { + assertFalse(apc.isLocked()); + + apc.lock(); + assertTrue(apc.isLocked()); + + apc.unlock(); + assertFalse(apc.isLocked()); + } + + @Test + public void testGetTopicSources() { + assertEquals(sources, apc.getTopicSources()); + } + + @Test + public void testGetTopicSinks() { + assertEquals(sinks, apc.getTopicSinks()); + } + + @Test + public void testGetDrools() { + assertEquals(drools, apc.getDrools()); + } + + @Test + public void testGetProperties() { + assertEquals(properties, apc.getProperties()); + } + + @Test + public void testToString() { + assertTrue(apc.toString().startsWith("AggregatedPolicyController [")); + } + + /** + * Performs an operation that has a beforeXxx method and an afterXxx method. Tries + * combinations where beforeXxx and afterXxx return {@code true} and {@code false}. + * + * @param setBefore function to set the return value of a provider's beforeXxx method + * @param setAfter function to set the return value of a provider's afterXxx method + * @param action invokes the operation + * @param verifyBefore verifies that a provider's beforeXxx method was invoked + * @param verifyMiddle verifies that the action occurring between the beforeXxx loop + * and the afterXxx loop was invoked + * @param verifyAfter verifies that a provider's afterXxx method was invoked + */ + private void checkBeforeAfter(BiConsumer<PolicyControllerFeatureAPI, Boolean> setBefore, + BiConsumer<PolicyControllerFeatureAPI, Boolean> setAfter, Runnable action, + Consumer<PolicyControllerFeatureAPI> verifyBefore, Runnable verifyMiddle, + Consumer<PolicyControllerFeatureAPI> verifyAfter) { + + checkBeforeAfter_FalseFalse(setBefore, setAfter, action, verifyBefore, verifyMiddle, verifyAfter); + checkBeforeAfter_FalseTrue(setBefore, setAfter, action, verifyBefore, verifyMiddle, verifyAfter); + checkBeforeAfter_TrueFalse(setBefore, setAfter, action, verifyBefore, verifyMiddle, verifyAfter); + + // don't need to test true-true, as it's behavior is a subset of true-false + } + + /** + * Performs an operation that has a beforeXxx method and an afterXxx method. Tries the + * case where both the beforeXxx and afterXxx methods return {@code false}. + * + * @param setBefore function to set the return value of a provider's beforeXxx method + * @param setAfter function to set the return value of a provider's afterXxx method + * @param action invokes the operation + * @param verifyBefore verifies that a provider's beforeXxx method was invoked + * @param verifyMiddle verifies that the action occurring between the beforeXxx loop + * and the afterXxx loop was invoked + * @param verifyAfter verifies that a provider's afterXxx method was invoked + */ + private void checkBeforeAfter_FalseFalse(BiConsumer<PolicyControllerFeatureAPI, Boolean> setBefore, + BiConsumer<PolicyControllerFeatureAPI, Boolean> setAfter, Runnable action, + Consumer<PolicyControllerFeatureAPI> verifyBefore, Runnable verifyMiddle, + Consumer<PolicyControllerFeatureAPI> verifyAfter) { + + setUp(); + + // configure for the test + setBefore.accept(prov1, false); + setBefore.accept(prov2, false); + + setAfter.accept(prov1, false); + setAfter.accept(prov2, false); + + // run the action + action.run(); + + // verify that various methods were invoked + verifyBefore.accept(prov1); + verifyBefore.accept(prov2); + + verifyMiddle.run(); + + verifyAfter.accept(prov1); + verifyAfter.accept(prov2); + } + + /** + * Performs an operation that has a beforeXxx method and an afterXxx method. Tries the + * case where the first provider's afterXxx returns {@code true}, while the others + * return {@code false}. + * + * @param setBefore function to set the return value of a provider's beforeXxx method + * @param setAfter function to set the return value of a provider's afterXxx method + * @param action invokes the operation + * @param verifyBefore verifies that a provider's beforeXxx method was invoked + * @param verifyMiddle verifies that the action occurring between the beforeXxx loop + * and the afterXxx loop was invoked + * @param verifyAfter verifies that a provider's afterXxx method was invoked + */ + private void checkBeforeAfter_FalseTrue(BiConsumer<PolicyControllerFeatureAPI, Boolean> setBefore, + BiConsumer<PolicyControllerFeatureAPI, Boolean> setAfter, Runnable action, + Consumer<PolicyControllerFeatureAPI> verifyBefore, Runnable verifyMiddle, + Consumer<PolicyControllerFeatureAPI> verifyAfter) { + + setUp(); + + // configure for the test + setBefore.accept(prov1, false); + setBefore.accept(prov2, false); + + setAfter.accept(prov1, true); + setAfter.accept(prov2, false); + + // run the action + action.run(); + + // verify that various methods were invoked + verifyBefore.accept(prov1); + verifyBefore.accept(prov2); + + verifyMiddle.run(); + + verifyAfter.accept(prov1); + assertThrows(AssertionError.class, () -> verifyAfter.accept(prov2)); + } + + /** + * Performs an operation that has a beforeXxx method and an afterXxx method. Tries the + * case where the first provider's beforeXxx returns {@code true}, while the others + * return {@code false}. + * + * @param setBefore function to set the return value of a provider's beforeXxx method + * @param setAfter function to set the return value of a provider's afterXxx method + * @param action invokes the operation + * @param verifyBefore verifies that a provider's beforeXxx method was invoked + * @param verifyMiddle verifies that the action occurring between the beforeXxx loop + * and the afterXxx loop was invoked + * @param verifyAfter verifies that a provider's afterXxx method was invoked + */ + private void checkBeforeAfter_TrueFalse(BiConsumer<PolicyControllerFeatureAPI, Boolean> setBefore, + BiConsumer<PolicyControllerFeatureAPI, Boolean> setAfter, Runnable action, + Consumer<PolicyControllerFeatureAPI> verifyBefore, Runnable verifyMiddle, + Consumer<PolicyControllerFeatureAPI> verifyAfter) { + + setUp(); + + // configure for the test + setBefore.accept(prov1, true); + setBefore.accept(prov2, false); + + setAfter.accept(prov1, false); + setAfter.accept(prov2, false); + + // run the action + action.run(); + + // verify that various methods were invoked + verifyBefore.accept(prov1); + + // remaining methods should not have been invoked + assertThrows(AssertionError.class, () -> verifyBefore.accept(prov2)); + + assertThrows(AssertionError.class, () -> verifyMiddle.run()); + + assertThrows(AssertionError.class, () -> verifyAfter.accept(prov1)); + assertThrows(AssertionError.class, () -> verifyAfter.accept(prov2)); + } +} |