Create PAP API to only create/update PdpGroups

Create an API to create/update PdpGroups.
Policies are not allowed to be deployed as part of PDPGroup
create/update operation. There will be a separate API as part of
POLICY-2274 to deploy policies into individual group/subgroups.

Change-Id: I4e2cb43fefe08b22d6f70a1db7c026e83f0ebde0
Issue-ID: POLICY-2273
Signed-off-by: a.sreekumar <ajith.sreekumar@est.tech>

8 files changed, 876 insertions, 182 deletions

diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateControllerV1.java b/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateControllerV1.java
new file mode 100644
index 00000000..31246416
--- /dev/null
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateControllerV1.java
@@ -0,0 +1,80 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.main.rest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.Arrays;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import org.junit.Test;
+import org.onap.policy.models.pap.concepts.PdpGroupUpdateResponse;
+import org.onap.policy.models.pdp.concepts.PdpGroup;
+import org.onap.policy.models.pdp.concepts.PdpGroups;
+import org.onap.policy.models.pdp.concepts.PdpSubGroup;
+
+/**
+ * Note: this tests failure cases; success cases are tested by tests in the "e2e" package.
+ */
+public class TestPdpGroupCreateOrUpdateControllerV1 extends CommonPapRestServer {
+
+    private static final String CREATEORUPDATE_GROUPS_ENDPOINT = "pdps/groups/batch";
+
+    @Test
+    public void testSwagger() throws Exception {
+        super.testSwagger(CREATEORUPDATE_GROUPS_ENDPOINT);
+    }
+
+    @Test
+    public void testCreateOrUpdateGroups() throws Exception {
+        Entity<PdpGroups> entgrp = makePdpGroupsEntity();
+
+        Invocation.Builder invocationBuilder = sendRequest(CREATEORUPDATE_GROUPS_ENDPOINT);
+        Response rawresp = invocationBuilder.post(entgrp);
+        PdpGroupUpdateResponse resp = rawresp.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), rawresp.getStatus());
+        assertNotNull(resp.getErrorDetails());
+
+        rawresp = invocationBuilder.post(entgrp);
+        resp = rawresp.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), rawresp.getStatus());
+        assertNotNull(resp.getErrorDetails());
+
+        // verify it fails when no authorization info is included
+        checkUnauthRequest(CREATEORUPDATE_GROUPS_ENDPOINT, req -> req.post(entgrp));
+    }
+
+    private Entity<PdpGroups> makePdpGroupsEntity() {
+        PdpSubGroup subgrp = new PdpSubGroup();
+        subgrp.setPdpType("drools");
+
+        PdpGroup group = new PdpGroup();
+        group.setName("drools-group");
+        group.setDescription("my description");
+        group.setPdpSubgroups(Arrays.asList(subgrp));
+        PdpGroups groups = new PdpGroups();
+        groups.setGroups(Arrays.asList(group));
+        return Entity.entity(groups, MediaType.APPLICATION_JSON);
+    }
+}
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateProvider.java b/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateProvider.java
new file mode 100644
index 00000000..1ac97c77
--- /dev/null
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateProvider.java
@@ -0,0 +1,563 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP PAP
+ * ================================================================================
+ * Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.main.rest;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.TreeMap;
+import javax.ws.rs.core.Response.Status;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.common.utils.services.Registry;
+import org.onap.policy.models.base.PfModelException;
+import org.onap.policy.models.pdp.concepts.PdpGroup;
+import org.onap.policy.models.pdp.concepts.PdpGroups;
+import org.onap.policy.models.pdp.concepts.PdpStateChange;
+import org.onap.policy.models.pdp.concepts.PdpSubGroup;
+import org.onap.policy.models.pdp.concepts.PdpUpdate;
+import org.onap.policy.models.pdp.enums.PdpState;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
+
+public class TestPdpGroupCreateOrUpdateProvider extends ProviderSuper {
+    private static final String EXPECTED_EXCEPTION = "expected exception";
+
+    private static final String PDP2 = "pdpB";
+    private static final String PDP4 = "pdpD";
+
+    private PdpGroupCreateOrUpdateProvider prov;
+
+    @AfterClass
+    public static void tearDownAfterClass() {
+        Registry.newRegistry();
+    }
+
+    /**
+     * Configures mocks and objects.
+     *
+     * @throws Exception if an error occurs
+     */
+    @Override
+    @Before
+    public void setUp() throws Exception {
+
+        super.setUp();
+
+        when(dao.getPolicyTypeList("typeA", "100.2.3")).thenReturn(Arrays.asList(loadPolicyType("daoPolicyType.json")));
+
+        prov = new PdpGroupCreateOrUpdateProvider();
+    }
+
+    @Test
+    public void testCreateOrUpdateGroups() throws Exception {
+        prov.createOrUpdateGroups(loadPdpGroups("emptyGroups.json"));
+
+        // no groups, so no action should have been taken
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testCreateOrUpdateGroups_InvalidRequest() throws Exception {
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(new PdpGroups())).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("is null");
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testCreateOrUpdate_Invalid() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("pdpGroupState");
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testAddGroup() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup group = groups.getGroups().get(0);
+        group.setPdpGroupState(PdpState.PASSIVE);
+
+        prov.createOrUpdateGroups(groups);
+
+        // should not have updated the state
+        assertEquals(PdpState.PASSIVE, group.getPdpGroupState());
+
+        assertSame(group, getGroupCreates().get(0));
+    }
+
+    @Test
+    public void testAddGroup_Invalid() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("pdpGroupState");
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testAddGroup_InvalidSubGroup() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+
+        groups.getGroups().get(0).getPdpSubgroups().get(0).getSupportedPolicyTypes().get(0).setVersion("99.99.99");
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("unknown policy type");
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testValidateGroupOnly_NullState() throws PfModelException {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        groups.getGroups().get(0).setPdpGroupState(null);
+        prov.createOrUpdateGroups(groups);
+    }
+
+    @Test
+    public void testValidateGroupOnly_Active() throws PfModelException {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        groups.getGroups().get(0).setPdpGroupState(PdpState.ACTIVE);
+        prov.createOrUpdateGroups(groups);
+    }
+
+    @Test
+    public void testValidateGroupOnly_Passive() throws PfModelException {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        groups.getGroups().get(0).setPdpGroupState(PdpState.PASSIVE);
+        prov.createOrUpdateGroups(groups);
+    }
+
+    @Test
+    public void testValidateGroupOnly_Invalid() {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("pdpGroupState");
+    }
+
+    @Test
+    public void testUpdateGroup() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+
+        // DB group = new group
+        PdpGroup group = new PdpGroup(groups.getGroups().get(0));
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testUpdateGroup_PropertiesChanged() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+
+        PdpGroup group = new PdpGroup(groups.getGroups().get(0));
+        group.setProperties(new TreeMap<>());
+
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("properties");
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testUpdateGroup_NewDescription() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        group.setDescription("old description");
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        assertGroupUpdateOnly(group);
+
+        assertEquals(group.getDescription(), "my description");
+        assertEquals(newgrp.toString(), group.toString());
+    }
+
+    @Test
+    public void testUpdateGroup_NewState() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        group.setPdpGroupState(PdpState.TEST);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        assertGroupUpdateOnly(group);
+
+        assertEquals(PdpState.ACTIVE, group.getPdpGroupState());
+        assertEquals(newgrp.toString(), group.toString());
+    }
+
+    @Test
+    public void testUpdateGroup_NewSubGroup() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
+        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        PdpGroup newgrp = groups.getGroups().get(0);
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testUpdateGroup_UpdatedSubGroup() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        // something different in this subgroup
+        group.getPdpSubgroups().get(0).setDesiredInstanceCount(10);
+
+        prov.createOrUpdateGroups(groups);
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testUpdateGroup_notifyPdpsDelSubGroups() throws Exception {
+        PdpGroup dbgroup = new PdpGroup(loadPdpGroups("createGroupsDelSub.json").getGroups().get(0));
+        when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
+
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+
+        prov.createOrUpdateGroups(groups);
+
+        // verify that DB group was updated
+        List<PdpGroup> updates = getGroupUpdates();
+        assertEquals(1, updates.size());
+        dbgroup = updates.get(0);
+
+        PdpGroup newgrp = groups.getGroups().get(0);
+
+        Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
+        Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
+
+        assertEquals(newgrp.toString(), dbgroup.toString());
+
+        // no deployment notifications
+        verify(notifier, never()).addDeploymentData(any());
+
+        // this requires a PDP UPDATE message
+        List<PdpUpdate> pdpUpdates = getUpdateRequests(2);
+        assertEquals(2, pdpUpdates.size());
+
+        PdpUpdate pdpUpdate = pdpUpdates.get(0);
+        assertEquals(PDP2, pdpUpdate.getName());
+        assertNull(pdpUpdate.getPdpGroup());
+
+        pdpUpdate = pdpUpdates.get(1);
+        assertEquals(PDP4, pdpUpdate.getName());
+        assertNull(pdpUpdate.getPdpGroup());
+
+        // it also requires a PDP STATE-CHANGE message
+        List<PdpStateChange> changes = getStateChangeRequests(2);
+        assertEquals(2, changes.size());
+
+        PdpStateChange change = changes.get(0);
+        assertEquals(PDP2, change.getName());
+        assertEquals(PdpState.PASSIVE, change.getState());
+
+        change = changes.get(1);
+        assertEquals(PDP4, change.getName());
+        assertEquals(PdpState.PASSIVE, change.getState());
+    }
+
+    @Test
+    public void testUpdateField_Unchanged() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testUpdateField_WasNull() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        group.setDescription(null);
+
+        prov.createOrUpdateGroups(groups);
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testUpdateField_NowNull() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        newgrp.setDescription(null);
+
+        prov.createOrUpdateGroups(groups);
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testUpdateField_Changed() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        newgrp.setDescription(group.getDescription() + "-changed");
+
+        prov.createOrUpdateGroups(groups);
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testAddSubGroup() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
+        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        PdpGroup newgrp = groups.getGroups().get(0);
+
+        PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);
+        newsub.setCurrentInstanceCount(0);
+        newsub.setPdpInstances(new ArrayList<>(0));
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    /**
+     * Tests addSubgroup() when the new subgroup has a wild-card policy type.
+     *
+     * @throws Exception if an error occurs
+     */
+    @Test
+    public void testAddSubGroupWildCardPolicyType() throws Exception {
+        when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyListWildCard.json"));
+        when(dao.getPolicyTypeList("some.*", "2.3.4")).thenReturn(Collections.emptyList());
+
+        PdpGroups groups = loadPdpGroups("createGroupsWildCard.json");
+        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        PdpGroup newgrp = groups.getGroups().get(0);
+
+        PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);
+        newsub.setCurrentInstanceCount(0);
+        newsub.setPdpInstances(new ArrayList<>(0));
+
+        assertEquals(newgrp.toString(), group.toString());
+    }
+
+    @Test
+    public void testAddSubGroup_ValidationPolicyTypeNotFound() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
+        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        when(dao.getPolicyTypeList(any(), any())).thenReturn(Collections.emptyList());
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).hasMessageContaining("unknown policy type");
+    }
+
+    @Test
+    public void testAddSubGroup_ValidationPolicyTypeDaoEx() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
+        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        PfModelException exc = new PfModelException(Status.CONFLICT, EXPECTED_EXCEPTION);
+        when(dao.getPolicyTypeList(any(), any())).thenThrow(exc);
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isSameAs(exc);
+    }
+
+    @Test
+    public void testAddSubGroup_ValidateVersionPrefixMatch() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup dbgroup = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
+
+        when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("createGroupNewPolicy.json"))
+            .thenReturn(loadPolicies("daoPolicyList.json")).thenReturn(loadPolicies("createGroupNewPolicy.json"));
+
+        PdpGroups reqgroups = loadPdpGroups("createGroupsVersPrefix.json");
+
+        prov.createOrUpdateGroups(reqgroups);
+
+        Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
+        Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
+
+        assertEquals(newgrp.toString(), dbgroup.toString());
+    }
+
+    @Test
+    public void testUpdateSubGroup_Invalid() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        // change properties
+        newgrp.getPdpSubgroups().get(0).setProperties(new TreeMap<>());
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("properties");
+
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testUpdateSubGroup_SupportedPolicies() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        newgrp.getPdpSubgroups().get(0).getSupportedPolicyTypes()
+            .add(new ToscaPolicyTypeIdentifier("typeX.*", "9.8.7"));
+
+        prov.createOrUpdateGroups(groups);
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testUpdateSubGroup_DesiredCount() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        newgrp.getPdpSubgroups().get(0).setDesiredInstanceCount(20);
+
+        prov.createOrUpdateGroups(groups);
+
+        assertEquals(newgrp.toString(), group.toString());
+        assertGroupUpdateOnly(group);
+    }
+
+    @Test
+    public void testUpdateSubGroup_Unchanged() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        prov.createOrUpdateGroups(groups);
+
+        Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
+        Collections.sort(group.getPdpSubgroups().get(0).getPolicies());
+
+        assertEquals(newgrp.toString(), group.toString());
+
+        // no notifications
+        verify(notifier, never()).addDeploymentData(any());
+        verify(notifier, never()).addUndeploymentData(any());
+
+        // no group updates
+        assertNoGroupAction();
+    }
+
+    @Test
+    public void testValidateSubGroup_PropertiesMismatch() throws Exception {
+        PdpGroups groups = loadPdpGroups("createGroups.json");
+        PdpGroup newgrp = groups.getGroups().get(0);
+        PdpGroup group = new PdpGroup(newgrp);
+        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+        newgrp.setProperties(new TreeMap<>());
+
+        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
+            .hasMessageContaining("properties");
+
+        assertNoGroupAction();
+    }
+
+    protected void assertUpdate(List<PdpUpdate> updates, String groupName, String pdpType, String pdpName) {
+
+        PdpUpdate update = updates.remove(0);
+
+        assertEquals(groupName, update.getPdpGroup());
+        assertEquals(pdpType, update.getPdpSubgroup());
+        assertEquals(pdpName, update.getName());
+        assertTrue(update.getPolicies().contains(policy1));
+    }
+
+    private void assertNoGroupAction() throws Exception {
+        verify(dao, never()).createPdpGroups(any());
+        verify(dao, never()).updatePdpGroups(any());
+        verify(reqmap, never()).addRequest(any(), any());
+    }
+
+    private void assertGroupUpdateOnly(PdpGroup group) throws Exception {
+        verify(dao, never()).createPdpGroups(any());
+        verify(reqmap, never()).addRequest(any(), any());
+
+        List<PdpGroup> updates = getGroupUpdates();
+        assertEquals(Arrays.asList(group), updates);
+    }
+}
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupDeployProvider.java b/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupDeployProvider.java
index 39a11396..a7fc11a8 100644
--- a/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupDeployProvider.java
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupDeployProvider.java
@@ -22,7 +22,6 @@ package org.onap.policy.pap.main.rest;
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
@@ -48,7 +47,6 @@ import org.onap.policy.models.base.PfModelRuntimeException;
 import org.onap.policy.models.pap.concepts.PdpDeployPolicies;
 import org.onap.policy.models.pdp.concepts.PdpGroup;
 import org.onap.policy.models.pdp.concepts.PdpGroups;
