opendaylight/adsal/containermanager/shell/src/test/java/org/opendaylight/controller/containermanager/shell/ContainerManagerShellTest.java

   1 package org.opendaylight.controller.containermanager.shell;
   2
   3 import java.io.ByteArrayOutputStream;
   4 import java.io.PrintStream;
   5 import java.util.ArrayList;
   6 import java.util.Arrays;
   7 import java.util.List;
   8 import java.lang.reflect.Field;
   9
  10 import org.junit.Assert;
  11 import org.junit.Test;
  12 import static org.mockito.Mockito.mock;
  13 import static org.mockito.Mockito.when;
  14 import org.opendaylight.controller.containermanager.IContainerManagerShell;
  15
  16
  17 public class ContainerManagerShellTest {
  18     private IContainerManagerShell containerManager;
  19
  20     @Test
  21     public void testAddContainer() throws Exception {
  22         String containerName = "test", staticVlan = "1234";
  23         AddContainer addConTest = new AddContainer();
  24         containerManager = mock(IContainerManagerShell.class);
  25         List<String> result = new ArrayList<String>(Arrays.asList("status"));
  26         List<String> result2 = new ArrayList<String>(Arrays.asList("Container Name not specified"));
  27         when(containerManager.addContainer(containerName, staticVlan)).thenReturn(result);
  28         when(containerManager.addContainer(null, null)).thenReturn(result2);
  29
  30         Field cNField = addConTest.getClass().getDeclaredField("containerName");
  31         cNField.setAccessible(true);
  32         Field sVField = addConTest.getClass().getDeclaredField("staticVlan");
  33         sVField.setAccessible(true);
  34
  35         cNField.set(addConTest, "test");
  36         sVField.set(addConTest, "1234");
  37
  38         addConTest.setContainerManager(containerManager);
  39         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  40         System.setOut(new PrintStream(baos));
  41         addConTest.doExecute();
  42         Assert.assertEquals("status\n", baos.toString());
  43         baos.reset();
  44
  45         cNField.set(addConTest, null);
  46         sVField.set(addConTest, null);
  47         addConTest.doExecute();
  48         Assert.assertEquals("Container Name not specified\n", baos.toString());
  49     }
  50
  51     @Test
  52     public void testAddContainerEntry() throws Exception {
  53         String containerName = "test", nodeId = "1234", portId = "5678";
  54         AddContainerEntry addConEntTest = new AddContainerEntry();
  55         containerManager = mock(IContainerManagerShell.class);
  56         List<String> result = new ArrayList<String>(Arrays.asList("status"));
  57         when(containerManager.addContainerEntry(containerName, nodeId, portId)).thenReturn(result);
  58
  59         Field cNField = addConEntTest.getClass().getDeclaredField("containerName");
  60         cNField.setAccessible(true);
  61         Field nIField = addConEntTest.getClass().getDeclaredField("nodeId");
  62         nIField.setAccessible(true);
  63         Field pIField = addConEntTest.getClass().getDeclaredField("portId");
  64         pIField.setAccessible(true);
  65
  66         cNField.set(addConEntTest, "test");
  67         nIField.set(addConEntTest, "1234");
  68         pIField.set(addConEntTest, "5678");
  69
  70         addConEntTest.setContainerManager(containerManager);
  71         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  72         System.setOut(new PrintStream(baos));
  73         addConEntTest.doExecute();
  74         Assert.assertEquals("status\n", baos.toString());
  75     }
  76
  77     @Test
  78     public void testAddContainerFlow() throws Exception {
  79         String containerName = "test", cflowName = "1234", unidirectional = "5678";
  80         AddContainerFlow addConFlowTest = new AddContainerFlow();
  81         containerManager = mock(IContainerManagerShell.class);
  82         List<String> result = new ArrayList<String>(Arrays.asList("status"));
  83         when(containerManager.addContainerFlow(containerName, cflowName, unidirectional)).thenReturn(result);
  84
  85         Field cNField = addConFlowTest.getClass().getDeclaredField("containerName");
  86         cNField.setAccessible(true);
  87         Field cfField = addConFlowTest.getClass().getDeclaredField("cflowName");
  88         cfField.setAccessible(true);
  89         Field unField = addConFlowTest.getClass().getDeclaredField("unidirectional");
  90         unField.setAccessible(true);
  91
  92         cNField.set(addConFlowTest, "test");
  93         cfField.set(addConFlowTest, "1234");
  94         unField.set(addConFlowTest, "5678");
  95
  96         addConFlowTest.setContainerManager(containerManager);
  97         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  98         System.setOut(new PrintStream(baos));
  99         addConFlowTest.doExecute();
 100         Assert.assertEquals("status\n", baos.toString());
 101     }
 102
 103     @Test
 104     public void testContainermgrGetAuthorizedGroups() throws Exception {
 105         String roleName = "test";
 106         ContainermgrGetAuthorizedGroups contmgrGTest = new ContainermgrGetAuthorizedGroups();
 107         containerManager = mock(IContainerManagerShell.class);
 108         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 109         when(containerManager.containermgrGetAuthorizedGroups(roleName)).thenReturn(result);
 110
 111         Field rNField = contmgrGTest.getClass().getDeclaredField("roleName");
 112         rNField.setAccessible(true);
 113
 114         rNField.set(contmgrGTest, "test");
 115
 116         contmgrGTest.setContainerManager(containerManager);
 117         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 118         System.setOut(new PrintStream(baos));
 119         contmgrGTest.doExecute();
 120         Assert.assertEquals("status\n", baos.toString());
 121     }
 122
 123     @Test
 124     public void testContainermgrGetAuthorizedResources() throws Exception {
 125         String roleName = "test";
 126         ContainermgrGetAuthorizedResources contmgrRTest = new ContainermgrGetAuthorizedResources();
 127         containerManager = mock(IContainerManagerShell.class);
 128         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 129         when(containerManager.containermgrGetAuthorizedResources(roleName)).thenReturn(result);
 130
 131         Field rNField = contmgrRTest.getClass().getDeclaredField("roleName");
 132         rNField.setAccessible(true);
 133
 134         rNField.set(contmgrRTest, "test");
 135
 136         contmgrRTest.setContainerManager(containerManager);
 137         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 138         System.setOut(new PrintStream(baos));
 139         contmgrRTest.doExecute();
 140         Assert.assertEquals("status\n", baos.toString());
 141     }
 142
 143     @Test
 144     public void testContainermgrGetResourcesForGroup() throws Exception {
 145         String groupName = "test";
 146         ContainermgrGetResourcesForGroup contmgrRTest = new ContainermgrGetResourcesForGroup();
 147         containerManager = mock(IContainerManagerShell.class);
 148         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 149         when(containerManager.containermgrGetResourcesForGroup(groupName)).thenReturn(result);
 150
 151         Field gNField = contmgrRTest.getClass().getDeclaredField("groupName");
 152         gNField.setAccessible(true);
 153
 154         gNField.set(contmgrRTest, groupName);
 155
 156         contmgrRTest.setContainerManager(containerManager);
 157         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 158         System.setOut(new PrintStream(baos));
 159         contmgrRTest.doExecute();
 160         Assert.assertEquals("status\n", baos.toString());
 161     }
 162
 163     @Test
 164     public void testContainermgrGetRoles() throws Exception {
 165         ContainermgrGetRoles contmgrRTest = new ContainermgrGetRoles();
 166         containerManager = mock(IContainerManagerShell.class);
 167         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 168         when(containerManager.containermgrGetRoles()).thenReturn(result);
 169
 170         contmgrRTest.setContainerManager(containerManager);
 171         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 172         System.setOut(new PrintStream(baos));
 173         contmgrRTest.doExecute();
 174         Assert.assertEquals("status\n", baos.toString());
 175     }
 176
 177     @Test
 178     public void testContainermgrGetUserLevel() throws Exception {
 179         String userName = "test";
 180         ContainermgrGetUserLevel contmgrUTest = new ContainermgrGetUserLevel();
 181         containerManager = mock(IContainerManagerShell.class);
 182         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 183         when(containerManager.containermgrGetUserLevel(userName)).thenReturn(result);
 184
 185         Field gNField = contmgrUTest.getClass().getDeclaredField("userName");
 186         gNField.setAccessible(true);
 187
 188         gNField.set(contmgrUTest, userName);
 189
 190         contmgrUTest.setContainerManager(containerManager);
 191         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 192         System.setOut(new PrintStream(baos));
 193         contmgrUTest.doExecute();
 194         Assert.assertEquals("status\n", baos.toString());
 195     }
 196
 197     @Test
 198     public void testContainermgrGetUserResources() throws Exception {
 199         String userName = "test";
 200         ContainermgrGetUserResources contmgrUTest = new ContainermgrGetUserResources();
 201         containerManager = mock(IContainerManagerShell.class);
 202         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 203         when(containerManager.containermgrGetUserResources(userName)).thenReturn(result);
 204
 205         Field gNField = contmgrUTest.getClass().getDeclaredField("userName");
 206         gNField.setAccessible(true);
 207
 208         gNField.set(contmgrUTest, userName);
 209
 210         contmgrUTest.setContainerManager(containerManager);
 211         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 212         System.setOut(new PrintStream(baos));
 213         contmgrUTest.doExecute();
 214         Assert.assertEquals("status\n", baos.toString());
 215     }
 216
 217     @Test
 218     public void testPfc() throws Exception {
 219         Pfc pfc = new Pfc();
 220         containerManager = mock(IContainerManagerShell.class);
 221         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 222         when(containerManager.pfc()).thenReturn(result);
 223
 224         pfc.setContainerManager(containerManager);
 225         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 226         System.setOut(new PrintStream(baos));
 227         pfc.doExecute();
 228         Assert.assertEquals("status\n", baos.toString());
 229     }
 230
 231     @Test
 232     public void testPsc() throws Exception {
 233         Psc psc = new Psc();
 234         containerManager = mock(IContainerManagerShell.class);
 235         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 236         when(containerManager.psc()).thenReturn(result);
 237
 238         psc.setContainerManager(containerManager);
 239         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 240         System.setOut(new PrintStream(baos));
 241         psc.doExecute();
 242         Assert.assertEquals("status\n", baos.toString());
 243     }
 244
 245     @Test
 246     public void testPsd() throws Exception {
 247         Psd psd = new Psd();
 248         containerManager = mock(IContainerManagerShell.class);
 249         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 250         when(containerManager.psd()).thenReturn(result);
 251
 252         psd.setContainerManager(containerManager);
 253         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 254         System.setOut(new PrintStream(baos));
 255         psd.doExecute();
 256         Assert.assertEquals("status\n", baos.toString());
 257     }
 258
 259     @Test
 260     public void testPsm() throws Exception {
 261         Psm psm = new Psm();
 262         containerManager = mock(IContainerManagerShell.class);
 263         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 264         when(containerManager.psm()).thenReturn(result);
 265
 266         psm.setContainerManager(containerManager);
 267         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 268         System.setOut(new PrintStream(baos));
 269         psm.doExecute();
 270         Assert.assertEquals("status\n", baos.toString());
 271     }
 272
 273     @Test
 274     public void testPsp() throws Exception {
 275         Psp psp = new Psp();
 276         containerManager = mock(IContainerManagerShell.class);
 277         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 278         when(containerManager.psp()).thenReturn(result);
 279
 280         psp.setContainerManager(containerManager);
 281         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 282         System.setOut(new PrintStream(baos));
 283         psp.doExecute();
 284         Assert.assertEquals("status\n", baos.toString());
 285     }
 286
 287     @Test
 288     public void testRemoveContainer() throws Exception {
 289         String containerName = "test";
 290         RemoveContainer remConTest = new RemoveContainer();
 291         containerManager = mock(IContainerManagerShell.class);
 292         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 293         when(containerManager.removeContainerShell(containerName)).thenReturn(result);
 294
 295         Field cNField = remConTest.getClass().getDeclaredField("containerName");
 296         cNField.setAccessible(true);
 297         cNField.set(remConTest, "test");
 298
 299         remConTest.setContainerManager(containerManager);
 300         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 301         System.setOut(new PrintStream(baos));
 302         remConTest.doExecute();
 303         Assert.assertEquals("status\n", baos.toString());
 304     }
 305
 306     @Test
 307     public void testRemoveContainerEntry() throws Exception {
 308         String containerName = "test", nodeId = "1234", portId = "5678";
 309         RemoveContainerEntry remConEntTest = new RemoveContainerEntry();
 310         containerManager = mock(IContainerManagerShell.class);
 311         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 312         when(containerManager.removeContainerEntry(containerName, nodeId, portId)).thenReturn(result);
 313
 314         Field cNField = remConEntTest.getClass().getDeclaredField("containerName");
 315         cNField.setAccessible(true);
 316         Field nIField = remConEntTest.getClass().getDeclaredField("nodeId");
 317         nIField.setAccessible(true);
 318         Field pIField = remConEntTest.getClass().getDeclaredField("portId");
 319         pIField.setAccessible(true);
 320
 321         cNField.set(remConEntTest, "test");
 322         nIField.set(remConEntTest, "1234");
 323         pIField.set(remConEntTest, "5678");
 324
 325         remConEntTest.setContainerManager(containerManager);
 326         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 327         System.setOut(new PrintStream(baos));
 328         remConEntTest.doExecute();
 329         Assert.assertEquals("status\n", baos.toString());
 330     }
 331
 332     @Test
 333     public void testRemoveContainerFlow() throws Exception {
 334         String containerName = "test", cflowName = "1234";
 335         RemoveContainerFlow remConFlowTest = new RemoveContainerFlow();
 336         containerManager = mock(IContainerManagerShell.class);
 337         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 338         when(containerManager.removeContainerFlow(containerName, cflowName)).thenReturn(result);
 339
 340         Field cNField = remConFlowTest.getClass().getDeclaredField("containerName");
 341         cNField.setAccessible(true);
 342         Field cfField = remConFlowTest.getClass().getDeclaredField("cflowName");
 343         cfField.setAccessible(true);
 344
 345         cNField.set(remConFlowTest, "test");
 346         cfField.set(remConFlowTest, "1234");
 347
 348         remConFlowTest.setContainerManager(containerManager);
 349         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 350         System.setOut(new PrintStream(baos));
 351         remConFlowTest.doExecute();
 352         Assert.assertEquals("status\n", baos.toString());
 353     }
 354
 355     @Test
 356     public void testSaveConfig() throws Exception {
 357         SaveConfig saveConfig = new SaveConfig();
 358         containerManager = mock(IContainerManagerShell.class);
 359         List<String> result = new ArrayList<String>(Arrays.asList("status"));
 360         when(containerManager.saveConfig()).thenReturn(result);
 361
 362         saveConfig.setContainerManager(containerManager);
 363         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 364         System.setOut(new PrintStream(baos));
 365         saveConfig.doExecute();
 366         Assert.assertEquals("status\n", baos.toString());
 367     }
 368 }