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.assertNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.mockito.Mockito.mock;
  28
  29 import java.util.ArrayList;
  30 import java.util.HashMap;
  31 import java.util.concurrent.CountDownLatch;
  32
  33 import org.iotivity.cloud.base.device.CoapDevice;
  34 import org.iotivity.cloud.base.protocols.IRequest;
  35 import org.iotivity.cloud.base.protocols.IResponse;
  36 import org.iotivity.cloud.base.protocols.MessageBuilder;
  37 import org.iotivity.cloud.base.protocols.coap.CoapRequest;
  38 import org.iotivity.cloud.base.protocols.coap.CoapResponse;
  39 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  40 import org.iotivity.cloud.base.protocols.enums.Observe;
  41 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
  42 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  43 import org.iotivity.cloud.rdserver.Constants;
  44 import org.iotivity.cloud.rdserver.resources.directory.rd.ResourceDirectoryResource;
  45 import org.iotivity.cloud.rdserver.resources.presence.device.DevicePresenceResource;
  46 import org.iotivity.cloud.util.Cbor;
  47 import org.junit.After;
  48 import org.junit.Before;
  49 import org.junit.Test;
  50 import org.mockito.Mockito;
  51 import org.mockito.invocation.InvocationOnMock;
  52 import org.mockito.stubbing.Answer;
  53
  54 public class DevicePresenceResourceTest {
  55     private Cbor<HashMap<String, Object>> mCbor                       = new Cbor<>();
  56     private ResourceDirectoryResource     mRDResource                 = null;
  57     private DevicePresenceResource        mMockDevicePresenceResource = null;
  58     private CoapDevice                    mMockDevice                 = null;
  59     private CountDownLatch                mLatch                      = null;
  60     private IResponse                     mResponse;
  61
  62     @Before
  63     public void setUp() throws Exception {
  64         mResponse = null;
  65         mMockDevice = mock(CoapDevice.class);
  66         mLatch = new CountDownLatch(1);
  67         mRDResource = new ResourceDirectoryResource();
  68         mMockDevicePresenceResource = new DevicePresenceResource();
  69         // callback mock
  70         Mockito.doAnswer(new Answer<Object>() {
  71             @Override
  72             public CoapResponse answer(InvocationOnMock invocation)
  73                     throws Throwable {
  74                 CoapResponse resp = (CoapResponse) invocation.getArguments()[0];
  75                 mLatch.countDown();
  76                 mResponse = resp;
  77                 return null;
  78             }
  79         }).when(mMockDevice).sendResponse(Mockito.anyObject());
  80     }
  81
  82     @After
  83     public void tearDown() throws Exception {
  84         RDServerTestUtils.resetRDDatabase();
  85     }
  86
  87     private IRequest makePresenceGetRequest(Observe obs) {
  88         String query = Constants.DEVICE_ID + "=" + RDServerTestUtils.DI;
  89         IRequest request = null;
  90         if (obs.compareTo(Observe.SUBSCRIBE) == 0) {
  91             request = MessageBuilder.createRequest(RequestMethod.GET,
  92                     RDServerTestUtils.DEVICE_PRS_REQ_URI, query);
  93         } else if (obs.compareTo(Observe.UNSUBSCRIBE) == 0) {
  94             request = MessageBuilder.createRequest(RequestMethod.GET,
  95                     RDServerTestUtils.DEVICE_PRS_REQ_URI, query);
  96         }
  97         ((CoapRequest) request).setObserve(obs);
  98         return request;
  99     }
 100
 101     private HashMap<String, String> parsePayload(IResponse response) {
 102
 103         HashMap<String, Object> payloadData = mCbor
 104                 .parsePayloadFromCbor(response.getPayload(), HashMap.class);
 105
 106         ArrayList<HashMap<String, String>> prsList = (ArrayList<HashMap<String, String>>) payloadData
 107                 .get(Constants.PRESENCE_LIST);
 108
 109         if (prsList.isEmpty()) {
 110             return null;
 111         } else {
 112             return prsList.get(0);
 113
 114         }
 115     }
 116
 117     @Test
 118     public void testSubscribeRequest() throws Exception {
 119         System.out.println("\t------testHandleGetSubscribeRequest");
 120         mRDResource.onDefaultRequestReceived(mMockDevice,
 121                 RDServerTestUtils.makePublishRequest());
 122         IRequest request = makePresenceGetRequest(Observe.SUBSCRIBE);
 123         mMockDevicePresenceResource.onDefaultRequestReceived(mMockDevice,
 124                 request);
 125         // assertion: if the response status is "CONTENT"
 126         assertTrue(mLatch.await(2L, SECONDS));
 127         assertTrue(checkResponseCode(mResponse, ResponseStatus.CONTENT));
 128         assertNull(parsePayload(mResponse));
 129     }
 130
 131     @Test
 132     public void testUnsubscribeRequest() throws Exception {
 133         System.out.println("\t------testHandleGetUnsubscribeRequest");
 134         IRequest request = makePresenceGetRequest(Observe.UNSUBSCRIBE);
 135         mRDResource.onDefaultRequestReceived(mMockDevice,
 136                 RDServerTestUtils.makePublishRequest());
 137         mMockDevicePresenceResource.onDefaultRequestReceived(mMockDevice,
 138                 request);
 139         // assertion: if the response status is "CONTENT"
 140         assertTrue(mLatch.await(2L, SECONDS));
 141         assertTrue(checkResponseCode(mResponse, ResponseStatus.CONTENT));
 142         assertNull(parsePayload(mResponse));
 143     }
 144
 145     @Test
 146     public void testSubscribeRequest_existDevice() throws Exception {
 147         System.out.println("\t------testSubscribeRequest_existDevice");
 148         CoapDevice observerDevice = mock(CoapDevice.class);
 149         CountDownLatch observerLatch = new CountDownLatch(2);
 150         // callback mock for observer Device
 151         Mockito.doAnswer(new Answer<Object>() {
 152             @Override
 153             public CoapResponse answer(InvocationOnMock invocation)
 154                     throws Throwable {
 155                 CoapResponse response = (CoapResponse) invocation
 156                         .getArguments()[0];
 157                 observerLatch.countDown();
 158                 // assertion for observer device (subscribe response)
 159                 if (observerLatch.getCount() == 1) {
 160                     assertTrue(checkResponseCode(response,
 161                             ResponseStatus.CONTENT));
 162                 }
 163                 if (observerLatch.getCount() == 0) {
 164                     assertTrue(checkResponseCode(response,
 165                             ResponseStatus.CONTENT));
 166                     assertTrue(checkPayloadProperty(response,
 167                             Constants.DEVICE_ID));
 168                     assertTrue(checkPayloadProperty(response,
 169                             Constants.PRESENCE_STATE));
 170                     assertTrue(parsePayload(response)
 171                             .get(Constants.PRESENCE_STATE).equals("on"));
 172                 }
 173
 174                 return null;
 175             }
 176
 177         }).when(observerDevice).sendResponse(Mockito.anyObject());
 178         // subscribe request (specific device)
 179         IRequest subRequest = makePresenceGetRequest(Observe.SUBSCRIBE);
 180         mMockDevicePresenceResource.onDefaultRequestReceived(observerDevice,
 181                 subRequest);
 182         // POST device presence off
 183         HashMap<String, Object> payload = new HashMap<>();
 184         payload.put(Constants.DEVICE_ID, RDServerTestUtils.DI);
 185         payload.put(Constants.PRESENCE_STATE, "on");
 186         IRequest request = MessageBuilder.createRequest(RequestMethod.POST,
 187                 RDServerTestUtils.DEVICE_PRS_REQ_URI, null,
 188                 ContentFormat.APPLICATION_CBOR,
 189                 mCbor.encodingPayloadToCbor(payload));
 190         mMockDevicePresenceResource.onDefaultRequestReceived(mMockDevice,
 191                 request);
 192         // assertion for resource server device : responseStatus is "CHANGED"
 193         assertTrue(mLatch.await(2L, SECONDS));
 194         assertTrue(observerLatch.await(2L, SECONDS));
 195         assertTrue(checkResponseCode(mResponse, ResponseStatus.CHANGED));
 196     }
 197
 198     @Test
 199     public void testUnSubscribeRequest_existDevice() throws Exception {
 200         System.out.println("\t------testUnSubscribeRequest_existDevice");
 201         CoapDevice observerDevice = mock(CoapDevice.class);
 202         CountDownLatch observerLatch = new CountDownLatch(1);
 203         // callback mock for observer Device
 204         Mockito.doAnswer(new Answer<Object>() {
 205             @Override
 206             public CoapResponse answer(InvocationOnMock invocation)
 207                     throws Throwable {
 208                 CoapResponse response = (CoapResponse) invocation
 209                         .getArguments()[0];
 210                 observerLatch.countDown();
 211                 // assertion for observer device (subscribe response)
 212                 if (observerLatch.getCount() == 0) {
 213                     assertTrue(checkResponseCode(response,
 214                             ResponseStatus.CONTENT));
 215                 }
 216
 217                 return null;
 218             }
 219
 220         }).when(observerDevice).sendResponse(Mockito.anyObject());
 221         // subscribe request (specific device)
 222         IRequest subRequest = makePresenceGetRequest(Observe.UNSUBSCRIBE);
 223         mMockDevicePresenceResource.onDefaultRequestReceived(observerDevice,
 224                 subRequest);
 225         HashMap<String, Object> payload = new HashMap<>();
 226         payload.put(Constants.DEVICE_ID, RDServerTestUtils.DI);
 227         payload.put(Constants.PRESENCE_STATE, "off");
 228         IRequest request = MessageBuilder.createRequest(RequestMethod.POST,
 229                 RDServerTestUtils.DEVICE_PRS_REQ_URI, null,
 230                 ContentFormat.APPLICATION_CBOR,
 231                 mCbor.encodingPayloadToCbor(payload));
 232         mMockDevicePresenceResource.onDefaultRequestReceived(mMockDevice,
 233                 request);
 234         // assertion for resource server device : responseStatus is "CHANGED"
 235         assertTrue(mLatch.await(2L, SECONDS));
 236         assertTrue(observerLatch.await(2L, SECONDS));
 237         assertTrue(checkResponseCode(mResponse, ResponseStatus.CHANGED));
 238     }
 239
 240     private boolean checkPayloadProperty(IResponse response,
 241             String propertyName) {
 242         HashMap<String, Object> payloadData = mCbor
 243                 .parsePayloadFromCbor(response.getPayload(), HashMap.class);
 244
 245         ArrayList<HashMap<String, String>> prsList = (ArrayList<HashMap<String, String>>) payloadData
 246                 .get(Constants.PRESENCE_LIST);
 247
 248         HashMap<String, String> mapData = prsList.get(0);
 249         if (mapData.containsKey(propertyName))
 250             return true;
 251         else
 252             return false;
 253     }
 254
 255     private boolean checkResponseCode(IResponse response,
 256             ResponseStatus responseStatus) {
 257         if (responseStatus == response.getStatus())
 258             return true;
 259         else
 260             return false;
 261     }
 262
 263 }