-import org.onap.policy.models.pdp.concepts.PdpStateChange;
 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
 import org.onap.policy.models.pdp.concepts.PdpUpdate;
 import org.onap.policy.models.pdp.enums.PdpState;
@@ -82,6 +80,7 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
      *
      * @throws Exception if an error occurs
      */
+    @Override
     @Before
     public void setUp() throws Exception {
 
@@ -146,19 +145,6 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
     }
 
     @Test
-    public void testAddGroup_InvalidSubGroup() throws Exception {
-        PdpGroups groups = loadPdpGroups("createGroups.json");
-
-        // policy won't match supported type
-        groups.getGroups().get(0).getPdpSubgroups().get(0).getSupportedPolicyTypes().get(0).setVersion("99.99.99");
-
-        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
-                        .hasMessageContaining("supported policy");
-
-        assertNoGroupAction();
-    }
-
-    @Test
     public void testValidateGroupOnly_NullState() throws PfModelException {
         PdpGroups groups = loadPdpGroups("createGroups.json");
         groups.getGroups().get(0).setPdpGroupState(null);
@@ -249,19 +235,6 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
     }
 
     @Test
-    public void testUpdateGroup_NewSubGroup() throws Exception {
-        PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
-        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
-        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
-
-        prov.createOrUpdateGroups(groups);
-
-        PdpGroup newgrp = groups.getGroups().get(0);
-        assertEquals(newgrp.toString(), group.toString());
-        assertGroupUpdateOnly(group);
-    }
-
-    @Test
     public void testUpdateGroup_UpdatedSubGroup() throws Exception {
         PdpGroups groups = loadPdpGroups("createGroups.json");
         PdpGroup newgrp = groups.getGroups().get(0);
@@ -278,60 +251,6 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
     }
 
     @Test
