main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestPdpGroupDeployProvider.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.assertThatThrownBy;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertSame;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.mockito.Matchers.any;
  29 import static org.mockito.Mockito.never;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.Collections;
  36 import java.util.List;
  37 import java.util.TreeMap;
  38 import java.util.stream.Collectors;
  39 import javax.ws.rs.core.Response.Status;
  40 import org.junit.AfterClass;
  41 import org.junit.Before;
  42 import org.junit.Test;
  43 import org.onap.policy.common.utils.services.Registry;
  44 import org.onap.policy.models.base.PfModelException;
  45 import org.onap.policy.models.base.PfModelRuntimeException;
  46 import org.onap.policy.models.pap.concepts.PdpDeployPolicies;
  47 import org.onap.policy.models.pdp.concepts.PdpGroup;
  48 import org.onap.policy.models.pdp.concepts.PdpGroups;
  49 import org.onap.policy.models.pdp.concepts.PdpStateChange;
  50 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  51 import org.onap.policy.models.pdp.concepts.PdpUpdate;
  52 import org.onap.policy.models.pdp.enums.PdpState;
  53 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
  55 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
  56
  57 public class TestPdpGroupDeployProvider extends ProviderSuper {
  58     private static final String EXPECTED_EXCEPTION = "expected exception";
  59
  60     private static final String POLICY2_NAME = "policyB";
  61     private static final String POLICY1_VERSION = "1.2.3";
  62     private static final String GROUP1_NAME = "groupA";
  63     private static final String PDP1_TYPE = "pdpTypeA";
  64     private static final String PDP2_TYPE = "pdpTypeB";
  65     private static final String PDP4_TYPE = "pdpTypeD";
  66     private static final String PDP2 = "pdpB";
  67     private static final String PDP4 = "pdpD";
  68
  69     private PdpGroupDeployProvider prov;
  70
  71
  72     @AfterClass
  73     public static void tearDownAfterClass() {
  74         Registry.newRegistry();
  75     }
  76
  77     /**
  78      * Configures mocks and objects.
  79      *
  80      * @throws Exception if an error occurs
  81      */
  82     @Before
  83     public void setUp() throws Exception {
  84
  85         super.setUp();
  86
  87         when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyList.json"));
  88         when(dao.getPolicyTypeList("typeA", "100.2.3")).thenReturn(Arrays.asList(loadPolicyType("daoPolicyType.json")));
  89
  90         prov = new PdpGroupDeployProvider();
  91     }
  92
  93     @Test
  94     public void testCreateOrUpdateGroups() throws Exception {
  95         prov.createOrUpdateGroups(loadPdpGroups("emptyGroups.json"));
  96
  97         // no groups, so no action should have been taken
  98         assertNoGroupAction();
  99     }
 100
 101     @Test
 102     public void testCreateOrUpdateGroups_InvalidRequest() throws Exception {
 103         assertThatThrownBy(() -> prov.createOrUpdateGroups(new PdpGroups())).isInstanceOf(PfModelException.class)
 104                         .hasMessageContaining("is null");
 105
 106         assertNoGroupAction();
 107     }
 108
 109     @Test
 110     public void testCreateOrUpdate_Invalid() throws Exception {
 111         PdpGroups groups = loadPdpGroups("createGroups.json");
 112         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
 113
 114         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 115                         .hasMessageContaining("pdpGroupState");
 116
 117         assertNoGroupAction();
 118     }
 119
 120     @Test
 121     public void testAddGroup() throws Exception {
 122         PdpGroups groups = loadPdpGroups("createGroups.json");
 123         PdpGroup group = groups.getGroups().get(0);
 124         group.setPdpGroupState(PdpState.PASSIVE);
 125
 126         prov.createOrUpdateGroups(groups);
 127
 128         // should not have updated the state
 129         assertEquals(PdpState.PASSIVE, group.getPdpGroupState());
 130
 131         assertSame(group, getGroupCreates().get(0));
 132     }
 133
 134     @Test
 135     public void testAddGroup_Invalid() throws Exception {
 136         PdpGroups groups = loadPdpGroups("createGroups.json");
 137         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
 138
 139         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 140                         .hasMessageContaining("pdpGroupState");
 141
 142         assertNoGroupAction();
 143     }
 144
 145     @Test
 146     public void testAddGroup_InvalidSubGroup() throws Exception {
 147         PdpGroups groups = loadPdpGroups("createGroups.json");
 148
 149         // policy won't match supported type
 150         groups.getGroups().get(0).getPdpSubgroups().get(0).getSupportedPolicyTypes().get(0).setVersion("99.99.99");
 151
 152         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 153                         .hasMessageContaining("supported policy");
 154
 155         assertNoGroupAction();
 156     }
 157
 158     @Test
 159     public void testValidateGroupOnly_NullState() throws PfModelException {
 160         PdpGroups groups = loadPdpGroups("createGroups.json");
 161         groups.getGroups().get(0).setPdpGroupState(null);
 162         prov.createOrUpdateGroups(groups);
 163     }
 164
 165     @Test
 166     public void testValidateGroupOnly_Active() throws PfModelException {
 167         PdpGroups groups = loadPdpGroups("createGroups.json");
 168         groups.getGroups().get(0).setPdpGroupState(PdpState.ACTIVE);
 169         prov.createOrUpdateGroups(groups);
 170     }
 171
 172     @Test
 173     public void testValidateGroupOnly_Passive() throws PfModelException {
 174         PdpGroups groups = loadPdpGroups("createGroups.json");
 175         groups.getGroups().get(0).setPdpGroupState(PdpState.PASSIVE);
 176         prov.createOrUpdateGroups(groups);
 177     }
 178
 179     @Test
 180     public void testValidateGroupOnly_Invalid() {
 181         PdpGroups groups = loadPdpGroups("createGroups.json");
 182         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
 183
 184         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 185                         .hasMessageContaining("pdpGroupState");
 186     }
 187
 188     @Test
 189     public void testUpdateGroup() throws Exception {
 190         PdpGroups groups = loadPdpGroups("createGroups.json");
 191
 192         // DB group = new group
 193         PdpGroup group = new PdpGroup(groups.getGroups().get(0));
 194         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 195
 196         prov.createOrUpdateGroups(groups);
 197
 198         assertNoGroupAction();
 199     }
 200
 201     @Test
 202     public void testUpdateGroup_PropertiesChanged() throws Exception {
 203         PdpGroups groups = loadPdpGroups("createGroups.json");
 204
 205         PdpGroup group = new PdpGroup(groups.getGroups().get(0));
 206         group.setProperties(new TreeMap<>());
 207
 208         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 209
 210         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 211                         .hasMessageContaining("properties");
 212
 213         assertNoGroupAction();
 214     }
 215
 216     @Test
 217     public void testUpdateGroup_NewDescription() throws Exception {
 218         PdpGroups groups = loadPdpGroups("createGroups.json");
 219         PdpGroup newgrp = groups.getGroups().get(0);
 220         PdpGroup group = new PdpGroup(newgrp);
 221         group.setDescription("old description");
 222         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 223
 224         prov.createOrUpdateGroups(groups);
 225
 226         assertGroupUpdateOnly(group);
 227
 228         assertEquals(group.getDescription(), "my description");
 229         assertEquals(newgrp.toString(), group.toString());
 230     }
 231
 232     @Test
 233     public void testUpdateGroup_NewSubGroup() throws Exception {
 234         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 235         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 236         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 237
 238         prov.createOrUpdateGroups(groups);
 239
 240         PdpGroup newgrp = groups.getGroups().get(0);
 241         assertEquals(newgrp.toString(), group.toString());
 242         assertGroupUpdateOnly(group);
 243     }
 244
 245     @Test
 246     public void testUpdateGroup_UpdatedSubGroup() throws Exception {
 247         PdpGroups groups = loadPdpGroups("createGroups.json");
 248         PdpGroup newgrp = groups.getGroups().get(0);
 249         PdpGroup group = new PdpGroup(newgrp);
 250         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 251
 252         // something different in this subgroup
 253         group.getPdpSubgroups().get(0).setDesiredInstanceCount(10);
 254
 255         prov.createOrUpdateGroups(groups);
 256
 257         assertEquals(newgrp.toString(), group.toString());
 258         assertGroupUpdateOnly(group);
 259     }
 260
 261     @Test
 262     public void testUpdateGroup_notifyPdpsDelSubGroups() throws Exception {
 263         PdpGroup dbgroup = new PdpGroup(loadPdpGroups("createGroupsDelSub.json").getGroups().get(0));
 264         when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
 265
 266         PdpGroups groups = loadPdpGroups("createGroups.json");
 267
 268         prov.createOrUpdateGroups(groups);
 269
 270         // verify that DB group was updated
 271         List<PdpGroup> updates = getGroupUpdates();
 272         assertEquals(1, updates.size());
 273         dbgroup = updates.get(0);
 274
 275         PdpGroup newgrp = groups.getGroups().get(0);
 276
 277         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
 278         Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
 279
 280         assertEquals(newgrp.toString(), dbgroup.toString());
 281
 282         // this requires a PDP UPDATE message
 283         List<PdpUpdate> pdpUpdates = getUpdateRequests(2);
 284         assertEquals(2, pdpUpdates.size());
 285
 286         PdpUpdate pdpUpdate = pdpUpdates.get(0);
 287         assertEquals(PDP2, pdpUpdate.getName());
 288         assertNull(pdpUpdate.getPdpGroup());
 289
 290         pdpUpdate = pdpUpdates.get(1);
 291         assertEquals(PDP4, pdpUpdate.getName());
 292         assertNull(pdpUpdate.getPdpGroup());
 293
 294         // it also requires a PDP STATE-CHANGE message
 295         List<PdpStateChange> changes = getStateChangeRequests(2);
 296         assertEquals(2, changes.size());
 297
 298         PdpStateChange change = changes.get(0);
 299         assertEquals(PDP2, change.getName());
 300         assertEquals(PdpState.PASSIVE, change.getState());
 301
 302         change = changes.get(1);
 303         assertEquals(PDP4, change.getName());
 304         assertEquals(PdpState.PASSIVE, change.getState());
 305     }
 306
 307     @Test
 308     public void testUpdateGroup_MultipleChanges() throws Exception {
 309         PdpGroups groups = loadPdpGroups("createGroups.json");
 310         PdpGroup newgrp = groups.getGroups().get(0);
 311         PdpGroup group = new PdpGroup(newgrp);
 312         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 313
 314         PdpSubGroup subgrp = newgrp.getPdpSubgroups().get(0);
 315         subgrp.setDesiredInstanceCount(30);
 316         subgrp.getPolicies().add(new ToscaPolicyIdentifier(POLICY2_NAME, POLICY1_VERSION));
 317         subgrp.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier("typeX", "9.8.7"));
 318
 319         when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyList.json"))
 320                         .thenReturn(loadPolicies("createGroupNewPolicy.json"));
 321
 322         prov.createOrUpdateGroups(groups);
 323
 324         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
 325         Collections.sort(group.getPdpSubgroups().get(0).getPolicies());
 326
 327         assertEquals(newgrp.toString(), group.toString());
 328
 329         // this requires a PDP UPDATE message
 330         assertGroupUpdate(group, subgrp);
 331     }
 332
 333     @Test
 334     public void testUpdateField_Unchanged() throws Exception {
 335         PdpGroups groups = loadPdpGroups("createGroups.json");
 336         PdpGroup newgrp = groups.getGroups().get(0);
 337         PdpGroup group = new PdpGroup(newgrp);
 338         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 339
 340         prov.createOrUpdateGroups(groups);
 341
 342         assertNoGroupAction();
 343     }
 344
 345     @Test
 346     public void testUpdateField_WasNull() throws Exception {
 347         PdpGroups groups = loadPdpGroups("createGroups.json");
 348         PdpGroup newgrp = groups.getGroups().get(0);
 349         PdpGroup group = new PdpGroup(newgrp);
 350         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 351
 352         group.setDescription(null);
 353
 354         prov.createOrUpdateGroups(groups);
 355
 356         assertEquals(newgrp.toString(), group.toString());
 357         assertGroupUpdateOnly(group);
 358     }
 359
 360     @Test
 361     public void testUpdateField_NowNull() throws Exception {
 362         PdpGroups groups = loadPdpGroups("createGroups.json");
 363         PdpGroup newgrp = groups.getGroups().get(0);
 364         PdpGroup group = new PdpGroup(newgrp);
 365         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 366
 367         newgrp.setDescription(null);
 368
 369         prov.createOrUpdateGroups(groups);
 370
 371         assertEquals(newgrp.toString(), group.toString());
 372         assertGroupUpdateOnly(group);
 373     }
 374
 375     @Test
 376     public void testUpdateField_Changed() throws Exception {
 377         PdpGroups groups = loadPdpGroups("createGroups.json");
 378         PdpGroup newgrp = groups.getGroups().get(0);
 379         PdpGroup group = new PdpGroup(newgrp);
 380         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 381
 382         newgrp.setDescription(group.getDescription() + "-changed");
 383
 384         prov.createOrUpdateGroups(groups);
 385
 386         assertEquals(newgrp.toString(), group.toString());
 387         assertGroupUpdateOnly(group);
 388     }
 389
 390     @Test
 391     public void testAddSubGroup() throws Exception {
 392         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 393         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 394         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 395
 396         prov.createOrUpdateGroups(groups);
 397
 398         PdpGroup newgrp = groups.getGroups().get(0);
 399
 400         PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);
 401         newsub.setCurrentInstanceCount(0);
 402         newsub.setPdpInstances(new ArrayList<>(0));
 403
 404         assertEquals(newgrp.toString(), group.toString());
 405         assertGroupUpdateOnly(group);
 406     }
 407
 408     @Test
 409     public void testAddSubGroup_ValidationPolicyTypeNotFound() throws Exception {
 410         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 411         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 412         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 413
 414         when(dao.getPolicyTypeList(any(), any())).thenReturn(Collections.emptyList());
 415
 416         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).hasMessageContaining("unknown policy type");
 417     }
 418
 419     @Test
 420     public void testAddSubGroup_ValidationPolicyTypeDaoEx() throws Exception {
 421         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 422         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 423         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 424
 425         PfModelException exc = new PfModelException(Status.CONFLICT, EXPECTED_EXCEPTION);
 426         when(dao.getPolicyTypeList(any(), any())).thenThrow(exc);
 427
 428         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isSameAs(exc);
 429     }
 430
 431     @Test
 432     public void testAddSubGroup_ValidationPolicyNotFound() throws Exception {
 433         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 434         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 435         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 436
 437         when(dao.getFilteredPolicyList(any())).thenReturn(Collections.emptyList());
 438
 439         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).hasMessageContaining("unknown policy");
 440     }
 441
 442     @Test
 443     public void testAddSubGroup_ValidationPolicyDaoEx() throws Exception {
 444         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 445         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 446         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 447
 448         PfModelException exc = new PfModelException(Status.CONFLICT, EXPECTED_EXCEPTION);
 449         when(dao.getFilteredPolicyList(any())).thenThrow(exc);
 450
 451         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isSameAs(exc);
 452     }
 453
 454     @Test
 455     public void testUpdateSubGroup_Invalid() throws Exception {
 456         PdpGroups groups = loadPdpGroups("createGroups.json");
 457         PdpGroup newgrp = groups.getGroups().get(0);
 458         PdpGroup group = new PdpGroup(newgrp);
 459         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 460
 461         // change properties
 462         newgrp.getPdpSubgroups().get(0).setProperties(new TreeMap<>());
 463
 464         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 465                         .hasMessageContaining("properties");
 466
 467         assertNoGroupAction();
 468     }
 469
 470     @Test
 471     public void testUpdateSubGroup_SupportedPolicies() throws Exception {
 472         PdpGroups groups = loadPdpGroups("createGroups.json");
 473         PdpGroup newgrp = groups.getGroups().get(0);
 474         PdpGroup group = new PdpGroup(newgrp);
 475         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 476
 477         newgrp.getPdpSubgroups().get(0).getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier("typeX", "9.8.7"));
 478
 479         prov.createOrUpdateGroups(groups);
 480
 481         assertEquals(newgrp.toString(), group.toString());
 482         assertGroupUpdateOnly(group);
 483     }
 484
 485     @Test
 486     public void testUpdateSubGroup_DesiredCount() throws Exception {
 487         PdpGroups groups = loadPdpGroups("createGroups.json");
 488         PdpGroup newgrp = groups.getGroups().get(0);
 489         PdpGroup group = new PdpGroup(newgrp);
 490         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 491
 492         newgrp.getPdpSubgroups().get(0).setDesiredInstanceCount(20);
 493
 494         prov.createOrUpdateGroups(groups);
 495
 496         assertEquals(newgrp.toString(), group.toString());
 497         assertGroupUpdateOnly(group);
 498     }
 499
 500     @Test
 501     public void testUpdateSubGroup_Policies() throws Exception {
 502         PdpGroups groups = loadPdpGroups("createGroups.json");
 503         PdpGroup newgrp = groups.getGroups().get(0);
 504         PdpGroup group = new PdpGroup(newgrp);
 505         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 506
 507         PdpSubGroup subgrp = newgrp.getPdpSubgroups().get(0);
 508         subgrp.getPolicies().add(new ToscaPolicyIdentifier(POLICY2_NAME, POLICY1_VERSION));
 509
 510         when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyList.json"))
 511                         .thenReturn(loadPolicies("createGroupNewPolicy.json"));
 512
 513         prov.createOrUpdateGroups(groups);
 514
 515         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
 516         Collections.sort(group.getPdpSubgroups().get(0).getPolicies());
 517
 518         assertEquals(newgrp.toString(), group.toString());
 519
 520         // this requires a PDP UPDATE message
 521         assertGroupUpdate(group, subgrp);
 522     }
 523
 524     @Test
 525     public void testUpdateSubGroup_PolicyVersionMismatch() throws Exception {
 526         PdpGroups groups = loadPdpGroups("createGroups.json");
 527         PdpGroup newgrp = groups.getGroups().get(0);
 528         PdpGroup dbgroup = new PdpGroup(newgrp);
 529         when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
 530
 531         // arrange for DB policy version to be different
 532         PdpSubGroup dbsubgrp = dbgroup.getPdpSubgroups().get(0);
 533         dbsubgrp.getPolicies().get(0).setVersion("9.9.9");
 534
 535         when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyList.json"));
 536
 537         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 538                         .hasMessageContaining("different version already deployed");
 539
 540         assertNoGroupAction();
 541     }
 542
 543     @Test
 544     public void testValidateSubGroup_PropertiesMismatch() throws Exception {
 545         PdpGroups groups = loadPdpGroups("createGroups.json");
 546         PdpGroup newgrp = groups.getGroups().get(0);
 547         PdpGroup group = new PdpGroup(newgrp);
 548         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 549
 550         newgrp.setProperties(new TreeMap<>());
 551
 552         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 553                         .hasMessageContaining("properties");
 554
 555         assertNoGroupAction();
 556     }
 557
 558     @Test
 559     public void testDeployPolicies() throws PfModelException {
 560         prov.deployPolicies(loadEmptyRequest());
 561     }
 562
 563     @Test
 564     public void testDeploySimplePolicies() throws Exception {
 565         prov.deployPolicies(loadEmptyRequest());
 566     }
 567
 568     @Test
 569     public void testDeploySimplePolicies_DaoEx() throws Exception {
 570         PfModelException exc = new PfModelException(Status.BAD_REQUEST, EXPECTED_EXCEPTION);
 571         when(dao.getFilteredPdpGroups(any())).thenThrow(exc);
 572
 573         assertThatThrownBy(() -> prov.deployPolicies(loadRequest())).isSameAs(exc);
 574     }
 575
 576     @Test
 577     public void testDeploySimplePolicies_DaoPfRtEx() throws Exception {
 578         PfModelRuntimeException exc = new PfModelRuntimeException(Status.BAD_REQUEST, EXPECTED_EXCEPTION);
 579         when(dao.getFilteredPdpGroups(any())).thenThrow(exc);
 580
 581         assertThatThrownBy(() -> prov.deployPolicies(loadRequest())).isSameAs(exc);
 582     }
 583
 584     @Test
 585     public void testDeploySimplePolicies_RuntimeEx() throws Exception {
 586         RuntimeException exc = new RuntimeException(EXPECTED_EXCEPTION);
 587         when(dao.getFilteredPolicyList(any())).thenThrow(exc);
 588
 589         assertThatThrownBy(() -> prov.deployPolicies(loadRequest())).isInstanceOf(PfModelException.class).hasCause(exc);
 590     }
 591
 592     @Test
 593     public void testDeploySimplePolicies_NoGroups() throws Exception {
 594         when(dao.getFilteredPdpGroups(any())).thenReturn(loadGroups("emptyGroups.json"));
 595
 596         assertThatThrownBy(() -> prov.deployPolicies(loadRequest())).isInstanceOf(PfModelException.class)
 597                         .hasMessage("policy not supported by any PDP group: policyA 1.2.3");
 598     }
 599
 600     @Test
 601     public void testMakeUpdater() throws Exception {
 602         /*
 603          * Each subgroup has a different PDP type and name.
 604          *
 605          * Type is not supported by the first subgroup.
 606          *
 607          * Second subgroup matches.
 608          *
 609          * Third subgroup already contains the policy.
 610          *
 611          * Last subgroup matches.
 612          */
 613
 614         when(dao.getFilteredPdpGroups(any())).thenReturn(loadGroups("upgradeGroupDao.json"));
 615
 616         prov.deployPolicies(loadRequest());
 617
 618         assertGroup(getGroupUpdates(), GROUP1_NAME);
 619
 620         List<PdpUpdate> requests = getUpdateRequests(2);
 621         assertUpdate(requests, GROUP1_NAME, PDP2_TYPE, PDP2);
 622         assertUpdate(requests, GROUP1_NAME, PDP4_TYPE, PDP4);
 623     }
 624
 625     @Test
 626     public void testMakeUpdater_PolicyVersionMismatch() throws Exception {
 627
 628         // subgroup has a different version of the Policy
 629         when(dao.getFilteredPdpGroups(any())).thenReturn(loadGroups("upgradeGroupDao_DiffVers.json"));
 630
 631         assertThatThrownBy(() -> prov.deployPolicies(loadRequest())).isInstanceOf(PfModelRuntimeException.class)
 632                         .hasMessageContaining("pdpTypeC").hasMessageContaining("different version already deployed");
 633
 634         verify(dao, never()).createPdpGroups(any());
 635         verify(dao, never()).updatePdpGroups(any());
 636         verify(reqmap, never()).addRequest(any(PdpUpdate.class));
 637     }
 638
 639     @Test
 640     public void testMakeUpdater_NoPdps() throws Exception {
 641
 642         // subgroup has no PDPs
 643         when(dao.getFilteredPdpGroups(any())).thenReturn(loadGroups("upgradeGroup_NoPdpsDao.json"));
 644
 645         assertThatThrownBy(() -> prov.deployPolicies(loadRequest())).isInstanceOf(PfModelRuntimeException.class)
 646                         .hasMessage("group " + GROUP1_NAME + " subgroup " + PDP1_TYPE + " has no active PDPs");
 647
 648         verify(dao, never()).createPdpGroups(any());
 649         verify(dao, never()).updatePdpGroups(any());
 650         verify(reqmap, never()).addRequest(any(PdpUpdate.class));
 651     }
 652
 653
 654     protected void assertUpdate(List<PdpUpdate> updates, String groupName, String pdpType, String pdpName) {
 655
 656         PdpUpdate update = updates.remove(0);
 657
 658         assertEquals(groupName, update.getPdpGroup());
 659         assertEquals(pdpType, update.getPdpSubgroup());
 660         assertEquals(pdpName, update.getName());
 661         assertTrue(update.getPolicies().contains(policy1));
 662     }
 663
 664     private void assertNoGroupAction() throws Exception {
 665         verify(dao, never()).createPdpGroups(any());
 666         verify(dao, never()).updatePdpGroups(any());
 667         verify(reqmap, never()).addRequest(any(), any());
 668     }
 669
 670     private void assertGroupUpdate(PdpGroup group, PdpSubGroup subgrp) throws Exception {
 671         verify(dao, never()).createPdpGroups(any());
 672
 673         assertEquals(0, getStateChangeRequests(1).size());
 674
 675         List<PdpUpdate> pdpUpdates = getUpdateRequests(1);
 676         assertEquals(1, pdpUpdates.size());
 677
 678         PdpUpdate pdpUpdate = pdpUpdates.get(0);
 679         assertEquals("pdpA", pdpUpdate.getName());
 680         assertEquals(group.getName(), pdpUpdate.getPdpGroup());
 681
 682         assertEquals(subgrp.getPdpType(), pdpUpdate.getPdpSubgroup());
 683
 684         List<ToscaPolicyIdentifier> pdpPolicies =
 685                         pdpUpdate.getPolicies().stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList());
 686         Collections.sort(pdpPolicies);
 687
 688         assertEquals(subgrp.getPolicies().toString(), pdpPolicies.toString());
 689
 690         List<PdpGroup> updates = getGroupUpdates();
 691         assertEquals(Arrays.asList(group), updates);
 692     }
 693
 694     private void assertGroupUpdateOnly(PdpGroup group) throws Exception {
 695         verify(dao, never()).createPdpGroups(any());
 696         verify(reqmap, never()).addRequest(any(), any());
 697
 698         List<PdpGroup> updates = getGroupUpdates();
 699         assertEquals(Arrays.asList(group), updates);
 700     }
 701
 702     /**
 703      * Loads a standard request.
 704      *
 705      * @return a standard request
 706      */
 707     protected PdpDeployPolicies loadRequest() {
 708         return loadRequest("request.json");
 709     }
 710
 711     /**
 712      * Loads a request from a JSON file.
 713      *
 714      * @param fileName name of the file from which to load
 715      * @return the request that was loaded
 716      */
 717     protected PdpDeployPolicies loadRequest(String fileName) {
 718         return loadFile(fileName, PdpDeployPolicies.class);
 719     }
 720
 721     /**
 722      * Loads an empty request.
 723      *
 724      * @return an empty request
 725      */
 726     protected PdpDeployPolicies loadEmptyRequest() {
 727         return loadRequest("emptyRequest.json");
 728     }
 729 }