main/src/test/java/org/onap/policy/pap/main/notification/PolicyDeployTrackerTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP PAP
   4  * ================================================================================
   5  * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.main.notification;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.Matchers.any;
  27 import static org.mockito.Mockito.never;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Collections;
  35 import java.util.List;
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.mockito.Mock;
  39 import org.mockito.MockitoAnnotations;
  40 import org.onap.policy.models.pap.concepts.PolicyStatus;
  41
  42 public class PolicyDeployTrackerTest extends PolicyCommonSupport {
  43
  44     @Mock
  45     private PolicyTrackerData data;
  46
  47     private PolicyDeployTracker tracker;
  48
  49     /**
  50      * Creates various objects, including {@link #tracker}.
  51      */
  52     @Before
  53     public void setUp() {
  54         MockitoAnnotations.initMocks(this);
  55
  56         super.setUp();
  57
  58         tracker = new PolicyDeployTracker();
  59     }
  60
  61     /**
  62      * Simple test with one PDP that immediately responds with success.
  63      */
  64     @Test
  65     public void testSimpleImmediateSuccess() {
  66         tracker.addData(makeData(policy1, PDP1));
  67
  68         // indicate that PDP1 has succeeded
  69         List<PolicyStatus> statusList = new ArrayList<>();
  70         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
  71
  72         assertEquals(1, statusList.size());
  73         assertEquals(policy1, statusList.get(0).getPolicy());
  74         assertEquals(type, statusList.get(0).getPolicyType());
  75         assertEquals("[1, 0, 0]", getCounts(statusList.get(0)).toString());
  76
  77         // indicate that PDP1 has succeeded again - should be no output
  78         statusList.clear();
  79         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
  80         assertEquals(0, statusList.size());
  81
  82         // indicate failure
  83         statusList.clear();
  84         tracker.processResponse(PDP1, Arrays.asList(), statusList);
  85         assertEquals(1, statusList.size());
  86         assertEquals("[0, 1, 0]", getCounts(statusList.get(0)).toString());
  87
  88         // indicate that PDP1 has failed again - should be no output
  89         statusList.clear();
  90         tracker.processResponse(PDP1, Arrays.asList(), statusList);
  91         assertEquals(0, statusList.size());
  92
  93         // indicate that PDP1 has succeeded again
  94         statusList.clear();
  95         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
  96         assertEquals("[1, 0, 0]", getCounts(statusList.get(0)).toString());
  97     }
  98
  99     /**
 100      * Simple test with one PDP that immediately responds with success.
 101      */
 102     @Test
 103     public void testSimpleImmediateFail() {
 104         tracker.addData(makeData(policy1, PDP1));
 105
 106         // indicate that PDP1 has failed
 107         List<PolicyStatus> statusList = new ArrayList<>();
 108         tracker.processResponse(PDP1, Arrays.asList(), statusList);
 109         assertEquals(1, statusList.size());
 110         assertEquals("[0, 1, 0]", getCounts(statusList.get(0)).toString());
 111
 112         // indicate that PDP1 has failed again - should be no output
 113         statusList.clear();
 114         tracker.processResponse(PDP1, Arrays.asList(), statusList);
 115         assertEquals(0, statusList.size());
 116
 117         // indicate success
 118         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
 119
 120         assertEquals(1, statusList.size());
 121         assertEquals(policy1, statusList.get(0).getPolicy());
 122         assertEquals(type, statusList.get(0).getPolicyType());
 123         assertEquals("[1, 0, 0]", getCounts(statusList.get(0)).toString());
 124
 125         // indicate that PDP1 has succeeded again - should be no output
 126         statusList.clear();
 127         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
 128         assertEquals(0, statusList.size());
 129     }
 130
 131     /**
 132      * Simple test where PDP is removed and then it responds.
 133      */
 134     @Test
 135     public void testSimpleRemove() {
 136         tracker.addData(makeData(policy1, PDP1));
 137
 138         // remove the PDP
 139         List<PolicyStatus> statusList = new ArrayList<>();
 140         tracker.removePdp(PDP1, statusList);
 141         assertEquals(1, statusList.size());
 142         assertEquals(policy1, statusList.get(0).getPolicy());
 143         assertEquals(type, statusList.get(0).getPolicyType());
 144         assertEquals("[0, 0, 0]", getCounts(statusList.get(0)).toString());
 145
 146         /*
 147          * indicate that PDP1 has succeeded - should be no message since PDP was removed
 148          * from the policy
 149          */
 150         statusList.clear();
 151         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
 152         assertEquals(0, statusList.size());
 153
 154         /*
 155          * indicate that PDP1 has failed - should be no message since PDP was removed
 156          * from the policy
 157          */
 158         statusList.clear();
 159         tracker.processResponse(PDP1, Arrays.asList(), statusList);
 160         assertEquals(0, statusList.size());
 161     }
 162
 163     /**
 164      * Test with multiple PDPs.
 165      */
 166     @Test
 167     public void testMulti() {
 168         tracker.addData(makeData(policy1, PDP1, PDP2));
 169
 170         // indicate that PDP2 has succeeded
 171         List<PolicyStatus> statusList = new ArrayList<>();
 172         tracker.processResponse(PDP2, Arrays.asList(policy1), statusList);
 173         assertEquals(0, statusList.size());
 174
 175         // indicate that PDP1 has succeeded
 176         statusList.clear();
 177         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
 178
 179         assertEquals(1, statusList.size());
 180         assertEquals(policy1, statusList.get(0).getPolicy());
 181         assertEquals(type, statusList.get(0).getPolicyType());
 182         assertEquals("[2, 0, 0]", getCounts(statusList.get(0)).toString());
 183
 184         // indicate that PDP1 has failed - should get a notification
 185         statusList.clear();
 186         tracker.processResponse(PDP1, Collections.emptyList(), statusList);
 187         assertEquals(1, statusList.size());
 188         assertEquals(policy1, statusList.get(0).getPolicy());
 189         assertEquals(type, statusList.get(0).getPolicyType());
 190         assertEquals("[1, 1, 0]", getCounts(statusList.get(0)).toString());
 191
 192         // indicate that PDP1 has succeeded
 193         statusList.clear();
 194         tracker.processResponse(PDP1, Arrays.asList(policy1), statusList);
 195         assertEquals(1, statusList.size());
 196         assertEquals("[2, 0, 0]", getCounts(statusList.get(0)).toString());
 197
 198         // remove PDP2 - expect message
 199         statusList.clear();
 200         tracker.removePdp(PDP2, statusList);
 201         assertEquals(1, statusList.size());
 202         assertEquals("[1, 0, 0]", getCounts(statusList.get(0)).toString());
 203
 204         // re-add PDP2
 205         tracker.addData(makeData(policy1, PDP2));
 206
 207         // indicate that PDP2 has succeeded; PDP1 should still be ok
 208         statusList.clear();
 209         tracker.processResponse(PDP2, Arrays.asList(policy1), statusList);
 210         assertEquals(1, statusList.size());
 211         assertEquals("[2, 0, 0]", getCounts(statusList.get(0)).toString());
 212     }
 213
 214     @Test
 215     public void testUpdateData() {
 216         // when success returns false
 217         assertFalse(tracker.updateData(PDP1, data, true));
 218         verify(data).success(PDP1);
 219         verify(data, never()).fail(any());
 220
 221         // when inactive
 222         assertFalse(tracker.updateData(PDP1, data, false));
 223         verify(data).success(PDP1);
 224         verify(data).fail(any());
 225
 226         // when success & fail return true
 227         when(data.success(PDP1)).thenReturn(true);
 228         when(data.fail(PDP1)).thenReturn(true);
 229         assertTrue(tracker.updateData(PDP1, data, true));
 230         verify(data, times(2)).success(PDP1);
 231         verify(data, times(1)).fail(PDP1);
 232
 233         // when inactive
 234         assertTrue(tracker.updateData(PDP1, data, false));
 235         verify(data, times(2)).success(PDP1);
 236         verify(data, times(2)).fail(PDP1);
 237     }
 238
 239     @Test
 240     public void testShouldRemove() {
 241         // when data is complete, but not empty
 242         when(data.isComplete()).thenReturn(true);
 243         when(data.isEmpty()).thenReturn(false);
 244         assertFalse(tracker.shouldRemove(data));
 245
 246         // when data is empty
 247         when(data.isEmpty()).thenReturn(true);
 248         assertTrue(tracker.shouldRemove(data));
 249     }
 250 }