-    public void testUpdateGroup_notifyPdpsDelSubGroups() throws Exception {
-        PdpGroup dbgroup = new PdpGroup(loadPdpGroups("createGroupsDelSub.json").getGroups().get(0));
-        when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
-
-        PdpGroups groups = loadPdpGroups("createGroups.json");
-
-        prov.createOrUpdateGroups(groups);
-
-        // verify that DB group was updated
-        List<PdpGroup> updates = getGroupUpdates();
-        assertEquals(1, updates.size());
-        dbgroup = updates.get(0);
-
-        PdpGroup newgrp = groups.getGroups().get(0);
-
-        Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
-        Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
-
-        assertEquals(newgrp.toString(), dbgroup.toString());
-
-        // no deployment notifications
-        verify(notifier, never()).addDeploymentData(any());
-
-        // should have notified of deleted subgroup's policies/PDPs
-        ArgumentCaptor<PolicyPdpNotificationData> captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
-        verify(notifier).addUndeploymentData(captor.capture());
-        assertDeploymentData(captor, policy1.getIdentifier(), "[pdpB, pdpD]");
-
-        // this requires a PDP UPDATE message
-        List<PdpUpdate> pdpUpdates = getUpdateRequests(2);
-        assertEquals(2, pdpUpdates.size());
-
-        PdpUpdate pdpUpdate = pdpUpdates.get(0);
-        assertEquals(PDP2, pdpUpdate.getName());
-        assertNull(pdpUpdate.getPdpGroup());
-
-        pdpUpdate = pdpUpdates.get(1);
-        assertEquals(PDP4, pdpUpdate.getName());
-        assertNull(pdpUpdate.getPdpGroup());
-
-        // it also requires a PDP STATE-CHANGE message
-        List<PdpStateChange> changes = getStateChangeRequests(2);
-        assertEquals(2, changes.size());
-
-        PdpStateChange change = changes.get(0);
-        assertEquals(PDP2, change.getName());
-        assertEquals(PdpState.PASSIVE, change.getState());
-
-        change = changes.get(1);
-        assertEquals(PDP4, change.getName());
-        assertEquals(PdpState.PASSIVE, change.getState());
-    }
-
-    @Test
     public void testUpdateGroup_MultipleChanges() throws Exception {
         PdpGroups groups = loadPdpGroups("createGroups.json");
         PdpGroup newgrp = groups.getGroups().get(0);
@@ -416,24 +335,6 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
         assertGroupUpdateOnly(group);
     }
 
