main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestSessionData.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP PAP
   4  * ================================================================================
   5  * Copyright (C) 2019 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.rest.depundep;
  22
  23 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
  24 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertFalse;
  28 import static org.junit.Assert.assertNull;
  29 import static org.junit.Assert.assertSame;
  30 import static org.junit.Assert.assertTrue;
  31 import static org.mockito.Matchers.any;
  32 import static org.mockito.Mockito.never;
  33 import static org.mockito.Mockito.times;
  34 import static org.mockito.Mockito.verify;
  35 import static org.mockito.Mockito.when;
  36
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.Collection;
  40 import java.util.Collections;
  41 import java.util.Comparator;
  42 import java.util.Iterator;
  43 import java.util.List;
  44 import java.util.TreeSet;
  45 import java.util.function.Supplier;
  46 import javax.ws.rs.core.Response.Status;
  47 import org.apache.commons.lang3.tuple.Pair;
  48 import org.junit.Before;
  49 import org.junit.Test;
  50 import org.mockito.ArgumentCaptor;
  51 import org.onap.policy.models.base.PfModelException;
  52 import org.onap.policy.models.pdp.concepts.PdpGroup;
  53 import org.onap.policy.models.pdp.concepts.PdpStateChange;
  54 import org.onap.policy.models.pdp.concepts.PdpUpdate;
  55 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  56 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter;
  57 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
  58 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifierOptVersion;
  59 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  60 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
  61 import org.onap.policy.pap.main.notification.PolicyPdpNotificationData;
  62
  63 public class TestSessionData extends ProviderSuper {
  64     private static final String GROUP_NAME = "groupA";
  65     private static final String PDP1 = "pdp_1";
  66     private static final String PDP2 = "pdp_2";
  67     private static final String PDP3 = "pdp_3";
  68     private static final String POLICY_VERSION_PREFIX = "1.2.";
  69     private static final String POLICY_NAME = "myPolicy";
  70     private static final String POLICY_VERSION = POLICY_VERSION_PREFIX + "3";
  71     private static final String POLICY_TYPE = "myType";
  72     private static final String POLICY_TYPE_VERSION = "10.20.30";
  73     private static final String EXPECTED_EXCEPTION = "expected exception";
  74
  75     private SessionData session;
  76     private ToscaPolicyIdentifierOptVersion ident;
  77     private ToscaPolicyTypeIdentifier type;
  78     private ToscaPolicyTypeIdentifier type2;
  79     private PdpGroup group1;
  80     private PdpGroup group2;
  81
  82     /**
  83      * Initializes mocks and a session.
  84      *
  85      * @throws Exception if an error occurs
  86      */
  87     @Before
  88     public void setUp() throws Exception {
  89         super.setUp();
  90
  91         ident = new ToscaPolicyIdentifierOptVersion(POLICY_NAME, POLICY_VERSION);
  92         type = new ToscaPolicyTypeIdentifier(POLICY_TYPE, POLICY_TYPE_VERSION);
  93         type2 = new ToscaPolicyTypeIdentifier(POLICY_TYPE, POLICY_TYPE_VERSION + "0");
  94         group1 = loadGroup("group1.json");
  95         group2 = loadGroup("group2.json");
  96
  97         session = new SessionData(dao);
  98     }
  99
 100     @Test
 101     public void testGetPolicyType() throws Exception {
 102         ToscaPolicyType policy1 = makePolicyType(POLICY_TYPE, POLICY_TYPE_VERSION);
 103         when(dao.getPolicyTypeList(POLICY_TYPE, POLICY_TYPE_VERSION)).thenReturn(Arrays.asList(policy1));
 104
 105         assertSame(policy1, session.getPolicyType(type));
 106
 107         // retrieve a second time - should use cache
 108         assertSame(policy1, session.getPolicyType(type));
 109     }
 110
 111     @Test
 112     public void testGetPolicyType_NotFound() throws Exception {
 113         when(dao.getPolicyTypeList(any(), any())).thenReturn(Collections.emptyList());
 114
 115         assertNull(session.getPolicyType(type));
 116     }
 117
 118     @Test
 119     public void testGetPolicyType_DaoEx() throws Exception {
 120         PfModelException ex = new PfModelException(Status.INTERNAL_SERVER_ERROR, EXPECTED_EXCEPTION);
 121         when(dao.getPolicyTypeList(POLICY_TYPE, POLICY_TYPE_VERSION)).thenThrow(ex);
 122
 123         assertThatThrownBy(() -> session.getPolicyType(type)).isSameAs(ex);
 124     }
 125
 126     @Test
 127     public void testGetPolicy_NullVersion() throws Exception {
 128         ToscaPolicy policy1 = makePolicy(POLICY_NAME, POLICY_VERSION);
 129         when(dao.getFilteredPolicyList(any())).thenReturn(Arrays.asList(policy1));
 130
 131         ident.setVersion(null);
 132         assertSame(policy1, session.getPolicy(ident));
 133
 134         ToscaPolicyFilter filter = getPolicyFilter();
 135         assertEquals(POLICY_NAME, filter.getName());
 136         assertEquals(ToscaPolicyFilter.LATEST_VERSION, filter.getVersion());
 137         assertEquals(null, filter.getVersionPrefix());
 138
 139         // retrieve a second time using full version - should use cache
 140         assertSame(policy1, session.getPolicy(new ToscaPolicyIdentifierOptVersion(policy1.getIdentifier())));
 141         verify(dao).getFilteredPolicyList(any());
 142     }
 143
 144     @Test
 145     public void testGetPolicy_MajorVersion() throws Exception {
 146         ToscaPolicy policy1 = makePolicy(POLICY_NAME, POLICY_VERSION);
 147         when(dao.getFilteredPolicyList(any())).thenReturn(Arrays.asList(policy1));
 148
 149         ident.setVersion("1");
 150         assertSame(policy1, session.getPolicy(ident));
 151
 152         ToscaPolicyFilter filter = getPolicyFilter();
 153         assertEquals(POLICY_NAME, filter.getName());
 154         assertEquals(ToscaPolicyFilter.LATEST_VERSION, filter.getVersion());
 155         assertEquals("1.", filter.getVersionPrefix());
 156
 157         // retrieve a second time using full version - should use cache
 158         assertSame(policy1, session.getPolicy(new ToscaPolicyIdentifierOptVersion(policy1.getIdentifier())));
 159         verify(dao).getFilteredPolicyList(any());
 160     }
 161
 162     @Test
 163     public void testGetPolicy_MajorMinorVersion() throws Exception {
 164         ToscaPolicy policy1 = makePolicy(POLICY_NAME, POLICY_VERSION);
 165         when(dao.getFilteredPolicyList(any())).thenReturn(Arrays.asList(policy1));
 166
 167         ident.setVersion(POLICY_VERSION);
 168         assertSame(policy1, session.getPolicy(ident));
 169
 170         ToscaPolicyFilter filter = getPolicyFilter();
 171         assertEquals(POLICY_NAME, filter.getName());
 172         assertEquals(POLICY_VERSION, filter.getVersion());
 173         assertEquals(null, filter.getVersionPrefix());
 174
 175         // retrieve a second time using full version - should use cache
 176         assertSame(policy1, session.getPolicy(new ToscaPolicyIdentifierOptVersion(policy1.getIdentifier())));
 177         verify(dao).getFilteredPolicyList(any());
 178     }
 179
 180     @Test
 181     public void testGetPolicy_NotFound() throws Exception {
 182         when(dao.getFilteredPolicyList(any())).thenReturn(Collections.emptyList());
 183
 184         assertNull(session.getPolicy(ident));
 185     }
 186
 187     @Test
 188     public void testGetPolicy_DaoEx() throws Exception {
 189         PfModelException ex = new PfModelException(Status.INTERNAL_SERVER_ERROR, EXPECTED_EXCEPTION);
 190         when(dao.getFilteredPolicyList(any())).thenThrow(ex);
 191
 192         assertThatThrownBy(() -> session.getPolicy(ident)).isSameAs(ex);
 193     }
 194
 195     @Test
 196     public void testIsVersionPrefix() {
 197         assertTrue(SessionData.isVersionPrefix("1"));
 198         assertTrue(SessionData.isVersionPrefix("12"));
 199         assertTrue(SessionData.isVersionPrefix("1.2"));
 200         assertTrue(SessionData.isVersionPrefix("1.23"));
 201
 202         assertFalse(SessionData.isVersionPrefix("1."));
 203         assertFalse(SessionData.isVersionPrefix("1.2."));
 204         assertFalse(SessionData.isVersionPrefix("1.2.3"));
 205         assertFalse(SessionData.isVersionPrefix("1.2.3."));
 206         assertFalse(SessionData.isVersionPrefix("1.2.3.4"));
 207     }
 208
 209     @Test
 210     public void testAddRequests_testGetPdpStateChanges_testGetPdpUpdates() {
 211         // pre-load with a update and state-change for other PDPs
 212         PdpUpdate update2 = makeUpdate(PDP2);
 213         session.addUpdate(update2);
 214
 215         PdpStateChange change3 = makeStateChange(PDP3);
 216         session.addStateChange(change3);
 217
 218         // add requests
 219         PdpUpdate update = makeUpdate(PDP1);
 220         PdpStateChange change = makeStateChange(PDP1);
 221         session.addRequests(update, change);
 222         verifyRequests(update, update2, change, change3);
 223
 224         /*
 225          * repeat with a new pair
 226          */
 227         update = makeUpdate(PDP1);
 228         change = makeStateChange(PDP1);
 229         session.addRequests(update, change);
 230         verifyRequests(update, update2, change, change3);
 231
 232         // just make an update this time
 233         update = makeUpdate(PDP1);
 234         session.addUpdate(update);
 235         verifyRequests(update, update2, change, change3);
 236     }
 237
 238     private void verifyRequests(PdpUpdate update, PdpUpdate update2, PdpStateChange change, PdpStateChange change3) {
 239         List<Pair<PdpUpdate, PdpStateChange>> requests = sort(session.getPdpRequests(), this::compare);
 240         assertEquals(3, requests.size());
 241
 242         System.out.println(requests);
 243         System.out.println(update);
 244
 245         Iterator<Pair<PdpUpdate, PdpStateChange>> reqiter = requests.iterator();
 246         Pair<PdpUpdate, PdpStateChange> pair = reqiter.next();
 247         assertSame(update, pair.getLeft());
 248         assertSame(change, pair.getRight());
 249
 250         pair = reqiter.next();
 251         assertSame(update2, pair.getLeft());
 252         assertSame(null, pair.getRight());
 253
 254         pair = reqiter.next();
 255         assertSame(null, pair.getLeft());
 256         assertSame(change3, pair.getRight());
 257
 258         // verify individual lists
 259         List<PdpUpdate> updates = Arrays.asList(update, update2);
 260         assertEquals(sort(updates, this::compare), sort(session.getPdpUpdates(), this::compare));
 261
 262         List<PdpStateChange> changes = Arrays.asList(change, change3);
 263         assertEquals(sort(changes, this::compare), sort(session.getPdpStateChanges(), this::compare));
 264     }
 265
 266     @Test
 267     public void testAddRequests_MismatchedNames() {
 268         PdpUpdate update = makeUpdate(PDP1);
 269         PdpStateChange change = makeStateChange(PDP2);
 270         assertThatIllegalArgumentException().isThrownBy(() -> session.addRequests(update, change))
 271                         .withMessage("PDP name mismatch pdp_1, pdp_2");
 272     }
 273
 274     @Test
 275     public void testAddUpdate_testGetPdpUpdates() {
 276         // several different updates, but one duplicate
 277         PdpUpdate update1 = makeUpdate(PDP1);
 278         session.addUpdate(update1);
 279
 280         PdpUpdate update2 = makeUpdate(PDP2);
 281         session.addUpdate(update2);
 282
 283         PdpUpdate update3 = makeUpdate(PDP3);
 284         session.addUpdate(update3);
 285
 286         List<PdpUpdate> lst = sort(getUpdateRequests(), this::compare);
 287         assertEquals(Arrays.asList(update1, update2, update3).toString(), lst.toString());
 288
 289         // overwrite one
 290         update2 = makeUpdate(PDP2);
 291         session.addUpdate(update2);
 292
 293         lst = sort(getUpdateRequests(), this::compare);
 294         assertEquals(Arrays.asList(update1, update2, update3).toString(), lst.toString());
 295     }
 296
 297     @Test
 298     public void testAddStateChange_testGetPdpStateChanges() {
 299         // several different changes, but one duplicate
 300         PdpStateChange change1 = makeStateChange(PDP1);
 301         session.addStateChange(change1);
 302
 303         PdpStateChange change2 = makeStateChange(PDP2);
 304         session.addStateChange(change2);
 305
 306         PdpStateChange change3 = makeStateChange(PDP3);
 307         session.addStateChange(change3);
 308
 309         List<PdpStateChange> lst = sort(getStateChangeRequests(), this::compare);
 310         assertEquals(Arrays.asList(change1, change2, change3).toString(), lst.toString());
 311
 312         // overwrite one
 313         change2 = makeStateChange(PDP2);
 314         session.addStateChange(change2);
 315
 316         lst = sort(getStateChangeRequests(), this::compare);
 317         assertEquals(Arrays.asList(change1, change2, change3).toString(), lst.toString());
 318     }
 319
 320     private ToscaPolicyType makePolicyType(String name, String version) {
 321         ToscaPolicyType type = new ToscaPolicyType();
 322
 323         type.setName(name);
 324         type.setVersion(version);
 325
 326         return type;
 327     }
 328
 329     private ToscaPolicy makePolicy(String name, String version) {
 330         ToscaPolicy policy = new ToscaPolicy();
 331
 332         policy.setName(name);
 333         policy.setVersion(version);
 334
 335         return policy;
 336     }
 337
 338     @Test
 339     public void testCreate() throws Exception {
 340         assertTrue(session.isUnchanged());
 341
 342         session.create(group1);
 343         assertSame(group1, session.getGroup(group1.getName()));
 344         assertFalse(session.isUnchanged());
 345
 346         // can add another
 347         session.create(group2);
 348         assertSame(group1, session.getGroup(group1.getName()));
 349         assertSame(group2, session.getGroup(group2.getName()));
 350         assertFalse(session.isUnchanged());
 351
 352         // cannot overwrite
 353         assertThatIllegalStateException().isThrownBy(() -> session.create(group1))
 354                         .withMessage("group already cached: groupA");
 355     }
 356
 357     @Test
 358     public void testUpdate() throws Exception {
 359         assertTrue(session.isUnchanged());
 360
 361         // force the groups into the cache
 362         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1, group2));
 363         session.getActivePdpGroupsByPolicyType(type);
 364
 365         /*
 366          * try group 1
 367          */
 368         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
 369         PdpGroup newgrp = new PdpGroup(group1);
 370         session.update(newgrp);
 371         assertFalse(session.isUnchanged());
 372
 373         // repeat
 374         newgrp = new PdpGroup(group1);
 375         session.update(newgrp);
 376         assertFalse(session.isUnchanged());
 377
 378         /*
 379          * try group 2
 380          */
 381         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group2));
 382         newgrp = new PdpGroup(group2);
 383         session.update(newgrp);
 384         assertFalse(session.isUnchanged());
 385
 386         // repeat
 387         newgrp = new PdpGroup(group2);
 388         session.update(newgrp);
 389         assertFalse(session.isUnchanged());
 390     }
 391
 392     @Test
 393     public void testUpdate_NotInCache() throws Exception {
 394         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
 395
 396         assertThatIllegalStateException().isThrownBy(() -> session.update(new PdpGroup(group1)))
 397                         .withMessage("group not cached: groupA");
 398     }
 399
 400     @Test
 401     public void testGetGroup() throws Exception {
 402         when(dao.getPdpGroups(GROUP_NAME)).thenReturn(Arrays.asList(group1));
 403
 404         assertSame(group1, session.getGroup(GROUP_NAME));
 405         verify(dao).getPdpGroups(any());
 406
 407         // repeat
 408         assertSame(group1, session.getGroup(GROUP_NAME));
 409
 410         // should not access dao again
 411         verify(dao, times(1)).getPdpGroups(any());
 412     }
 413
 414     @Test
 415     public void testGetGroup_NotFound() throws Exception {
 416         when(dao.getPdpGroups(GROUP_NAME)).thenReturn(Collections.emptyList());
 417
 418         assertNull(session.getGroup(GROUP_NAME));
 419         verify(dao).getPdpGroups(any());
 420
 421         // repeat
 422         assertNull(session.getGroup(GROUP_NAME));
 423
 424         // SHOULD access dao again
 425         verify(dao, times(2)).getPdpGroups(GROUP_NAME);
 426
 427         // find it this time
 428         when(dao.getPdpGroups(GROUP_NAME)).thenReturn(Arrays.asList(group1));
 429         assertSame(group1, session.getGroup(GROUP_NAME));
 430         verify(dao, times(3)).getPdpGroups(GROUP_NAME);
 431     }
 432
 433     @Test
 434     public void testGetGroup_DaoEx() throws Exception {
 435         PfModelException ex = new PfModelException(Status.BAD_REQUEST, EXPECTED_EXCEPTION);
 436         when(dao.getPdpGroups(GROUP_NAME)).thenThrow(ex);
 437
 438         assertThatThrownBy(() -> session.getGroup(GROUP_NAME)).isSameAs(ex);
 439     }
 440
 441     @Test
 442     public void testGetActivePdpGroupsByPolicyType() throws Exception {
 443         List<PdpGroup> groups = Arrays.asList(group1, group2);
 444         when(dao.getFilteredPdpGroups(any())).thenReturn(groups);
 445
 446         // repeat
 447         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
 448         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
 449         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
 450
 451         // only invoked once - should have used the cache for the rest
 452         verify(dao, times(1)).getFilteredPdpGroups(any());
 453     }
 454
 455     @Test
 456     public void testAddGroup() throws Exception {
 457         List<PdpGroup> groups = Arrays.asList(group1, group2);
 458         when(dao.getFilteredPdpGroups(any())).thenReturn(groups);
 459
 460         // query by each type
 461         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
 462         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type2));
 463
 464         // invoked once for each type
 465         verify(dao, times(2)).getFilteredPdpGroups(any());
 466
 467         // repeat - should be no more invocations
 468         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
 469         assertEquals(groups, session.getActivePdpGroupsByPolicyType(type2));
 470         verify(dao, times(2)).getFilteredPdpGroups(any());
 471     }
 472
 473     @Test
 474     public void testUpdateDb() throws Exception {
 475         // force the groups into the cache
 476         PdpGroup group3 = loadGroup("group3.json");
 477         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1, group2, group3));
 478         session.getActivePdpGroupsByPolicyType(type);
 479
 480         // create groups 4 & 5
 481         PdpGroup group4 = loadGroup("group4.json");
 482         session.create(group4);
 483
 484         PdpGroup group5 = loadGroup("group5.json");
 485         session.create(group5);
 486
 487         // update group 1
 488         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
 489         PdpGroup newgrp1 = new PdpGroup(group1);
 490         session.update(newgrp1);
 491
 492         // another update
 493         newgrp1 = new PdpGroup(newgrp1);
 494         session.update(newgrp1);
 495
 496         // update group 3
 497         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group3));
 498         PdpGroup newgrp3 = new PdpGroup(group3);
 499         session.update(newgrp3);
 500
 501         // update group 5
 502         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group5));
 503         PdpGroup newgrp5 = new PdpGroup(group5);
 504         session.update(newgrp5);
 505
 506         // push the changes to the DB
 507         session.updateDb();
 508
 509         // expect one create for groups 4 & 5 (group5 replaced by newgrp5)
 510         List<PdpGroup> creates = getGroupCreates();
 511         assertEquals(2, creates.size());
 512         assertSame(group4, creates.get(0));
 513         assertSame(newgrp5, creates.get(1));
 514
 515         // expect one update for groups 1 & 3
 516         List<PdpGroup> updates = getGroupUpdates();
 517         assertEquals(2, updates.size());
 518         assertSame(newgrp1, updates.get(0));
 519         assertSame(newgrp3, updates.get(1));
 520     }
 521
 522     @Test
 523     public void testUpdateDb_Empty() throws Exception {
 524         // force data into the cache
 525         when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1, group2));
 526         session.getActivePdpGroupsByPolicyType(type);
 527
 528         session.updateDb();
 529         verify(dao, never()).createPdpGroups(any());
 530         verify(dao, never()).updatePdpGroups(any());
 531     }
 532
 533     @Test
 534     public void testDeleteGroupFromDb() throws Exception {
 535         session.deleteGroupFromDb(group1);
 536
 537         verify(dao).deletePdpGroup(group1.getName());
 538     }
 539
 540     @Test
 541     public void testTrackDeploy() throws PfModelException {
 542         testTrack(session::getDeployData, session::getUndeployData, session::trackDeploy);
 543     }
 544
 545     /**
 546      * Tests trackDeploy() when there is something in the undeployed list.
 547      *
 548      * @throws PfModelException if an error occurs
 549      */
 550     @Test
 551     public void testTrackDeployRemoveUndeploy() throws PfModelException {
 552         testTrack(session::getDeployData, session::getUndeployData, session::trackUndeploy, session::trackDeploy);
 553     }
 554
 555     @Test
 556     public void testTrackUndeploy() throws PfModelException {
 557         testTrack(session::getUndeployData, session::getDeployData, session::trackUndeploy);
 558     }
 559
 560     /**
 561      * Tests trackUndeploy() when there is something in the deployed list.
 562      *
 563      * @throws PfModelException if an error occurs
 564      */
 565     @Test
 566     public void testTrackUndeployRemoveUndeploy() throws PfModelException {
 567         testTrack(session::getUndeployData, session::getDeployData, session::trackDeploy, session::trackUndeploy);
 568     }
 569
 570     protected void testTrack(Supplier<Collection<PolicyPdpNotificationData>> expected,
 571                     Supplier<Collection<PolicyPdpNotificationData>> unexpected, TrackEx... trackFuncs)
 572                     throws PfModelException {
 573
 574         ToscaPolicy policy = makePolicy(POLICY_NAME, POLICY_VERSION);
 575         policy.setType(POLICY_TYPE);
 576         policy.setTypeVersion(POLICY_TYPE_VERSION);
 577
 578         when(dao.getFilteredPolicyList(any())).thenReturn(Arrays.asList(policy));
 579
 580         ToscaPolicyIdentifier policyId = new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION);
 581         List<String> pdps = Arrays.asList(PDP1, PDP2);
 582
 583         for (TrackEx trackFunc : trackFuncs) {
 584             trackFunc.accept(policyId, pdps);
 585         }
 586
 587         // "unexpected" list should be empty of any PDPs
 588         Collection<PolicyPdpNotificationData> dataList = unexpected.get();
 589         assertTrue(dataList.size() <= 1);
 590         if (!dataList.isEmpty()) {
 591             PolicyPdpNotificationData data = dataList.iterator().next();
 592             assertTrue(data.getPdps().isEmpty());
 593         }
 594
 595         dataList = expected.get();
 596         assertEquals(1, dataList.size());
 597
 598         PolicyPdpNotificationData data = dataList.iterator().next();
 599         assertEquals(policyId, data.getPolicyId());
 600         assertEquals(type, data.getPolicyType());
 601         assertEquals("[pdp_1, pdp_2]", new TreeSet<>(data.getPdps()).toString());
 602     }
 603
 604     private PdpUpdate makeUpdate(String pdpName) {
 605         PdpUpdate update = new PdpUpdate();
 606
 607         update.setName(pdpName);
 608
 609         return update;
 610     }
 611
 612     private PdpStateChange makeStateChange(String pdpName) {
 613         PdpStateChange change = new PdpStateChange();
 614
 615         change.setName(pdpName);
 616
 617         return change;
 618     }
 619
 620     private ToscaPolicyFilter getPolicyFilter() throws Exception {
 621         ArgumentCaptor<ToscaPolicyFilter> captor = ArgumentCaptor.forClass(ToscaPolicyFilter.class);
 622         verify(dao).getFilteredPolicyList(captor.capture());
 623
 624         return captor.getValue();
 625     }
 626
 627     private List<PdpUpdate> getUpdateRequests() {
 628         return session.getPdpUpdates();
 629     }
 630
 631     private List<PdpStateChange> getStateChangeRequests() {
 632         return session.getPdpStateChanges();
 633     }
 634
 635     private <T> List<T> sort(Collection<T> collection, Comparator<T> comparator) {
 636         List<T> lst = new ArrayList<>(collection);
 637         Collections.sort(lst, comparator);
 638
 639         return lst;
 640     }
 641
 642     private int compare(Pair<PdpUpdate, PdpStateChange> left, Pair<PdpUpdate, PdpStateChange> right) {
 643         return getName(left).compareTo(getName(right));
 644     }
 645
 646     private int compare(PdpUpdate left, PdpUpdate right) {
 647         return left.getName().compareTo(right.getName());
 648     }
 649
 650     private int compare(PdpStateChange left, PdpStateChange right) {
 651         return left.getName().compareTo(right.getName());
 652     }
 653
 654     private String getName(Pair<PdpUpdate, PdpStateChange> pair) {
 655         return (pair.getKey() != null ? pair.getKey().getName() : pair.getValue().getName());
 656     }
 657
 658     @FunctionalInterface
 659     private static interface TrackEx {
 660         public void accept(ToscaPolicyIdentifier policyId, Collection<String> pdps) throws PfModelException;
 661     }
 662 }