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

   1 /*\r
   2  * ============LICENSE_START=======================================================\r
   3  * ONAP PAP\r
   4  * ================================================================================\r
   5  * Copyright (C) 2019-2021 Nordix Foundation.\r
   6  * Modifications Copyright (C) 2021 AT&T Intellectual Property.\r
   7  * Modifications Copyright (C) 2021-2022 Bell Canada. All rights reserved.\r
   8  * ================================================================================\r
   9  * Licensed under the Apache License, Version 2.0 (the "License");\r
  10  * you may not use this file except in compliance with the License.\r
  11  * You may obtain a copy of the License at\r
  12  *\r
  13  * http://www.apache.org/licenses/LICENSE-2.0\r
  14  *\r
  15  * Unless required by applicable law or agreed to in writing, software\r
  16  * distributed under the License is distributed on an "AS IS" BASIS,\r
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  18  * See the License for the specific language governing permissions and\r
  19  * limitations under the License.\r
  20  * ============LICENSE_END=========================================================\r
  21  */\r
  22 \r
  23 package org.onap.policy.pap.main.rest;\r
  24 \r
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;\r
  26 import static org.junit.Assert.assertEquals;\r
  27 import static org.junit.Assert.assertNull;\r
  28 import static org.junit.Assert.assertSame;\r
  29 import static org.mockito.ArgumentMatchers.any;\r
  30 import static org.mockito.Mockito.never;\r
  31 import static org.mockito.Mockito.verify;\r
  32 import static org.mockito.Mockito.when;\r
  33 \r
  34 import java.util.ArrayList;\r
  35 import java.util.Arrays;\r
  36 import java.util.Collections;\r
  37 import java.util.List;\r
  38 import java.util.TreeMap;\r
  39 import javax.ws.rs.core.Response.Status;\r
  40 import org.assertj.core.api.Assertions;\r
  41 import org.junit.AfterClass;\r
  42 import org.junit.Before;\r
  43 import org.junit.Test;\r
  44 import org.onap.policy.common.utils.services.Registry;\r
  45 import org.onap.policy.models.base.PfModelException;\r
  46 import org.onap.policy.models.pdp.concepts.PdpGroup;\r
  47 import org.onap.policy.models.pdp.concepts.PdpGroups;\r
  48 import org.onap.policy.models.pdp.concepts.PdpStateChange;\r
  49 import org.onap.policy.models.pdp.concepts.PdpSubGroup;\r
  50 import org.onap.policy.models.pdp.concepts.PdpUpdate;\r
  51 import org.onap.policy.models.pdp.enums.PdpState;\r
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;\r
  53 import org.onap.policy.pap.main.PapConstants;\r
  54 \r
  55 public class TestPdpGroupCreateOrUpdateProvider extends ProviderSuper {\r
  56     private static final String EXPECTED_EXCEPTION = "expected exception";\r
  57 \r
  58     private static final String PDP2 = "pdpB";\r
  59     private static final String PDP4 = "pdpD";\r
  60 \r
  61     private PdpGroupCreateOrUpdateProvider prov;\r
  62 \r
  63 \r
  64
  65     @AfterClass\r
  66     public static void tearDownAfterClass() {\r
  67         Registry.newRegistry();\r
  68     }\r
  69 \r
  70     /**\r
  71      * Configures mocks and objects.\r
  72      *\r
  73      * @throws Exception if an error occurs\r
  74      */\r
  75     @Before\r
  76     @Override\r
  77     public void setUp() throws Exception {\r        super.setUp();\r
  78         prov = new PdpGroupCreateOrUpdateProvider();\r
  79         super.initialize(prov);\r
  80         when(toscaService.getPolicyTypeList("typeA", "100.2.3"))\r
  81             .thenReturn(Arrays.asList(loadPolicyType("daoPolicyType.json")));\r    }\r
  82 \r
  83     @Test\r
  84     public void testCreateOrUpdateGroups() throws Exception {\r
  85         prov.createOrUpdateGroups(loadPdpGroups("emptyGroups.json"));\r
  86 \r
  87         // no groups, so no action should have been taken\r
  88         assertNoGroupAction();\r
  89     }\r
  90 \r
  91     @Test\r
  92     public void testCreateOrUpdateGroups_InvalidRequest() throws Exception {\r
  93         assertThatThrownBy(() -> prov.createOrUpdateGroups(new PdpGroups())).isInstanceOf(PfModelException.class)\r
  94             .hasMessageContaining("is null");\r
  95 \r
  96         assertNoGroupAction();\r
  97     }\r
  98 \r
  99     @Test\r
 100     public void testCreateOrUpdate_Invalid() throws Exception {\r
 101         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 102         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);\r
 103 \r
 104         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 105             .hasMessageContaining("pdpGroupState");\r
 106 \r
 107         assertNoGroupAction();\r
 108     }\r
 109 \r
 110     @Test\r
 111     public void testAddGroup() throws Exception {\r
 112         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 113         PdpGroup group = groups.getGroups().get(0);\r
 114         group.setPdpGroupState(PdpState.PASSIVE);\r
 115 \r
 116         prov.createOrUpdateGroups(groups);\r
 117 \r
 118         // should not have updated the state\r
 119         assertEquals(PdpState.PASSIVE, group.getPdpGroupState());\r
 120 \r
 121         assertSame(group, getGroupCreates().get(0));\r
 122     }\r
 123 \r
 124     @Test\r
 125     public void testAddGroup_Invalid() throws Exception {\r
 126         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 127         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);\r
 128 \r
 129         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 130             .hasMessageContaining("pdpGroupState");\r
 131 \r
 132         assertNoGroupAction();\r
 133     }\r
 134 \r
 135     @Test\r
 136     public void testAddGroup_InvalidSubGroup() throws Exception {\r
 137         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 138 \r
 139         groups.getGroups().get(0).getPdpSubgroups().get(0).getSupportedPolicyTypes().get(0).setVersion("99.99.99");\r
 140 \r
 141         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 142             .hasMessageContaining("unknown policy type");\r
 143 \r
 144         assertNoGroupAction();\r
 145     }\r
 146 \r
 147     @Test\r
 148     public void testValidateGroupOnly_NullState() {\r
 149         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 150         groups.getGroups().get(0).setPdpGroupState(null);\r
 151         Assertions.assertThatCode(() -> prov.createOrUpdateGroups(groups)).doesNotThrowAnyException();\r
 152     }\r
 153 \r
 154     @Test\r
 155     public void testValidateGroupOnly_Active() {\r
 156         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 157         groups.getGroups().get(0).setPdpGroupState(PdpState.ACTIVE);\r
 158         Assertions.assertThatCode(() -> prov.createOrUpdateGroups(groups)).doesNotThrowAnyException();\r
 159     }\r
 160 \r
 161     @Test\r
 162     public void testValidateGroupOnly_Passive() {\r
 163         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 164         groups.getGroups().get(0).setPdpGroupState(PdpState.PASSIVE);\r
 165         Assertions.assertThatCode(() -> prov.createOrUpdateGroups(groups)).doesNotThrowAnyException();\r
 166     }\r
 167 \r
 168     @Test\r
 169     public void testValidateGroupOnly_Invalid() {\r
 170         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 171         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);\r
 172 \r
 173         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 174             .hasMessageContaining("pdpGroupState");\r
 175     }\r
 176 \r
 177     @Test\r
 178     public void testUpdateGroup() throws Exception {\r
 179         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 180 \r
 181         // DB group = new group\r
 182         PdpGroup group = new PdpGroup(groups.getGroups().get(0));\r
 183         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 184 \r
 185         prov.createOrUpdateGroups(groups);\r
 186 \r
 187         assertNoGroupAction();\r
 188     }\r
 189 \r
 190     @Test\r
 191     public void testUpdateGroup_PropertiesChanged() throws Exception {\r
 192         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 193 \r
 194         PdpGroup group = new PdpGroup(groups.getGroups().get(0));\r
 195         group.setProperties(new TreeMap<>());\r
 196 \r
 197         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 198 \r
 199         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 200             .hasMessageContaining("properties");\r
 201 \r
 202         assertNoGroupAction();\r
 203     }\r
 204 \r
 205     @Test\r
 206     public void testUpdateGroup_NewDescription() throws Exception {\r
 207         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 208         PdpGroup newgrp = groups.getGroups().get(0);\r
 209         PdpGroup group = new PdpGroup(newgrp);\r
 210         group.setDescription("old description");\r
 211         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 212 \r
 213         prov.createOrUpdateGroups(groups);\r
 214 \r
 215         assertGroupUpdateOnly(group);\r
 216 \r
 217         assertEquals("my description", group.getDescription());\r
 218         assertEquals(newgrp.toString(), group.toString());\r
 219     }\r
 220 \r
 221     @Test\r
 222     public void testUpdateGroup_NewState() throws Exception {\r
 223         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 224         PdpGroup newgrp = groups.getGroups().get(0);\r
 225         PdpGroup group = new PdpGroup(newgrp);\r
 226         group.setPdpGroupState(PdpState.TEST);\r
 227         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 228 \r
 229         prov.createOrUpdateGroups(groups);\r
 230 \r
 231         assertGroupUpdateOnly(group);\r
 232 \r
 233         assertEquals(PdpState.ACTIVE, group.getPdpGroupState());\r
 234         assertEquals(newgrp.toString(), group.toString());\r
 235     }\r
 236 \r
 237     @Test\r
 238     public void testUpdateGroup_NewSubGroup() throws Exception {\r
 239         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");\r
 240         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);\r
 241         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 242 \r
 243         prov.createOrUpdateGroups(groups);\r
 244 \r
 245         PdpGroup newgrp = groups.getGroups().get(0);\r
 246         assertEquals(newgrp.toString(), group.toString());\r
 247         assertGroupUpdateOnly(group);\r
 248     }\r
 249 \r
 250     @Test\r
 251     public void testUpdateGroup_UpdatedSubGroup() throws Exception {\r
 252         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 253         PdpGroup newgrp = groups.getGroups().get(0);\r
 254         PdpGroup group = new PdpGroup(newgrp);\r
 255         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 256 \r
 257         // something different in this subgroup\r
 258         group.getPdpSubgroups().get(0).setDesiredInstanceCount(10);\r
 259 \r
 260         prov.createOrUpdateGroups(groups);\r
 261 \r
 262         assertEquals(newgrp.toString(), group.toString());\r
 263         assertGroupUpdateOnly(group);\r
 264     }\r
 265 \r
 266     @Test\r
 267     public void testUpdateGroup_notifyPdpsDelSubGroups() throws Exception {\r
 268         PdpGroup dbgroup = new PdpGroup(loadPdpGroups("createGroupsDelSub.json").getGroups().get(0));\r
 269         when(pdpGroupService.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));\r
 270 \r
 271         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 272 \r
 273         prov.createOrUpdateGroups(groups);\r
 274 \r
 275         // verify that DB group was updated\r
 276         List<PdpGroup> updates = getGroupUpdates();\r
 277         assertEquals(1, updates.size());\r
 278         dbgroup = updates.get(0);\r
 279 \r
 280         PdpGroup newgrp = groups.getGroups().get(0);\r
 281 \r
 282         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());\r
 283         Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());\r
 284 \r
 285         assertEquals(newgrp.toString(), dbgroup.toString());\r
 286 \r
 287         // no deployment notifications\r
 288         checkEmptyNotification();\r
 289 \r
 290         // this requires a PDP UPDATE message\r
 291         List<PdpUpdate> pdpUpdates = getUpdateRequests(2);\r
 292         assertEquals(2, pdpUpdates.size());\r
 293 \r
 294         PdpUpdate pdpUpdate = pdpUpdates.get(0);\r
 295         assertEquals(PapConstants.PAP_NAME, pdpUpdate.getSource());\r
 296         assertEquals(PDP2, pdpUpdate.getName());\r
 297         assertNull(pdpUpdate.getPdpGroup());\r
 298 \r
 299         pdpUpdate = pdpUpdates.get(1);\r
 300         assertEquals(PapConstants.PAP_NAME, pdpUpdate.getSource());\r
 301         assertEquals(PDP4, pdpUpdate.getName());\r
 302         assertNull(pdpUpdate.getPdpGroup());\r
 303 \r
 304         // it also requires a PDP STATE-CHANGE message\r
 305         List<PdpStateChange> changes = getStateChangeRequests(2);\r
 306         assertEquals(2, changes.size());\r
 307 \r
 308         PdpStateChange change = changes.get(0);\r
 309         assertEquals(PapConstants.PAP_NAME, change.getSource());\r
 310         assertEquals(PDP2, change.getName());\r
 311         assertEquals(PdpState.PASSIVE, change.getState());\r
 312 \r
 313         change = changes.get(1);\r
 314         assertEquals(PapConstants.PAP_NAME, change.getSource());\r
 315         assertEquals(PDP4, change.getName());\r
 316         assertEquals(PdpState.PASSIVE, change.getState());\r
 317     }\r
 318 \r
 319     @Test\r
 320     public void testUpdateField_Unchanged() throws Exception {\r
 321         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 322         PdpGroup newgrp = groups.getGroups().get(0);\r
 323         PdpGroup group = new PdpGroup(newgrp);\r
 324         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 325 \r
 326         prov.createOrUpdateGroups(groups);\r
 327 \r
 328         assertNoGroupAction();\r
 329     }\r
 330 \r
 331     @Test\r
 332     public void testUpdateField_WasNull() throws Exception {\r
 333         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 334         PdpGroup newgrp = groups.getGroups().get(0);\r
 335         PdpGroup group = new PdpGroup(newgrp);\r
 336         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 337 \r
 338         group.setDescription(null);\r
 339 \r
 340         prov.createOrUpdateGroups(groups);\r
 341 \r
 342         assertEquals(newgrp.toString(), group.toString());\r
 343         assertGroupUpdateOnly(group);\r
 344     }\r
 345 \r
 346     @Test\r
 347     public void testUpdateField_NowNull() throws Exception {\r
 348         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 349         PdpGroup newgrp = groups.getGroups().get(0);\r
 350         PdpGroup group = new PdpGroup(newgrp);\r
 351         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 352 \r
 353         newgrp.setDescription(null);\r
 354 \r
 355         prov.createOrUpdateGroups(groups);\r
 356 \r
 357         assertEquals(newgrp.toString(), group.toString());\r
 358         assertGroupUpdateOnly(group);\r
 359     }\r
 360 \r
 361     @Test\r
 362     public void testUpdateField_Changed() throws Exception {\r
 363         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 364         PdpGroup newgrp = groups.getGroups().get(0);\r
 365         PdpGroup group = new PdpGroup(newgrp);\r
 366         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 367 \r
 368         newgrp.setDescription(group.getDescription() + "-changed");\r
 369 \r
 370         prov.createOrUpdateGroups(groups);\r
 371 \r
 372         assertEquals(newgrp.toString(), group.toString());\r
 373         assertGroupUpdateOnly(group);\r
 374     }\r
 375 \r
 376     @Test\r
 377     public void testAddSubGroup() throws Exception {\r
 378         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");\r
 379         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);\r
 380         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 381 \r
 382         prov.createOrUpdateGroups(groups);\r
 383 \r
 384         PdpGroup newgrp = groups.getGroups().get(0);\r
 385 \r
 386         PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);\r
 387         newsub.setCurrentInstanceCount(0);\r
 388         newsub.setPdpInstances(new ArrayList<>(0));\r
 389 \r
 390         assertEquals(newgrp.toString(), group.toString());\r
 391         assertGroupUpdateOnly(group);\r
 392     }\r
 393 \r
 394     /**\r
 395      * Tests addSubgroup() when the new subgroup has a wild-card policy type.\r
 396      *\r
 397      * @throws Exception if an error occurs\r
 398      */\r
 399     @Test\r
 400     public void testAddSubGroupWildCardPolicyType() throws Exception {\r
 401         when(toscaService.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyListWildCard.json"));\r
 402         when(toscaService.getPolicyTypeList("some.*", "2.3.4")).thenReturn(Collections.emptyList());\r
 403 \r
 404         PdpGroups groups = loadPdpGroups("createGroupsWildCard.json");\r
 405         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);\r
 406         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 407 \r
 408         prov.createOrUpdateGroups(groups);\r
 409 \r
 410         PdpGroup newgrp = groups.getGroups().get(0);\r
 411 \r
 412         PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);\r
 413         newsub.setCurrentInstanceCount(0);\r
 414         newsub.setPdpInstances(new ArrayList<>(0));\r
 415 \r
 416         assertEquals(newgrp.toString(), group.toString());\r
 417     }\r
 418 \r
 419     @Test\r
 420     public void testAddSubGroup_ValidationPolicyTypeNotFound() throws Exception {\r
 421         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");\r
 422         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);\r
 423         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 424 \r
 425         when(toscaService.getPolicyTypeList(any(), any())).thenReturn(Collections.emptyList());\r
 426 \r
 427         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).hasMessageContaining("unknown policy type");\r
 428     }\r
 429 \r
 430     @Test\r
 431     public void testAddSubGroup_ValidationPolicyTypeDaoEx() throws Exception {\r
 432         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");\r
 433         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);\r
 434         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 435 \r
 436         PfModelException exc = new PfModelException(Status.CONFLICT, EXPECTED_EXCEPTION);\r
 437         when(toscaService.getPolicyTypeList(any(), any())).thenThrow(exc);\r
 438 \r
 439         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isSameAs(exc);\r
 440     }\r
 441 \r
 442     @Test\r
 443     public void testAddSubGroup_ValidateVersionPrefixMatch() throws Exception {\r
 444         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 445         PdpGroup newgrp = groups.getGroups().get(0);\r
 446         PdpGroup dbgroup = new PdpGroup(newgrp);\r
 447         when(pdpGroupService.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));\r
 448 \r
 449         when(toscaService.getFilteredPolicyList(any())).thenReturn(loadPolicies("createGroupNewPolicy.json"))\r
 450             .thenReturn(loadPolicies("daoPolicyList.json")).thenReturn(loadPolicies("createGroupNewPolicy.json"));\r
 451 \r
 452         PdpGroups reqgroups = loadPdpGroups("createGroupsVersPrefix.json");\r
 453 \r
 454         prov.createOrUpdateGroups(reqgroups);\r
 455 \r
 456         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());\r
 457         Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());\r
 458 \r
 459         assertEquals(newgrp.toString(), dbgroup.toString());\r
 460     }\r
 461 \r
 462     @Test\r
 463     public void testUpdateSubGroup_Invalid() throws Exception {\r
 464         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 465         PdpGroup newgrp = groups.getGroups().get(0);\r
 466         PdpGroup group = new PdpGroup(newgrp);\r
 467         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 468 \r
 469         // change properties\r
 470         newgrp.getPdpSubgroups().get(0).setProperties(new TreeMap<>());\r
 471 \r
 472         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 473             .hasMessageContaining("properties");\r
 474 \r
 475         assertNoGroupAction();\r
 476     }\r
 477 \r
 478     @Test\r
 479     public void testUpdateSubGroup_SupportedPolicies() throws Exception {\r
 480         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 481         PdpGroup newgrp = groups.getGroups().get(0);\r
 482         PdpGroup group = new PdpGroup(newgrp);\r
 483         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 484 \r
 485         newgrp.getPdpSubgroups().get(0).getSupportedPolicyTypes()\r
 486             .add(new ToscaConceptIdentifier("typeX.*", "9.8.7"));\r
 487 \r
 488         // the group is updated with a new supported policy type in subgroup\r
 489         assertEquals(2, newgrp.getPdpSubgroups().get(0).getSupportedPolicyTypes().size());\r
 490         prov.createOrUpdateGroups(groups);\r
 491         // PdpGroup update doesn't allow supported policy type modifications\r
 492         // during pdp group update, the ones in db is maintained\r
 493         assertEquals(1, newgrp.getPdpSubgroups().get(0).getSupportedPolicyTypes().size());\r
 494         assertEquals(newgrp.toString(), group.toString());\r
 495     }\r
 496 \r
 497     @Test\r
 498     public void testUpdateSubGroup_DesiredCount() throws Exception {\r
 499         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 500         PdpGroup newgrp = groups.getGroups().get(0);\r
 501         PdpGroup group = new PdpGroup(newgrp);\r
 502         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 503 \r
 504         newgrp.getPdpSubgroups().get(0).setDesiredInstanceCount(20);\r
 505 \r
 506         prov.createOrUpdateGroups(groups);\r
 507 \r
 508         assertEquals(newgrp.toString(), group.toString());\r
 509         assertGroupUpdateOnly(group);\r
 510     }\r
 511 \r
 512     @Test\r
 513     public void testUpdateSubGroup_Unchanged() throws Exception {\r
 514         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 515         PdpGroup newgrp = groups.getGroups().get(0);\r
 516         PdpGroup group = new PdpGroup(newgrp);\r
 517         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 518 \r
 519         prov.createOrUpdateGroups(groups);\r
 520 \r
 521         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());\r
 522         Collections.sort(group.getPdpSubgroups().get(0).getPolicies());\r
 523 \r
 524         assertEquals(newgrp.toString(), group.toString());\r
 525 \r
 526         // no notifications\r
 527         checkEmptyNotification();\r
 528 \r
 529         // no group updates\r
 530         assertNoGroupAction();\r
 531     }\r
 532 \r
 533     @Test\r
 534     public void testValidateSubGroup_PropertiesMismatch() throws Exception {\r
 535         PdpGroups groups = loadPdpGroups("createGroups.json");\r
 536         PdpGroup newgrp = groups.getGroups().get(0);\r
 537         PdpGroup group = new PdpGroup(newgrp);\r
 538         when(pdpGroupService.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));\r
 539 \r
 540         newgrp.setProperties(new TreeMap<>());\r
 541 \r
 542         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)\r
 543             .hasMessageContaining("properties");\r
 544 \r
 545         assertNoGroupAction();\r
 546     }\r
 547 \r
 548     private void assertNoGroupAction() throws Exception {\r
 549         verify(pdpGroupService, never()).createPdpGroups(any());\r
 550         verify(pdpGroupService, never()).updatePdpGroups(any());\r
 551         verify(reqmap, never()).addRequest(any(), any());\r
 552     }\r
 553 \r
 554     private void assertGroupUpdateOnly(PdpGroup group) throws Exception {\r
 555         verify(pdpGroupService, never()).createPdpGroups(any());\r
 556         verify(reqmap, never()).addRequest(any(), any());\r
 557 \r
 558         List<PdpGroup> updates = getGroupUpdates();\r
 559         assertEquals(Arrays.asList(group), updates);\r
 560     }\r
 561 }\r