summaryrefslogtreecommitdiffstats
path: root/jjb/multicloud/multicloud-k8s.yaml
AgeCommit message (Expand)AuthorFilesLines
2023-05-03Refactor: Cleanup for pre-commitAndrew Grimberg1-44/+20
2023-04-10Chore: Use a smaller node for release jobsJessica Wagantall1-1/+1
2022-12-15CI: remove unsupported Jenkins jobs streams from multicloudKevin Sandi1-4/+0
2022-09-30Chore: Revert back to ubuntu1804-builderBengt Thuree1-1/+1
2022-09-28Chore: Move to ubuntu2004-builderBengt Thuree1-1/+1
2021-08-03[Multicloud] Disable KUD tests on Honolulu branchKonrad Bańka1-0/+4
2021-04-15[MULTICLOUD] Enable CI on Honolulu for K8spluginKonrad Bańka1-9/+2
2020-07-07Use Go 1.14 for multicloud-k8s CI buildLarry Sachs1-2/+2
2020-04-21[multicloud] Provide timeout for KUD building CI jobKonrad Bańka1-0/+1
2020-04-08Add gerrit release jobs to multicloud-k8sEric Multanen1-0/+2
2020-03-31Move k8s project to builderJessica Wagantall1-1/+1
2020-03-31Migrate to ubuntu1804-builderJessica Wagantall1-1/+1
2020-03-12Migrate to ARM Ubuntu18.04 nodeJessica Wagantall1-1/+1
2020-01-14Ensure INFO runs in centosJessica Wagantall1-0/+1
2019-10-31Assign bigger jenkins slave for KUD verification jobKonrad Bańka1-1/+0
2019-09-09Switch KUD deploying job to run on changeset basisKonrad Bańka1-0/+5
2019-08-28Update the build node used for multicloud-k8sKiran Kamineni1-1/+1
2019-08-07Update path for makefile buildKiran Kamineni1-1/+1
2019-04-25Move multicloud-k8s build to golang112Kiran Kamineni1-2/+2
2019-03-07Add INFO.yaml verify job (MULTI)Jessica Wagantall1-0/+8
2019-02-05temporary disable arm64 docker for multicloudPaul Vaduva1-21/+21
2018-12-07Add arm64 docker build for multicloudPaul Vaduva1-0/+22
2018-10-29Move to golang 1.11Kiran Kamineni1-0/+1
2018-10-15Create MultiCloud k8s Docker jobVictor Morales1-0/+3
2018-08-30Add tox execution in multicloud/k8s projectVictor Morales1-0/+5
2018-08-24Update Job trigger for Kubernetes PluginShashank Kumar Shankar1-4/+4
2018-08-22Add Job trigger for Kubernetes PluginShashank Kumar Shankar1-0/+16
#n466'>466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 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));
    }
}