cloud/interface/src/test/java/org/iotivity/cloud/ciserver/resources/proxy/rd/DevicePresenceTest.java

   1 package org.iotivity.cloud.ciserver.resources.proxy.rd;
   2
   3 import static java.util.concurrent.TimeUnit.SECONDS;
   4 import static org.junit.Assert.assertEquals;
   5 import static org.junit.Assert.assertTrue;
   6 import static org.mockito.Mockito.mock;
   7
   8 import java.util.ArrayList;
   9 import java.util.HashMap;
  10 import java.util.List;
  11 import java.util.concurrent.CountDownLatch;
  12
  13 import org.iotivity.cloud.base.connector.ConnectorPool;
  14 import org.iotivity.cloud.base.device.CoapDevice;
  15 import org.iotivity.cloud.base.device.IRequestChannel;
  16 import org.iotivity.cloud.base.exception.ClientException;
  17 import org.iotivity.cloud.base.protocols.IRequest;
  18 import org.iotivity.cloud.base.protocols.IResponse;
  19 import org.iotivity.cloud.base.protocols.MessageBuilder;
  20 import org.iotivity.cloud.base.protocols.coap.CoapRequest;
  21 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  22 import org.iotivity.cloud.base.protocols.enums.Observe;
  23 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
  24 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  25 import org.iotivity.cloud.ciserver.DeviceServerSystem;
  26 import org.iotivity.cloud.util.Cbor;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.mockito.InjectMocks;
  30 import org.mockito.Mock;
  31 import org.mockito.Mockito;
  32 import org.mockito.MockitoAnnotations;
  33 import org.mockito.invocation.InvocationOnMock;
  34 import org.mockito.stubbing.Answer;
  35
  36 public class DevicePresenceTest {
  37     public static final String DEVICE_PRS_REQ_URI = "/.well-known/ocf/prs";
  38     public static final String DEVICE_LIST_KEY    = "devices";
  39     public static final String RES_PRS_URI        = "/oic/ad";
  40     private String             di                 = "B371C481-38E6-4D47-8320-7688D8A5B58C";
  41     String                     userId             = "testuser";
  42     private CoapDevice         mockDevice         = mock(CoapDevice.class);
  43     IResponse                  res                = null;
  44     IRequest                   req                = null;
  45     ConnectorPool              connectorPool      = null;
  46     DeviceServerSystem         deviceServerSystem = new DeviceServerSystem();
  47     final CountDownLatch       latch              = new CountDownLatch(1);
  48     @Mock
  49     IRequestChannel            requestChannel;
  50     @InjectMocks
  51     DevicePresence             prsHandler         = new DevicePresence();
  52
  53     @Before
  54     public void setUp() throws Exception {
  55         MockitoAnnotations.initMocks(this);
  56         deviceServerSystem.addResource(prsHandler);
  57         Mockito.doReturn("mockDeviceId").when(mockDevice).getDeviceId();
  58         Mockito.doAnswer(new Answer<Object>() {
  59             @Override
  60             public CoapRequest answer(InvocationOnMock invocation)
  61                     throws Throwable {
  62                 Object[] args = invocation.getArguments();
  63                 CoapRequest request = (CoapRequest) args[0];
  64                 System.out.println(
  65                         "\t----------payload : " + request.getPayloadString());
  66                 System.out.println(
  67                         "\t----------uripath : " + request.getUriPath());
  68                 System.out.println(
  69                         "\t---------uriquery : " + request.getUriQuery());
  70                 req = request;
  71                 latch.countDown();
  72                 return request;
  73             }
  74         }).when(requestChannel).sendRequest(Mockito.any(IRequest.class),
  75                 Mockito.any(CoapDevice.class));
  76     }
  77
  78     // @InjectMocks for testSpecificDeviceonResponseReceived
  79     IRequest                             requestSpecificDevice = makePresenceSpecificDevice(
  80             "device1");
  81     @InjectMocks
  82     DevicePresence.AccountReceiveHandler SpecificDeviceHandler = prsHandler.new AccountReceiveHandler(
  83             requestSpecificDevice, mockDevice);
  84
  85     @Test
  86     public void testSpecificDeviceonResponseReceived() throws ClientException {
  87         System.out.println(
  88                 "\t--------------onResponseReceived(RD) Device Presence (specific deivce) Test------------");
  89         IResponse response = responseFromAccountServer();
  90         SpecificDeviceHandler.onResponseReceived(response);
  91         HashMap<String, List<String>> queryMap = req.getUriQueryMap();
  92         assertTrue(req.getObserve() == Observe.SUBSCRIBE);
  93         assertTrue(queryMap.get("di").contains("device1"));
  94         assertTrue(req.getMethod() == RequestMethod.GET);
  95     }
  96
  97     // @InjectMocks for testEntireDeviceonResponseReceived
  98     IRequest                             requestEntireDevices = makePresenceEntireDevice();
  99     @InjectMocks
 100     DevicePresence.AccountReceiveHandler EntireDeviceHandler  = prsHandler.new AccountReceiveHandler(
 101             requestEntireDevices, mockDevice);
 102
 103     @Test
 104     public void testEntireDeviceonResponseReceived() throws ClientException {
 105         System.out.println(
 106                 "\t--------------onResponseReceived(RD) Device Presence (entire deivces) Test------------");
 107         IResponse response = responseFromAccountServer();
 108         EntireDeviceHandler.onResponseReceived(response);
 109         HashMap<String, List<String>> queryMap = req.getUriQueryMap();
 110         assertTrue(req.getMethod() == RequestMethod.GET);
 111         assertTrue(queryMap.get("di").contains("device1"));
 112         assertTrue(queryMap.get("di").contains("device2"));
 113         assertTrue(queryMap.get("di").contains("device3"));
 114         assertTrue(req.getObserve() == Observe.SUBSCRIBE);
 115     }
 116
 117     @Test
 118     public void testDevicePresenceObserverSpecificDeviceOnRequestReceived()
 119             throws Exception {
 120         System.out.println(
 121                 "\t--------------OnRequestReceived(RD) Device Presence (observe specific device) Test------------");
 122         IRequest request = makePresenceSpecificDevice(di);
 123         deviceServerSystem.onRequestReceived(mockDevice, request);
 124         assertTrue(latch.await(1L, SECONDS));
 125         HashMap<String, List<String>> queryMap = req.getUriQueryMap();
 126         assertTrue(queryMap.containsKey("mid"));
 127         assertTrue(req.getMethod().equals(RequestMethod.GET));
 128         assertEquals(req.getUriPath(), "/.well-known/ocf/acl/group/null");
 129     }
 130
 131     // @InjectMocks for testPresenceDeregisterSpecificDeviceOnRequestReceived
 132     IRequest                             requestDeregisterSpecificDevice = makeDeregisterSpecificDevice(
 133             "device1");
 134     @InjectMocks
 135     DevicePresence.AccountReceiveHandler DeregisterHandler               = prsHandler.new AccountReceiveHandler(
 136             requestDeregisterSpecificDevice, mockDevice);
 137
 138     @Test
 139     public void testPresenceDeregisterSpecificDeviceOnRequestReceived()
 140             throws Exception {
 141         System.out.println(
 142                 "\t--------------OnRequestReceived(RD) Device Presence (deregister specific device) Test------------");
 143         IResponse response = responseFromAccountServer();
 144         DeregisterHandler.onResponseReceived(response);
 145         HashMap<String, List<String>> queryMap = req.getUriQueryMap();
 146         assertTrue(req.getMethod() == RequestMethod.GET);
 147         assertTrue(queryMap.get("di").contains("device1"));
 148         assertTrue(req.getObserve() == Observe.UNSUBSCRIBE);
 149     }
 150
 151     @Test
 152     public void testDevicePresenceObserverEntireDevicesOnRequestReceived()
 153             throws Exception {
 154         System.out.println(
 155                 "\t--------------OnRequestReceived(RD) Device Presence (observe entire devices) Test------------");
 156         IRequest request = makePresenceEntireDevice();
 157         deviceServerSystem.onRequestReceived(mockDevice, request);
 158         assertTrue(latch.await(1L, SECONDS));
 159         assertTrue(req.getMethod().equals(RequestMethod.GET));
 160         HashMap<String, List<String>> queryMap = req.getUriQueryMap();
 161         assertTrue(queryMap.containsKey("mid"));
 162         assertEquals(req.getUriPath(), "/.well-known/ocf/acl/group/null");
 163     }
 164
 165     public IRequest makePresenceEntireDevice() {
 166         IRequest request = null;
 167         request = MessageBuilder.createRequest(RequestMethod.GET,
 168                 DEVICE_PRS_REQ_URI, null);
 169         ((CoapRequest) request).setObserve(Observe.SUBSCRIBE);
 170         return request;
 171     }
 172
 173     private IRequest makePresenceSpecificDevice(String di) {
 174         String query = "di=" + di;
 175         IRequest request = null;
 176         request = MessageBuilder.createRequest(RequestMethod.GET,
 177                 DEVICE_PRS_REQ_URI, query);
 178         ((CoapRequest) request).setObserve(Observe.SUBSCRIBE);
 179         return request;
 180     }
 181
 182     private IRequest makeDeregisterSpecificDevice(String di) {
 183         String query = "di=" + di;
 184         IRequest request = null;
 185         request = MessageBuilder.createRequest(RequestMethod.GET,
 186                 DEVICE_PRS_REQ_URI, query);
 187         ((CoapRequest) request).setObserve(Observe.UNSUBSCRIBE);
 188         return request;
 189     }
 190
 191     private IResponse responseFromAccountServer() {
 192         // make response which has "CONTENT" status
 193         Cbor<HashMap<String, Object>> cbor = new Cbor<>();
 194         HashMap<String, Object> responsePayload = new HashMap<String, Object>();
 195         ArrayList<String> deviceList = new ArrayList<String>();
 196         // assuming that there are three devices in the response msg from
 197         // the AS
 198         deviceList.add("device1");
 199         deviceList.add("device2");
 200         deviceList.add("device3");
 201         responsePayload.put("dilist", deviceList);
 202         responsePayload.put("gid", "g0001");
 203         responsePayload.put("gmid", "u0001");
 204         ArrayList<String> midList = new ArrayList<String>();
 205         midList.add("u0001");
 206         responsePayload.put("midlist", midList);
 207         IRequest requestFromCitoAs = MessageBuilder.createRequest(
 208                 RequestMethod.GET, "/.well-known/ocf/acl/group/g0001",
 209                 "mid=null");
 210         IResponse response = MessageBuilder.createResponse(requestFromCitoAs,
 211                 ResponseStatus.CONTENT, ContentFormat.APPLICATION_CBOR,
 212                 cbor.encodingPayloadToCbor(responsePayload));
 213         return response;
 214     }
 215 }