-    @Test
-    public void testAddSubGroup() throws Exception {
-        PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
-        PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
-        when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
-
-        prov.createOrUpdateGroups(groups);
-
-        PdpGroup newgrp = groups.getGroups().get(0);
-
-        PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);
-        newsub.setCurrentInstanceCount(0);
-        newsub.setPdpInstances(new ArrayList<>(0));
-
-        assertEquals(newgrp.toString(), group.toString());
-        assertGroupUpdateOnly(group);
-    }
-
     /**
      * Tests addSubgroup() when the new subgroup has a wild-card policy type.
      *
@@ -524,45 +425,6 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
     }
 
     @Test
-    public void testAddSubGroup_ValidateVersionPrefixMatch() throws Exception {
-        PdpGroups groups = loadPdpGroups("createGroups.json");
-        PdpGroup newgrp = groups.getGroups().get(0);
-        PdpGroup dbgroup = new PdpGroup(newgrp);
-        when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
-
-        when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("createGroupNewPolicy.json"))
-                        .thenReturn(loadPolicies("daoPolicyList.json"))
-                        .thenReturn(loadPolicies("createGroupNewPolicy.json"));
-
-        PdpGroups reqgroups = loadPdpGroups("createGroupsVersPrefix.json");
-
-        prov.createOrUpdateGroups(reqgroups);
-
-        Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
-        Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
-
-        assertEquals(newgrp.toString(), dbgroup.toString());
-    }
-
-    @Test
-    public void testAddSubGroup_ValidateVersionPrefixMismatch() throws Exception {
-        PdpGroups groups = loadPdpGroups("createGroups.json");
-        PdpGroup newgrp = groups.getGroups().get(0);
-        PdpGroup dbgroup = new PdpGroup(newgrp);
-        when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
-
-        when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyList.json"));
-
-
-        PdpGroups reqgroups = loadPdpGroups("createGroupsVersPrefixMismatch.json");
-
-        assertThatThrownBy(() -> prov.createOrUpdateGroups(reqgroups)).isInstanceOf(PfModelException.class)
-                        .hasMessageContaining("different version already deployed");
-
-        assertNoGroupAction();
-    }
-
-    @Test
     public void testUpdateSubGroup_Invalid() throws Exception {
         PdpGroups groups = loadPdpGroups("createGroups.json");
         PdpGroup newgrp = groups.getGroups().get(0);
@@ -674,25 +536,6 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
     }
 
     @Test
-    public void testUpdateSubGroup_PolicyVersionMismatch() throws Exception {
-        PdpGroups groups = loadPdpGroups("createGroups.json");
-        PdpGroup newgrp = groups.getGroups().get(0);
-        PdpGroup dbgroup = new PdpGroup(newgrp);
-        when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
-
-        // arrange for DB policy version to be different
-        PdpSubGroup dbsubgrp = dbgroup.getPdpSubgroups().get(0);
-        dbsubgrp.getPolicies().get(0).setVersion("9.9.9");
-
-        when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyList.json"));
-
-        assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
-                        .hasMessageContaining("different version already deployed");
-
-        assertNoGroupAction();
-    }
-
-    @Test
     public void testValidateSubGroup_PropertiesMismatch() throws Exception {
         PdpGroups groups = loadPdpGroups("createGroups.json");
         PdpGroup newgrp = groups.getGroups().get(0);
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/e2e/PdpGroupCreateOrUpdateTest.java b/main/src/test/java/org/onap/policy/pap/main/rest/e2e/PdpGroupCreateOrUpdateTest.java
new file mode 100644
index 00000000..dacee672
--- /dev/null
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/e2e/PdpGroupCreateOrUpdateTest.java
@@ -0,0 +1,180 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP PAP
+ * ================================================================================
+ * Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.main.rest.e2e;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Optional;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.onap.policy.models.pap.concepts.PdpGroupUpdateResponse;
+import org.onap.policy.models.pdp.concepts.PdpGroup;
+import org.onap.policy.models.pdp.concepts.PdpGroups;
+import org.onap.policy.models.pdp.enums.PdpState;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PdpGroupCreateOrUpdateTest extends End2EndBase {
+    private static final Logger logger = LoggerFactory.getLogger(PdpGroupCreateOrUpdateTest.class);
+
+    private static final String CREATEORUPDATE_GROUPS_ENDPOINT = "pdps/groups/batch";
+    private static final String DELETE_GROUP_ENDPOINT = "pdps/groups/";
+    private static final String CREATE_SUBGROUP = "pdpTypeA";
+    private static final String GROUP_ENDPOINT = "pdps";
+
+    /**
+     * Starts Main and adds policies to the DB.
+     *
+     * @throws Exception if an error occurs
+     */
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        End2EndBase.setUpBeforeClass();
+
+        addToscaPolicyTypes("monitoring.policy-type.yaml");
+    }
+
+    /**
+     * Sets up.
+     */
+    @Override
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+
+        context = new End2EndContext();
+    }
+
+    /**
+     * Deletes the deployed group.
+     */
+    @Override
+    @After
+    public void tearDown() {
+        // delete the group that was inserted
+        try {
+            sendRequest(DELETE_GROUP_ENDPOINT + "createGroups").delete();
+        } catch (Exception e) {
+            logger.warn("cannot delete group: createGroups", e);
+        }
+
+        super.tearDown();
+    }
+
+    @Test
+    public void testCreateGroups() throws Exception {
+
+        context.addPdp("pdpAA_1", CREATE_SUBGROUP);
+        context.addPdp("pdpAA_2", CREATE_SUBGROUP);
+        context.addPdp("pdpAB_1", "pdpTypeB");
+
+        context.startThreads();
+
+        Invocation.Builder invocationBuilder = sendRequest(CREATEORUPDATE_GROUPS_ENDPOINT);
+
+        PdpGroups groups = loadJsonFile("createGroups.json", PdpGroups.class);
+        Entity<PdpGroups> entity = Entity.entity(groups, MediaType.APPLICATION_JSON);
+        Response rawresp = invocationBuilder.post(entity);
+        PdpGroupUpdateResponse resp = rawresp.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
+        assertNull(resp.getErrorDetails());
+
+        context.await();
+
+        // none of the PDPs should have handled any requests
+        assertEquals(context.getPdps().size(),
+            context.getPdps().stream().filter(pdp -> pdp.getHandled().isEmpty()).count());
+
+        // repeat - should be OK
+        rawresp = invocationBuilder.post(entity);
+        resp = rawresp.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
+        assertNull(resp.getErrorDetails());
+
+        // repeat with different properties - should fail
+        groups.getGroups().get(0).setProperties(null);
+        rawresp = invocationBuilder.post(entity);
+        resp = rawresp.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), rawresp.getStatus());
+        assertTrue(resp.getErrorDetails().contains("cannot change properties"));
+    }
+
+    @Test
+    public void testCreateAndUpdate_MultipleGroups() throws Exception {
+
+        Invocation.Builder invocationBuilderForGroupUpdate = sendRequest(CREATEORUPDATE_GROUPS_ENDPOINT);
+
+        PdpGroups groups = loadJsonFile("createGroups.json", PdpGroups.class);
+        Entity<PdpGroups> entity = Entity.entity(groups, MediaType.APPLICATION_JSON);
+        Response rawPdpGroupUpdateResponse = invocationBuilderForGroupUpdate.post(entity);
+        PdpGroupUpdateResponse pdpGroupUpdateResponse =
+            rawPdpGroupUpdateResponse.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.OK.getStatusCode(), rawPdpGroupUpdateResponse.getStatus());
+        assertNull(pdpGroupUpdateResponse.getErrorDetails());
+
+        Invocation.Builder invocationBuilderForGroupQuery = sendRequest(GROUP_ENDPOINT);
+        Response pdpGroupQueryResponse = invocationBuilderForGroupQuery.get();
+        assertEquals(Response.Status.OK.getStatusCode(), pdpGroupQueryResponse.getStatus());
+        PdpGroups pdpGroupsInDb = pdpGroupQueryResponse.readEntity(PdpGroups.class);
+        assertEquals(1, pdpGroupsInDb.getGroups().size());
+        assertEquals("createGroups", pdpGroupsInDb.getGroups().get(0).getName());
+        assertEquals(PdpState.PASSIVE, pdpGroupsInDb.getGroups().get(0).getPdpGroupState());
+
+        // creating 2 new groups
+        PdpGroups newGroups = loadJsonFile("createNewGroups.json", PdpGroups.class);
+        entity = Entity.entity(newGroups, MediaType.APPLICATION_JSON);
+        rawPdpGroupUpdateResponse = invocationBuilderForGroupUpdate.post(entity);
+        pdpGroupUpdateResponse = rawPdpGroupUpdateResponse.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.OK.getStatusCode(), rawPdpGroupUpdateResponse.getStatus());
+        assertNull(pdpGroupUpdateResponse.getErrorDetails());
+
+        invocationBuilderForGroupQuery = sendRequest(GROUP_ENDPOINT);
+        pdpGroupQueryResponse = invocationBuilderForGroupQuery.get();
+        assertEquals(Response.Status.OK.getStatusCode(), pdpGroupQueryResponse.getStatus());
+        pdpGroupsInDb = pdpGroupQueryResponse.readEntity(PdpGroups.class);
+        assertEquals(3, pdpGroupsInDb.getGroups().size());
+
+        // updating a group, changing state of old group to active
+        groups.getGroups().get(0).setPdpGroupState(PdpState.ACTIVE);
+        entity = Entity.entity(groups, MediaType.APPLICATION_JSON);
+        rawPdpGroupUpdateResponse = invocationBuilderForGroupUpdate.post(entity);
+        pdpGroupUpdateResponse = rawPdpGroupUpdateResponse.readEntity(PdpGroupUpdateResponse.class);
+        assertEquals(Response.Status.OK.getStatusCode(), rawPdpGroupUpdateResponse.getStatus());
+        assertNull(pdpGroupUpdateResponse.getErrorDetails());
+
+        invocationBuilderForGroupQuery = sendRequest(GROUP_ENDPOINT);
+        pdpGroupQueryResponse = invocationBuilderForGroupQuery.get();
+        assertEquals(Response.Status.OK.getStatusCode(), pdpGroupQueryResponse.getStatus());
+        pdpGroupsInDb = pdpGroupQueryResponse.readEntity(PdpGroups.class);
+        assertEquals(3, pdpGroupsInDb.getGroups().size());
+        Optional<PdpGroup> oldGroupInDb =
+            pdpGroupsInDb.getGroups().stream().filter(group -> group.getName().equals("createGroups")).findAny();
+        assertEquals(PdpState.ACTIVE, oldGroupInDb.get().getPdpGroupState());
+    }
+}
diff --git a/main/src/test/resources/e2e/createGroups.json b/main/src/test/resources/e2e/createGroups.json
index 1c8774be..1630a8d5 100644
--- a/main/src/test/resources/e2e/createGroups.json
+++ b/main/src/test/resources/e2e/createGroups.json
@@ -29,12 +29,7 @@
                             "version": "1.0.0"
                         }
                     ],
