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

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