service/simulator/unittests/SimulatorTest/src/org/oic/simulator/server/test/SimulatorCollectionResourceTest.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.oic.simulator.server.test;
  18
  19 import java.util.Vector;
  20
  21 import org.oic.simulator.InvalidArgsException;
  22 import org.oic.simulator.SimulatorException;
  23 import org.oic.simulator.SimulatorManager;
  24 import org.oic.simulator.SimulatorResourceModel;
  25 import org.oic.simulator.server.SimulatorCollectionResource;
  26 import org.oic.simulator.server.SimulatorResource;
  27 import org.oic.simulator.test.ExceptionType;
  28
  29 import junit.framework.TestCase;
  30
  31 public class SimulatorCollectionResourceTest extends TestCase {
  32
  33     private static final String         COLLECTION_RES_RAML = "./ramls/oic.d.airconditioner.raml";
  34     private SimulatorCollectionResource collectionResource  = null;
  35
  36     protected void setUp() throws Exception {
  37         super.setUp();
  38         collectionResource = (SimulatorCollectionResource) SimulatorManager
  39                 .createResource(COLLECTION_RES_RAML);
  40     }
  41
  42     protected void tearDown() throws Exception {
  43         super.tearDown();
  44         collectionResource = null;
  45     }
  46
  47     public void testAddChildResource_P01() {
  48         SimulatorResource childResource = null;
  49
  50         try {
  51             String name = "child-resource";
  52             String uri = "/child/resource";
  53             String resType = "child.resource";
  54
  55             childResource = SimulatorManager.createResource(
  56                     SimulatorResource.Type.SINGLE, name, uri, resType);
  57         } catch (InvalidArgsException e1) {
  58             e1.printStackTrace();
  59         } catch (SimulatorException e1) {
  60             e1.printStackTrace();
  61         }
  62
  63         if (null == childResource)
  64             return;
  65
  66         Vector<SimulatorResource> result = null;
  67         try {
  68             collectionResource.addChildResource(childResource);
  69             result = collectionResource.getChildResources();
  70         } catch (InvalidArgsException e) {
  71             e.printStackTrace();
  72         } catch (SimulatorException e) {
  73             e.printStackTrace();
  74         }
  75
  76         assertNotNull(result);
  77         assertEquals(1, result.size());
  78     }
  79
  80     public void testAddChildResource_P02() {
  81         SimulatorResource childResource = null;
  82
  83         try {
  84             String name = "child-resource";
  85             String uri = "/child/resource";
  86             String resType = "child.resource";
  87
  88             childResource = SimulatorManager.createResource(
  89                     SimulatorResource.Type.COLLECTION, name, uri, resType);
  90         } catch (InvalidArgsException e1) {
  91             e1.printStackTrace();
  92         } catch (SimulatorException e1) {
  93             e1.printStackTrace();
  94         }
  95
  96         if (null == childResource)
  97             return;
  98
  99         Vector<SimulatorResource> result = null;
 100         try {
 101             collectionResource.addChildResource(childResource);
 102             result = collectionResource.getChildResources();
 103         } catch (InvalidArgsException e) {
 104             e.printStackTrace();
 105         } catch (SimulatorException e) {
 106             e.printStackTrace();
 107         }
 108
 109         assertNotNull(result);
 110         assertEquals(1, result.size());
 111     }
 112
 113     public void testAddChildResource_P03() {
 114         SimulatorResource childResource1 = null;
 115         SimulatorResource childResource2 = null;
 116
 117         try {
 118             String name = "child-resource";
 119             String uri = "/child/resource";
 120             String resType = "child.resource";
 121
 122             childResource1 = SimulatorManager.createResource(
 123                     SimulatorResource.Type.SINGLE, name, uri, resType);
 124             childResource2 = SimulatorManager.createResource(
 125                     SimulatorResource.Type.COLLECTION, name + "-2", uri + "/2",
 126                     resType);
 127         } catch (InvalidArgsException e1) {
 128             e1.printStackTrace();
 129         } catch (SimulatorException e1) {
 130             e1.printStackTrace();
 131         }
 132
 133         if (null == childResource1 || null == childResource2)
 134             return;
 135
 136         Vector<SimulatorResource> result = null;
 137         try {
 138             collectionResource.addChildResource(childResource1);
 139             collectionResource.addChildResource(childResource2);
 140             result = collectionResource.getChildResources();
 141         } catch (InvalidArgsException e) {
 142             e.printStackTrace();
 143         } catch (SimulatorException e) {
 144             e.printStackTrace();
 145         }
 146
 147         assertNotNull(result);
 148         assertEquals(2, result.size());
 149     }
 150
 151     public void testAddChildResource_N01() {
 152         ExceptionType exType = ExceptionType.UNKNOWN;
 153
 154         try {
 155             collectionResource.addChildResource(null);
 156         } catch (InvalidArgsException e) {
 157             exType = ExceptionType.INVALID_ARGS;
 158         } catch (SimulatorException e) {
 159             exType = ExceptionType.SIMULATOR;
 160         }
 161
 162         assertTrue(exType == ExceptionType.INVALID_ARGS);
 163     }
 164
 165     public void testRemoveChildResource_P01() {
 166         SimulatorResource childResource = null;
 167         Vector<SimulatorResource> result = null;
 168
 169         try {
 170             String name = "child-resource";
 171             String uri = "/child/resource";
 172             String resType = "child.resource";
 173
 174             childResource = SimulatorManager.createResource(
 175                     SimulatorResource.Type.COLLECTION, name, uri, resType);
 176             collectionResource.addChildResource(childResource);
 177             result = collectionResource.getChildResources();
 178         } catch (InvalidArgsException e1) {
 179             e1.printStackTrace();
 180         } catch (SimulatorException e1) {
 181             e1.printStackTrace();
 182         }
 183
 184         if (null == childResource || null == result)
 185             return;
 186
 187         int count = result.size();
 188         try {
 189             collectionResource.removeChildResource(childResource);
 190             result = collectionResource.getChildResources();
 191         } catch (InvalidArgsException e) {
 192             e.printStackTrace();
 193         } catch (SimulatorException e) {
 194             e.printStackTrace();
 195         }
 196
 197         assertTrue((count == 1 && result == null)
 198                 || (count > 1 && result.size() == count - 1));
 199     }
 200
 201     public void testRemoveChildResource_N01() {
 202         ExceptionType exType = ExceptionType.UNKNOWN;
 203
 204         try {
 205             collectionResource.removeChildResource(null);
 206         } catch (InvalidArgsException e) {
 207             exType = ExceptionType.INVALID_ARGS;
 208         } catch (SimulatorException e) {
 209             exType = ExceptionType.SIMULATOR;
 210         }
 211
 212         assertTrue(exType == ExceptionType.INVALID_ARGS);
 213     }
 214
 215     public void testRemoveChildResourceByUri_P01() {
 216         SimulatorResource childResource = null;
 217         Vector<SimulatorResource> result = null;
 218
 219         try {
 220             String name = "child-resource";
 221             String uri = "/child/resource";
 222             String resType = "child.resource";
 223
 224             childResource = SimulatorManager.createResource(
 225                     SimulatorResource.Type.COLLECTION, name, uri, resType);
 226             collectionResource.addChildResource(childResource);
 227             result = collectionResource.getChildResources();
 228         } catch (InvalidArgsException e1) {
 229             e1.printStackTrace();
 230         } catch (SimulatorException e1) {
 231             e1.printStackTrace();
 232         }
 233
 234         if (null == childResource || null == result)
 235             return;
 236
 237         int count = result.size();
 238         try {
 239             collectionResource.removeChildResourceByUri(childResource.getURI());
 240             result = collectionResource.getChildResources();
 241         } catch (InvalidArgsException e) {
 242             e.printStackTrace();
 243         } catch (SimulatorException e) {
 244             e.printStackTrace();
 245         }
 246
 247         assertTrue((count == 1 && result == null)
 248                 || (count > 1 && result.size() == count - 1));
 249     }
 250
 251     public void testRemoveChildResourceByUri_N01() {
 252         ExceptionType exType = ExceptionType.UNKNOWN;
 253
 254         try {
 255             collectionResource.removeChildResourceByUri(null);
 256         } catch (InvalidArgsException e) {
 257             exType = ExceptionType.INVALID_ARGS;
 258         } catch (SimulatorException e) {
 259             exType = ExceptionType.SIMULATOR;
 260         }
 261
 262         assertTrue(exType == ExceptionType.INVALID_ARGS);
 263     }
 264
 265     public void testRemoveChildResourceByUri_N02() {
 266         ExceptionType exType = ExceptionType.UNKNOWN;
 267
 268         try {
 269             String uri = "";
 270             collectionResource.removeChildResourceByUri(uri);
 271         } catch (InvalidArgsException e) {
 272             exType = ExceptionType.INVALID_ARGS;
 273         } catch (SimulatorException e) {
 274             exType = ExceptionType.SIMULATOR;
 275         }
 276
 277         assertTrue(exType == ExceptionType.INVALID_ARGS);
 278     }
 279
 280     public void testGetResourceModel_P01() {
 281         SimulatorResourceModel result = null;
 282
 283         try {
 284             result = collectionResource.getResourceModel();
 285         } catch (InvalidArgsException e) {
 286             e.printStackTrace();
 287         } catch (SimulatorException e) {
 288             e.printStackTrace();
 289         }
 290
 291         assertNotNull(result);
 292         assertTrue(result.size() > 0);
 293     }
 294 }