POLICY-SDK-APP/src/test/java/org/onap/policy/model/PDPGroupContainerTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   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.model;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertNull;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.mockito.Mockito.doThrow;
  29 import static org.mockito.Mockito.when;
  30
  31 import com.att.research.xacml.api.pap.PAPException;
  32 import java.awt.Checkbox;
  33 import java.util.Set;
  34 import org.junit.Test;
  35 import org.mockito.Mockito;
  36 import org.onap.policy.rest.util.PolicyContainer.ItemSetChangeListener;
  37 import org.onap.policy.xacml.api.pap.OnapPDP;
  38 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
  39 import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
  40
  41 public class PDPGroupContainerTest {
  42     private OnapPDPGroup group = Mockito.mock(OnapPDPGroup.class);
  43     private OnapPDPGroup newGroup = Mockito.mock(OnapPDPGroup.class);
  44     private OnapPDP pdp = Mockito.mock(OnapPDP.class);
  45     private PAPPolicyEngine engine = Mockito.mock(PAPPolicyEngine.class);
  46     private PDPGroupContainer container = new PDPGroupContainer(engine);
  47
  48     @Test
  49     public void testContainer() throws PAPException {
  50         Object itemId = new Object();
  51         assertEquals(container.isSupported(itemId), false);
  52
  53         container.refreshGroups();
  54         assertEquals(container.getGroups().size(), 0);
  55
  56         container.makeDefault(group);
  57         container.removeGroup(group, newGroup);
  58         container.updatePDP(pdp);
  59         container.updateGroup(group);
  60         container.updateGroup(group, "testUserName");
  61         assertNull(container.getContainerPropertyIds());
  62         assertEquals(container.getItemIds().size(), 0);
  63         assertEquals(container.getType(itemId), null);
  64         assertEquals(container.size(), 0);
  65         assertEquals(container.containsId(itemId), false);
  66         String name = "testName";
  67         String description = "testDescription";
  68         container.addNewGroup(name, description);
  69         String id = "testID";
  70         int jmxport = 0;
  71         container.addNewPDP(id, newGroup, name, description, jmxport);
  72         container.movePDP(pdp, newGroup);
  73         ItemSetChangeListener listener = null;
  74         container.addItemSetChangeListener(listener);
  75         container.nextItemId(itemId);
  76         container.prevItemId(itemId);
  77         container.firstItemId();
  78         container.lastItemId();
  79         container.isFirstId(itemId);
  80         container.isLastId(itemId);
  81         container.indexOfId(itemId);
  82         assertEquals(container.getItemIds().size(), 0);
  83         container.removeItem(itemId);
  84         container.removePDP(pdp, newGroup);
  85     }
  86
  87     @Test(expected = UnsupportedOperationException.class)
  88     public void testAddItem() {
  89         container.addItem();
  90     }
  91
  92     @Test(expected = UnsupportedOperationException.class)
  93     public void testAddContainerProperty() {
  94         container.addContainerProperty(null, null, null);
  95     }
  96
  97     @Test(expected = UnsupportedOperationException.class)
  98     public void testRemoveContainerProperty() {
  99         container.removeContainerProperty(null);
 100     }
 101
 102     @Test(expected = UnsupportedOperationException.class)
 103     public void testRemoveAllItems() {
 104         container.removeAllItems();
 105     }
 106
 107     @Test(expected = UnsupportedOperationException.class)
 108     public void testAddItemAfter() {
 109         container.addItemAfter(null);
 110     }
 111
 112     @Test(expected = IndexOutOfBoundsException.class)
 113     public void testGetIdByIndexException() {
 114         container.getIdByIndex(0);
 115     }
 116
 117     @Test(expected = UnsupportedOperationException.class)
 118     public void testAddItemAt() {
 119         container.addItemAt(0);
 120     }
 121
 122     @Test(expected = IllegalArgumentException.class)
 123     public void testGetItemIdsException() {
 124         container.getItemIds(0, 1);
 125     }
 126
 127     @Test
 128     public void testGetType() {
 129         assertEquals(Boolean.class, container.getType("Default"));
 130         assertEquals(Checkbox.class, container.getType("Selected"));
 131         assertEquals(Set.class, container.getType("PDPs"));
 132         assertEquals(Set.class, container.getType("Policies"));
 133         assertEquals(Set.class, container.getType("PIP Configurations"));
 134         assertEquals(String.class, container.getType("Id"));
 135         assertEquals(String.class, container.getType("Name"));
 136         assertEquals(String.class, container.getType("Description"));
 137         assertEquals(String.class, container.getType("Status"));
 138     }
 139
 140     @Test
 141     public void testContainerPAPExceptions() throws PAPException {
 142         doThrow(PAPException.class).when(engine).getOnapPDPGroups();
 143         container.refreshGroups();
 144
 145         doThrow(PAPException.class).when(engine).setDefaultGroup(group);
 146         container.makeDefault(group);
 147
 148         doThrow(PAPException.class).when(engine).updatePDP(pdp);
 149         container.updatePDP(pdp);
 150
 151         doThrow(PAPException.class).when(engine).updateGroup(group);
 152         container.updateGroup(group);
 153
 154         doThrow(PAPException.class).when(engine).updateGroup(group, "testUserName");
 155         container.updateGroup(group, "testUserName");
 156
 157         doThrow(PAPException.class).when(engine).movePDP(pdp, group);
 158         container.movePDP(pdp, group);
 159     }
 160
 161     @Test(expected = PAPException.class)
 162     public void testContainerRemoveGroup() throws PAPException {
 163         doThrow(PAPException.class).when(engine).removeGroup(group, newGroup);
 164         container.removeGroup(group, newGroup);
 165     }
 166
 167     @Test(expected = PAPException.class)
 168     public void testContainerRemovePDP() throws PAPException {
 169         doThrow(PAPException.class).when(engine).removePDP(pdp);
 170         container.removePDP(pdp, group);
 171     }
 172
 173     @Test(expected = UnsupportedOperationException.class)
 174     public void testRemoveDefaultGroup() throws PAPException {
 175         when(group.isDefaultGroup()).thenReturn(true);
 176         container.removeGroup(group, newGroup);
 177     }
 178
 179     @Test
 180     public void testGetItemIds() {
 181         assertNotNull(container.getItemIds(0, 0));
 182     }
 183
 184     @Test
 185     public void testContainsId() {
 186         assertFalse(container.containsId(group));
 187     }
 188
 189     @Test
 190     public void testGroupMethods() {
 191         container.groups.add(group);
 192
 193         Object retObj = container.getIdByIndex(0);
 194         assertTrue(retObj instanceof OnapPDPGroup);
 195         assertNotNull(retObj);
 196
 197         Object retFirstItemId = container.firstItemId();
 198         assertTrue(retFirstItemId instanceof OnapPDPGroup);
 199         assertNotNull(retFirstItemId);
 200
 201         Object retLastItemId = container.lastItemId();
 202         assertTrue(retLastItemId instanceof OnapPDPGroup);
 203         assertNotNull(retLastItemId);
 204
 205         assertTrue(container.isFirstId(group));
 206
 207         assertTrue(container.isLastId(group));
 208     }
 209
 210     @Test
 211     public void testNextItemId() {
 212         OnapPDPGroup groupNotInList = Mockito.mock(OnapPDPGroup.class);
 213         Object retObj = null;
 214
 215         container.groups.add(group);
 216         container.groups.add(newGroup);
 217
 218         assertNull(container.nextItemId(groupNotInList));
 219         assertNull(container.nextItemId(newGroup));
 220
 221         retObj = container.nextItemId(group);
 222         assertNotNull(retObj);
 223         assertTrue(retObj instanceof OnapPDPGroup);
 224     }
 225
 226     @Test
 227     public void testPrevItemId() {
 228         OnapPDPGroup groupNotInList = Mockito.mock(OnapPDPGroup.class);
 229         Object retObj = null;
 230
 231         container.groups.add(group);
 232         container.groups.add(newGroup);
 233
 234         assertNull(container.prevItemId(groupNotInList));
 235         assertNull(container.prevItemId(group));
 236
 237         retObj = container.prevItemId(newGroup);
 238         assertNotNull(retObj);
 239         assertTrue(retObj instanceof OnapPDPGroup);
 240     }
 241
 242     @Test
 243     public void testRemoveNullItem() {
 244         OnapPDPGroup nullGroup = null;
 245         assertFalse(container.removeItem(nullGroup));
 246     }
 247
 248     @Test(expected = UnsupportedOperationException.class)
 249     public void testRemoveDefaultItem() {
 250         when(group.getId()).thenReturn("Default");
 251         container.removeItem(group);
 252     }
 253
 254     @SuppressWarnings("unchecked")
 255     @Test
 256     public void testRemoveItem() throws PAPException {
 257         assertTrue(container.removeItem(group));
 258
 259         PAPPolicyEngine mockPAPPolicyEngine = Mockito.mock(PAPPolicyEngine.class);
 260         PDPGroupContainer groupContainer = new PDPGroupContainer(mockPAPPolicyEngine);
 261         when(mockPAPPolicyEngine.getDefaultGroup()).thenThrow(PAPException.class);
 262         assertFalse(groupContainer.removeItem(group));
 263     }
 264 }