main/src/test/java/org/onap/policy/pap/main/notification/PolicyTrackerDataTest.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.assertSame;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.util.Arrays;
  29 import java.util.Collection;
  30 import java.util.List;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.onap.policy.models.pap.concepts.PolicyStatus;
  34 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
  35
  36 public class PolicyTrackerDataTest {
  37
  38     private static final ToscaPolicyTypeIdentifier TYPE = new ToscaPolicyTypeIdentifier("my-type", "1.2.3");
  39     private static final String PDP1 = "pdp-1";
  40     private static final String PDP2 = "pdp-2";
  41     private static final String PDP3 = "pdp-3";
  42     private static final String PDP4 = "pdp-4";
  43     private static final String PDP5 = "pdp-5";
  44     private static final String PDP6 = "pdp-6";
  45
  46     private Collection<String> fullSet;
  47     private PolicyTrackerData data;
  48
  49     @Before
  50     public void setUp() {
  51         fullSet = Arrays.asList(PDP1, PDP2, PDP3, PDP4, PDP5, PDP6);
  52         data = new PolicyTrackerData(TYPE);
  53     }
  54
  55     @Test
  56     public void testPolicyTrackerData_testGetPolicyType() {
  57         assertSame(TYPE, data.getPolicyType());
  58     }
  59
  60     @Test
  61     public void testIsComplete() {
  62         assertTrue(data.isComplete());
  63
  64         data.addPdps(Arrays.asList(PDP1, PDP2));
  65         assertFalse(data.isComplete());
  66
  67         data.success(PDP1);
  68         assertFalse(data.isComplete());
  69
  70         data.fail(PDP2);
  71         assertTrue(data.isComplete());
  72     }
  73
  74     @Test
  75     public void testAllSucceeded() {
  76         assertTrue(data.allSucceeded());
  77
  78         data.addPdps(Arrays.asList(PDP1, PDP2));
  79         assertFalse(data.allSucceeded());
  80
  81         data.success(PDP1);
  82         assertFalse(data.allSucceeded());
  83
  84         data.fail(PDP2);
  85         assertFalse(data.allSucceeded());
  86
  87         data.success(PDP2);
  88         assertTrue(data.allSucceeded());
  89
  90         data.fail(PDP2);
  91         assertFalse(data.allSucceeded());
  92
  93         data.success(PDP2);
  94         assertTrue(data.allSucceeded());
  95     }
  96
  97     @Test
  98     public void testIsEmpty() {
  99         assertTrue(data.isEmpty());
 100
 101         data.addPdps(Arrays.asList(PDP1, PDP2));
 102         assertFalse(data.isEmpty());
 103
 104         data.success(PDP1);
 105         assertFalse(data.isEmpty());
 106
 107         data.fail(PDP2);
 108         assertFalse(data.isEmpty());
 109
 110         data.removePdp(PDP1);
 111         assertFalse(data.isEmpty());
 112
 113         data.removePdp(PDP2);
 114         assertTrue(data.isEmpty());
 115     }
 116
 117     @Test
 118     public void testPutValuesInto() {
 119         data.addPdps(fullSet);
 120         data.success(PDP1);
 121         data.fail(PDP2);
 122         data.fail(PDP3);
 123
 124         PolicyStatus status = new PolicyStatus();
 125         data.putValuesInto(status);
 126
 127         assertEquals(1, status.getSuccessCount());
 128         assertEquals(2, status.getFailureCount());
 129         assertEquals(3, status.getIncompleteCount());
 130     }
 131
 132     @Test
 133     public void testAddPdps_testSuccess_testFail() {
 134         data.addPdps(Arrays.asList(PDP1, PDP2, PDP3, PDP4));
 135         assertEquals("[0, 0, 4]", getCounts().toString());
 136
 137         data.success(PDP1);
 138         assertEquals("[1, 0, 3]", getCounts().toString());
 139
 140         data.success(PDP2);
 141         assertEquals("[2, 0, 2]", getCounts().toString());
 142
 143         // repeat
 144         data.success(PDP2);
 145         assertEquals("[2, 0, 2]", getCounts().toString());
 146
 147         data.fail(PDP3);
 148         assertEquals("[2, 1, 1]", getCounts().toString());
 149
 150         // repeat
 151         data.fail(PDP3);
 152         assertEquals("[2, 1, 1]", getCounts().toString());
 153
 154         data.addPdps(Arrays.asList(PDP2, PDP3, PDP4, PDP5));
 155
 156         // PDP1 is still success
 157         assertEquals("[1, 0, 4]", getCounts().toString());
 158     }
 159
 160     @Test
 161     public void testRemovePdps() {
 162         data.addPdps(Arrays.asList(PDP1, PDP2, PDP3, PDP4, PDP5, PDP6));
 163         data.success(PDP1);
 164         data.success(PDP2);
 165         data.fail(PDP3);
 166         data.fail(PDP4);
 167         assertFalse(data.removePdps(Arrays.asList(PDP1, PDP3, PDP5)));
 168         assertEquals("[1, 1, 1]", getCounts().toString());
 169
 170         assertTrue(data.removePdps(Arrays.asList(PDP6)));
 171         assertEquals("[1, 1, 0]", getCounts().toString());
 172     }
 173
 174     /**
 175      * Tests removePdps(), where nothing is removed from the "incomplete" set.
 176      */
 177     @Test
 178     public void testRemovePdpsNoIncompleteRemove() {
 179         assertFalse(data.removePdps(Arrays.asList(PDP1, PDP2)));
 180         assertEquals("[0, 0, 0]", getCounts().toString());
 181     }
 182
 183     /**
 184      * Tests removePdps(), where remaining incomplete items are removed.
 185      */
 186     @Test
 187     public void testRemovePdpsAllComplete() {
 188         data.addPdps(Arrays.asList(PDP1));
 189         assertTrue(data.removePdps(Arrays.asList(PDP1)));
 190
 191         data.addPdps(Arrays.asList(PDP1, PDP2, PDP3));
 192         assertFalse(data.removePdps(Arrays.asList(PDP1)));
 193         assertTrue(data.removePdps(Arrays.asList(PDP2, PDP3)));
 194     }
 195
 196     /**
 197      * Tests removePdps() with more variations.
 198      */
 199     @Test
 200     public void testRemovePdpsVariations() {
 201         data.addPdps(Arrays.asList(PDP1, PDP2, PDP3));
 202         data.success(PDP1);
 203         data.fail(PDP2);
 204         assertEquals("[1, 1, 1]", getCounts().toString());
 205
 206         // remove PDP1, which checks removal from "success" set, while incomplete
 207         assertFalse(data.removePdps(Arrays.asList(PDP1)));
 208         assertEquals("[0, 1, 1]", getCounts().toString());
 209
 210         // remove PDP2, which checks removal from "failure" set, while incomplete
 211         assertFalse(data.removePdps(Arrays.asList(PDP2)));
 212         assertEquals("[0, 0, 1]", getCounts().toString());
 213
 214         // re-add 1 & 2
 215         data.addPdps(Arrays.asList(PDP1, PDP2));
 216         data.success(PDP1);
 217         data.fail(PDP2);
 218         assertEquals("[1, 1, 1]", getCounts().toString());
 219
 220         // remove PDP3, which checks removal from "incomplete" set
 221         assertTrue(data.removePdps(Arrays.asList(PDP3)));
 222         assertEquals("[1, 1, 0]", getCounts().toString());
 223
 224         // remove PDP1, which checks removal from "success" set, while complete
 225         assertTrue(data.removePdps(Arrays.asList(PDP1)));
 226         assertEquals("[0, 1, 0]", getCounts().toString());
 227
 228         // remove PDP2, which checks removal from "failure" set, while complete
 229         assertTrue(data.removePdps(Arrays.asList(PDP2)));
 230         assertEquals("[0, 0, 0]", getCounts().toString());
 231
 232         // re-add 1 and then remove it again
 233         data.addPdps(Arrays.asList(PDP1));
 234         assertTrue(data.removePdps(Arrays.asList(PDP1)));
 235         assertEquals("[0, 0, 0]", getCounts().toString());
 236     }
 237
 238     @Test
 239     public void testRemovePdp() {
 240         data.addPdps(Arrays.asList(PDP1, PDP2, PDP3, PDP4, PDP5, PDP6));
 241         data.success(PDP1);
 242         data.success(PDP2);
 243         data.fail(PDP3);
 244         data.fail(PDP4);
 245
 246         assertFalse(data.removePdp(PDP1));
 247         assertEquals("[1, 2, 2]", getCounts().toString());
 248
 249         assertFalse(data.removePdp(PDP2));
 250         assertEquals("[0, 2, 2]", getCounts().toString());
 251
 252         assertFalse(data.removePdp(PDP3));
 253         assertEquals("[0, 1, 2]", getCounts().toString());
 254
 255         assertFalse(data.removePdp(PDP4));
 256         assertEquals("[0, 0, 2]", getCounts().toString());
 257
 258         assertFalse(data.removePdp(PDP5));
 259         assertEquals("[0, 0, 1]", getCounts().toString());
 260
 261         assertTrue(data.removePdp(PDP6));
 262         assertEquals("[0, 0, 0]", getCounts().toString());
 263     }
 264
 265     /**
 266      * Tests removePdps(), where nothing is removed from the "incomplete" set.
 267      */
 268     @Test
 269     public void testRemovePdpNoIncompleteRemove() {
 270         assertFalse(data.removePdp(PDP1));
 271         assertEquals("[0, 0, 0]", getCounts().toString());
 272     }
 273
 274     /**
 275      * Tests removePdps(), where remaining incomplete items are removed.
 276      */
 277     @Test
 278     public void testRemovePdpAllComplete() {
 279         data.addPdps(Arrays.asList(PDP1, PDP2));
 280         assertFalse(data.removePdp(PDP1));
 281
 282         assertTrue(data.removePdp(PDP2));
 283     }
 284
 285     /**
 286      * Tests removePdp() with more variations.
 287      */
 288     @Test
 289     public void testRemovePdpVariations() {
 290         data.addPdps(Arrays.asList(PDP1, PDP2, PDP3));
 291         data.success(PDP1);
 292         data.fail(PDP2);
 293         assertEquals("[1, 1, 1]", getCounts().toString());
 294
 295         // remove PDP1, which checks removal from "success" set, while incomplete
 296         assertFalse(data.removePdp(PDP1));
 297         assertEquals("[0, 1, 1]", getCounts().toString());
 298
 299         // remove PDP2, which checks removal from "failure" set, while incomplete
 300         assertFalse(data.removePdp(PDP2));
 301         assertEquals("[0, 0, 1]", getCounts().toString());
 302
 303         // re-add 1 & 2
 304         data.addPdps(Arrays.asList(PDP1, PDP2));
 305         data.success(PDP1);
 306         data.fail(PDP2);
 307         assertEquals("[1, 1, 1]", getCounts().toString());
 308
 309         // remove PDP3, which checks removal from "incomplete" set
 310         assertTrue(data.removePdp(PDP3));
 311         assertEquals("[1, 1, 0]", getCounts().toString());
 312
 313         // remove PDP1, which checks removal from "success" set, while complete
 314         assertTrue(data.removePdp(PDP1));
 315         assertEquals("[0, 1, 0]", getCounts().toString());
 316
 317         // remove PDP2, which checks removal from "failure" set, while complete
 318         assertTrue(data.removePdp(PDP2));
 319         assertEquals("[0, 0, 0]", getCounts().toString());
 320
 321         // re-add 1 and then remove it again
 322         data.addPdps(Arrays.asList(PDP1));
 323         assertTrue(data.removePdp(PDP1));
 324         assertEquals("[0, 0, 0]", getCounts().toString());
 325     }
 326
 327     @Test
 328     public void testComplete() {
 329         // attempt to remove a PDP that isn't in the data
 330         assertFalse(data.success(PDP1));
 331
 332         // remove one that was incomplete
 333         data.addPdps(Arrays.asList(PDP1));
 334         assertTrue(data.success(PDP1));
 335
 336         // move from one set to the other
 337         assertTrue(data.fail(PDP1));
 338
 339         // already in the correct set
 340         assertFalse(data.fail(PDP1));
 341     }
 342
 343     private List<Integer> getCounts() {
 344         PolicyStatus status = new PolicyStatus();
 345         data.putValuesInto(status);
 346
 347         return Arrays.asList(status.getSuccessCount(), status.getFailureCount(), status.getIncompleteCount());
 348     }
 349 }