cloud/resourcedirectory/src/test/java/org/iotivity/cloud/testrdserver/DevicePresenceResourceTest.java

   1 /*
   2  * //******************************************************************
   3  * //
   4  * // Copyright 2016 Samsung Electronics All Rights Reserved.
   5  * //
   6  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  * //
   8  * // Licensed under the Apache License, Version 2.0 (the "License");
   9  * // you may not use this file except in compliance with the License.
  10  * // You may obtain a copy of the License at
  11  * //
  12  * //      http://www.apache.org/licenses/LICENSE-2.0
  13  * //
  14  * // Unless required by applicable law or agreed to in writing, software
  15  * // distributed under the License is distributed on an "AS IS" BASIS,
  16  * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * // See the License for the specific language governing permissions and
  18  * // limitations under the License.
  19  * //
  20  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22 package org.iotivity.cloud.testrdserver;
  23
  24 import static java.util.concurrent.TimeUnit.SECONDS;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.assertNull;
  27 import static org.mockito.Mockito.mock;
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.concurrent.CountDownLatch;
  31 import org.iotivity.cloud.base.device.CoapDevice;
  32 import org.iotivity.cloud.base.protocols.IRequest;
  33 import org.iotivity.cloud.base.protocols.IResponse;
  34 import org.iotivity.cloud.base.protocols.MessageBuilder;
  35 import org.iotivity.cloud.base.protocols.coap.CoapRequest;
  36 import org.iotivity.cloud.base.protocols.coap.CoapResponse;
  37 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  38 import org.iotivity.cloud.base.protocols.enums.Observe;
  39 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
  40 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  41 import org.iotivity.cloud.rdserver.Constants;
  42 import org.iotivity.cloud.rdserver.resources.directory.rd.ResourceDirectoryResource;
  43 import org.iotivity.cloud.rdserver.resources.presence.device.DevicePresenceResource;
  44 import org.iotivity.cloud.util.Cbor;
  45 import org.junit.After;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48 import org.mockito.Mockito;
  49 import org.mockito.invocation.InvocationOnMock;
  50 import org.mockito.stubbing.Answer;
  51
  52 public class DevicePresenceResourceTest {
  53     private Cbor<ArrayList<Object>>   mCbor                      = new Cbor<>();
  54     private ResourceDirectoryResource mRDResource                = null;
  55     private DevicePresenceResource    mockDevicePresenceResource = null;
  56     private CoapDevice                mockDevice                 = null;
  57     CountDownLatch                    latch                      = null;
  58     IResponse                         res;
  59
  60     @Before
  61     public void setUp() throws Exception {
  62         res = null;
  63         mockDevice = mock(CoapDevice.class);
  64         latch = new CountDownLatch(1);
  65         mRDResource = new ResourceDirectoryResource();
  66         mockDevicePresenceResource = new DevicePresenceResource();
  67         // callback mock
  68         Mockito.doAnswer(new Answer<Object>() {
  69             @Override
  70             public CoapResponse answer(InvocationOnMock invocation)
  71                     throws Throwable {
  72                 CoapResponse resp = (CoapResponse) invocation.getArguments()[0];
  73                 latch.countDown();
  74                 res = resp;
  75                 return resp;
  76             }
  77         }).when(mockDevice).sendResponse(Mockito.anyObject());
  78     }
  79
  80     @After
  81     public void tearDown() throws Exception {
  82         RDServerTestUtils.resetRDDatabase();
  83     }
  84
  85     private IRequest makePresenceGetRequest(Observe obs) {
  86         String query = "di=" + RDServerTestUtils.DI;
  87         IRequest request = null;
  88         if (obs.compareTo(Observe.SUBSCRIBE) == 0) {
  89             request = MessageBuilder.createRequest(RequestMethod.GET,
  90                     RDServerTestUtils.DEVICE_PRS_REQ_URI, query);
  91         } else if (obs.compareTo(Observe.UNSUBSCRIBE) == 0) {
  92             ArrayList<String> devices = new ArrayList<>();
  93             devices.add(RDServerTestUtils.DI);
  94             HashMap<String, ArrayList<String>> payload = new HashMap<>();
  95             payload.put(Constants.DEVICE_LIST_KEY, devices);
  96             Cbor<HashMap<String, Object>> cbor = new Cbor<>();
  97             request = MessageBuilder.createRequest(RequestMethod.GET,
  98                     RDServerTestUtils.DEVICE_PRS_REQ_URI, query,
  99                     ContentFormat.APPLICATION_CBOR,
 100                     cbor.encodingPayloadToCbor(payload));
 101         }
 102         ((CoapRequest) request).setObserve(obs);
 103         return request;
 104     }
 105
 106     @Test
 107     public void testHandleGetSubscribeRequest_notExistVaule() throws Exception {
 108         System.out
 109                 .println("\t------testHandleGetSubscribeRequest_notExistVaule");
 110         IRequest request = makePresenceGetRequest(Observe.SUBSCRIBE);
 111         mockDevicePresenceResource.onDefaultRequestReceived(mockDevice,
 112                 request);
 113         // assertion: if the response status is "CONTENT"
 114         assertTrue(latch.await(2L, SECONDS));
 115         assertTrue(methodCheck(res, ResponseStatus.CONTENT));
 116         // assertion : if the payload has "di" and "state"
 117         assertTrue(arrayHashmapCheck(res, "di"));
 118         assertTrue(arrayHashmapCheck(res, "state"));
 119         ArrayList<Object> payloadData = mCbor
 120                 .parsePayloadFromCbor(res.getPayload(), ArrayList.class);
 121         HashMap<String, Object> mapData = (HashMap<String, Object>) payloadData
 122                 .get(0);
 123         assertNull(mapData.get("state"));
 124     }
 125
 126     @Test
 127     public void testHandleGetSubscribeRequest() throws Exception {
 128         System.out.println("\t------testHandleGetSubscribeRequest");
 129         mRDResource.onDefaultRequestReceived(mockDevice,
 130                 RDServerTestUtils.makePublishRequest());
 131         IRequest request = makePresenceGetRequest(Observe.SUBSCRIBE);
 132         mockDevicePresenceResource.onDefaultRequestReceived(mockDevice,
 133                 request);
 134         // assertion: if the response status is "CONTENT"
 135         assertTrue(latch.await(2L, SECONDS));
 136         assertTrue(methodCheck(res, ResponseStatus.CONTENT));
 137         // assertion : if the payload has "di" and "state"
 138         assertTrue(arrayHashmapCheck(res, "di"));
 139         assertTrue(arrayHashmapCheck(res, "state"));
 140         Cbor<ArrayList<Object>> mCbor = new Cbor<>();
 141         ArrayList<Object> payloadData = mCbor
 142                 .parsePayloadFromCbor(res.getPayload(), ArrayList.class);
 143         HashMap<String, Object> mapData = (HashMap<String, Object>) payloadData
 144                 .get(0);
 145         assertNull(mapData.get("state"));
 146     }
 147
 148     @Test
 149     public void testHandleGetUnsubscribeRequest() throws Exception {
 150         System.out.println("\t------testHandleGetUnsubscribeRequest");
 151         IRequest request = makePresenceGetRequest(Observe.UNSUBSCRIBE);
 152         mRDResource.onDefaultRequestReceived(mockDevice,
 153                 RDServerTestUtils.makePublishRequest());
 154         mockDevicePresenceResource.onDefaultRequestReceived(mockDevice,
 155                 request);
 156         // assertion: if the response status is "CONTENT"
 157         assertTrue(latch.await(2L, SECONDS));
 158         assertTrue(methodCheck(res, ResponseStatus.CONTENT));
 159         // assertion : if the payload has "di" and "state"
 160         assertTrue(arrayHashmapCheck(res, "di"));
 161         assertTrue(arrayHashmapCheck(res, "state"));
 162         Cbor<ArrayList<Object>> mCbor = new Cbor<>();
 163         ArrayList<Object> payloadData = mCbor
 164                 .parsePayloadFromCbor(res.getPayload(), ArrayList.class);
 165         HashMap<String, Object> mapData = (HashMap<String, Object>) payloadData
 166                 .get(0);
 167         assertNull(mapData.get("state"));
 168     }
 169
 170     @Test
 171     public void testHandlePostRequest_presenceOn() throws Exception {
 172         System.out.println("\t------testHandlePostRequest_presenceOn");
 173         // POST device presence on
 174         HashMap<String, Object> payload = new HashMap<>();
 175         Cbor<HashMap<String, Object>> cbor = new Cbor<>();
 176         payload.put(Constants.DEVICE_ID, RDServerTestUtils.DI);
 177         payload.put(Constants.PRESENCE_STATE, "on");
 178         IRequest request = MessageBuilder.createRequest(RequestMethod.POST,
 179                 RDServerTestUtils.DEVICE_PRS_REQ_URI, null,
 180                 ContentFormat.APPLICATION_CBOR,
 181                 cbor.encodingPayloadToCbor(payload));
 182         mockDevicePresenceResource.onDefaultRequestReceived(mockDevice,
 183                 request);
 184         // subscribe request (specific device)
 185         IRequest subRequest = makePresenceGetRequest(Observe.SUBSCRIBE);
 186         mockDevicePresenceResource.onDefaultRequestReceived(mockDevice,
 187                 subRequest);
 188         // assertion: if the response status is "CONTENT"
 189         assertTrue(latch.await(2L, SECONDS));
 190         assertTrue(methodCheck(res, ResponseStatus.CONTENT));
 191         // assertion: if the device status is "on"
 192         assertTrue(arrayHashmapCheck(res, "di"));
 193         assertTrue(arrayHashmapCheck(res, "state"));
 194         Cbor<ArrayList<Object>> mCbor = new Cbor<>();
 195         ArrayList<Object> payloadData = mCbor
 196                 .parsePayloadFromCbor(res.getPayload(), ArrayList.class);
 197         HashMap<String, Object> mapData = (HashMap<String, Object>) payloadData
 198                 .get(0);
 199         assertTrue(mapData.get("state").equals("on"));
 200     }
 201
 202     @Test
 203     public void testHandlePostRequest_presenceOff() throws Exception {
 204         System.out.println("\t------testHandlePostRequest_presenceOff");
 205         CoapDevice observerDevice = mock(CoapDevice.class);
 206         CountDownLatch observerLatch = new CountDownLatch(2);
 207         // callback mock for observer Device
 208         Mockito.doAnswer(new Answer<Object>() {
 209             @Override
 210             public CoapResponse answer(InvocationOnMock invocation)
 211                     throws Throwable {
 212                 CoapResponse resp = (CoapResponse) invocation.getArguments()[0];
 213                 observerLatch.countDown();
 214                 // assertion for observer device (subscribe response)
 215                 if (observerLatch.getCount() == 1) {
 216                     assertTrue(methodCheck(resp, ResponseStatus.CONTENT));
 217                 }
 218                 // assertion for observer device (prs off response)
 219                 if (observerLatch.getCount() == 0) {
 220                     assertTrue(methodCheck(resp, ResponseStatus.CONTENT));
 221                     Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
 222                     HashMap<String, Object> payloadData = mCbor
 223                             .parsePayloadFromCbor(resp.getPayload(),
 224                                     HashMap.class);
 225                     assertTrue(payloadData.get("state").equals("off"));
 226                 }
 227
 228                 return null;
 229             }
 230
 231         }).when(observerDevice).sendResponse(Mockito.anyObject());
 232         // subscribe request (specific device)
 233         IRequest subRequest = makePresenceGetRequest(Observe.SUBSCRIBE);
 234         mockDevicePresenceResource.onDefaultRequestReceived(observerDevice,
 235                 subRequest);
 236         // POST device presence off
 237         HashMap<String, Object> payload = new HashMap<>();
 238         Cbor<HashMap<String, Object>> cbor = new Cbor<>();
 239         payload.put(Constants.DEVICE_ID, RDServerTestUtils.DI);
 240         payload.put(Constants.PRESENCE_STATE, "off");
 241         IRequest request = MessageBuilder.createRequest(RequestMethod.POST,
 242                 RDServerTestUtils.DEVICE_PRS_REQ_URI, null,
 243                 ContentFormat.APPLICATION_CBOR,
 244                 cbor.encodingPayloadToCbor(payload));
 245         mockDevicePresenceResource.onDefaultRequestReceived(mockDevice,
 246                 request);
 247         // assertion for resource server device : responseStatus is "CREATED"
 248         assertTrue(latch.await(2L, SECONDS));
 249         assertTrue(observerLatch.await(2L, SECONDS));
 250         assertTrue(methodCheck(res, ResponseStatus.CREATED));
 251     }
 252
 253     private boolean arrayHashmapCheck(IResponse response, String propertyName) {
 254         Cbor<ArrayList<Object>> mCbor = new Cbor<>();
 255         ArrayList<Object> payloadData = mCbor
 256                 .parsePayloadFromCbor(response.getPayload(), ArrayList.class);
 257         HashMap<String, Object> mapData = (HashMap<String, Object>) payloadData
 258                 .get(0);
 259         if (mapData.containsKey(propertyName))
 260             return true;
 261         else
 262             return false;
 263     }
 264
 265     private boolean methodCheck(IResponse response,
 266             ResponseStatus responseStatus) {
 267         if (responseStatus == response.getStatus())
 268             return true;
 269         else
 270             return false;
 271     }
 272
 273 }