-                    "policies": [
-                        {
-                            "name": "onap.restart.tca",
-                            "version": "1.0.0"
-                        }
-                    ]
+                    "policies": []
                 },
                 {
                     "pdpType": "pdpTypeB",
diff --git a/main/src/test/resources/e2e/createNewGroups.json b/main/src/test/resources/e2e/createNewGroups.json
new file mode 100644
index 00000000..45339322
--- /dev/null
+++ b/main/src/test/resources/e2e/createNewGroups.json
@@ -0,0 +1,48 @@
+{
+    "groups": [
+        {
+            "name": "newGroup1",
+            "pdpGroupState": "ACTIVE",
+            "properties": {
+                "hello": "world"
+            },
+            "pdpSubgroups": [
+                {
+                    "pdpType": "pdpTypeA",
+                    "desiredInstanceCount": 2,
+                    "properties": {},
+                    "pdpInstances": [],
+                    "supportedPolicyTypes": [
+                        {
+                            "name": "onap.policies.monitoring.cdap.tca.hi.lo.app",
+                            "version": "1.0.0"
+                        }
+                    ],
+                    "policies": []
+                }
+            ]
+        },
+        {
+            "name": "newGroup2",
+            "pdpGroupState": "ACTIVE",
+            "properties": {
+                "hello": "world"
+            },
+            "pdpSubgroups": [
+                {
+                    "pdpType": "pdpTypeB",
+                    "desiredInstanceCount": 2,
+                    "properties": {},
+                    "pdpInstances": [],
+                    "supportedPolicyTypes": [
+                        {
+                            "name": "onap.policies.monitoring.cdap.tca.hi.lo.app",
+                            "version": "1.0.0"
+                        }
+                    ],
+                    "policies": []
+                }
+            ]
+        }
+    ]
+}
diff --git a/main/src/test/resources/simpleDeploy/createGroups.json b/main/src/test/resources/simpleDeploy/createGroups.json
index 59c4eb87..daef17b7 100644
--- a/main/src/test/resources/simpleDeploy/createGroups.json
+++ b/main/src/test/resources/simpleDeploy/createGroups.json
@@ -26,12 +26,7 @@
                             "instanceId": "pdpA"
                         }
                     ],
-                    "policies": [
-                        {
-                            "name": "policyA",
-                            "version": "1.2.3"
-                        }
-                    ]
+                    "policies": []
                 }
             ]
         }
diff --git a/main/src/test/resources/simpleDeploy/createGroupsDelSub.json b/main/src/test/resources/simpleDeploy/createGroupsDelSub.json
index cba308ec..bcaa1c1f 100644
--- a/main/src/test/resources/simpleDeploy/createGroupsDelSub.json
+++ b/main/src/test/resources/simpleDeploy/createGroupsDelSub.json
@@ -26,12 +26,7 @@
                             "instanceId": "pdpA"
                         }
                     ],
-                    "policies": [
-                        {
-                            "name": "policyA",
-                            "version": "1.2.3"
-                        }
-                    ]
+                    "policies": []
                 },
                 {
                     "pdpType": "pdpTypeB",
@@ -51,12 +46,7 @@
                             "instanceId": "pdpD"
                         }
                     ],
-                    "policies": [
-                        {
-                            "name": "policyA",
-                            "version": "1.2.3"
-                        }
-                    ]
+                    "policies": []
                 }
             ]
         }