cloud/account/src/test/java/org/iotivity/cloud/accountserver/resources/account/session/SessionResourceTest.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
  23 package org.iotivity.cloud.accountserver.resources.account.session;
  24
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.Mockito.mock;
  27
  28 import java.text.DateFormat;
  29 import java.text.SimpleDateFormat;
  30 import java.util.Date;
  31 import java.util.HashMap;
  32 import java.util.concurrent.CountDownLatch;
  33
  34 import org.iotivity.cloud.accountserver.Constants;
  35 import org.iotivity.cloud.accountserver.db.AccountDBManager;
  36 import org.iotivity.cloud.accountserver.db.TokenTable;
  37 import org.iotivity.cloud.accountserver.db.UserTable;
  38 import org.iotivity.cloud.accountserver.util.TypeCastingManager;
  39 import org.iotivity.cloud.base.ServerSystem;
  40 import org.iotivity.cloud.base.ServerSystem.PersistentPacketReceiver;
  41 import org.iotivity.cloud.base.device.CoapDevice;
  42 import org.iotivity.cloud.base.device.Device;
  43 import org.iotivity.cloud.base.protocols.IRequest;
  44 import org.iotivity.cloud.base.protocols.IResponse;
  45 import org.iotivity.cloud.base.protocols.MessageBuilder;
  46 import org.iotivity.cloud.base.protocols.coap.CoapResponse;
  47 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  48 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
  49 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  50 import org.iotivity.cloud.util.Cbor;
  51 import org.iotivity.cloud.util.Log;
  52 import org.junit.After;
  53 import org.junit.Before;
  54 import org.junit.Test;
  55 import org.mockito.InjectMocks;
  56 import org.mockito.Mock;
  57 import org.mockito.Mockito;
  58 import org.mockito.MockitoAnnotations;
  59 import org.mockito.invocation.InvocationOnMock;
  60 import org.mockito.stubbing.Answer;
  61
  62 import io.netty.channel.Channel;
  63 import io.netty.channel.ChannelHandlerContext;
  64 import io.netty.channel.ChannelId;
  65 import io.netty.util.Attribute;
  66
  67 public class SessionResourceTest {
  68     private final String                   DEFAULT_AUTH_LOGIN        = "/.well-known/ocf/account/session";
  69     private final String                   DEFAULT_AUTH_LOGOUT       = "/.well-known/ocf/account/session";
  70     private String                         di                        = "d0001";
  71     private String                         accessToken               = "5f5536c896da7dd437316585b86ef9dd03441c40";
  72     private String                         refreshToken              = "rt0001";
  73     private TypeCastingManager<UserTable>  mUserTableCastingManager  = new TypeCastingManager<>();
  74     private TypeCastingManager<TokenTable> mTokenTableCastingManager = new TypeCastingManager<>();
  75     ServerSystem                           serverSystem              = new ServerSystem();
  76     final CountDownLatch                   latch                     = new CountDownLatch(
  77             1);
  78     private String                         uuid                      = "bc38f243-aab5-44d3-8eb9-4a54ebbaf359";
  79     private String                         authProvider              = "github";
  80     private CoapDevice                     mockDevice                = Mockito
  81             .mock(CoapDevice.class);
  82     private Cbor<HashMap<String, Object>>  mCbor                     = new Cbor<>();
  83     IResponse                              res                       = null;
  84
  85     @Mock
  86     ChannelHandlerContext                  ctx;
  87
  88     @InjectMocks
  89     PersistentPacketReceiver               receiver                  = serverSystem.new PersistentPacketReceiver();
  90
  91     @Before
  92     public void setUp() throws Exception {
  93         // create log file
  94         Log.createfile();
  95         // add resource
  96         serverSystem.addResource(new SessionResource());
  97         MockitoAnnotations.initMocks(this);
  98         ChannelId channelId = mock(ChannelId.class);
  99         // inject mocked coapDevice into the api
 100         Channel channel = mock(Channel.class);
 101         Attribute<Device> attribute = mock(Attribute.class);
 102         Mockito.doReturn(channel).when(ctx).channel();
 103         Mockito.doReturn(attribute).when(channel).attr(Mockito.any());
 104         Mockito.doReturn(mockDevice).when(attribute).get();
 105         Mockito.doReturn(channelId).when(channel).id();
 106         Mockito.doReturn(
 107                 "0000000141f3edcfc2c3000000000001d0000000000000000000000000000000000000")
 108                 .when(channelId).asLongText();
 109         // register the token table and user table to the DB
 110         HashMap<String, Object> tokenInfo = mTokenTableCastingManager
 111                 .convertObjectToMap(makeTokenTable());
 112         HashMap<String, Object> userInfo = mUserTableCastingManager
 113                 .convertObjectToMap(makeUserTable());
 114         AccountDBManager.getInstance()
 115                 .insertAndReplaceRecord(Constants.TOKEN_TABLE, tokenInfo);
 116         AccountDBManager.getInstance().insertRecord(Constants.USER_TABLE,
 117                 userInfo);
 118         // response handler mock
 119         Mockito.doAnswer(new Answer<Object>() {
 120             @Override
 121             public CoapResponse answer(InvocationOnMock invocation)
 122                     throws Throwable {
 123
 124                 Object[] args = invocation.getArguments();
 125                 CoapResponse resp = (CoapResponse) args[0];
 126                 System.out.println(
 127                         "\t----------payload : " + resp.getPayloadString());
 128                 System.out.println("\t---------method : " + resp.getMethod());
 129                 res = resp;
 130                 latch.countDown();
 131                 return resp;
 132             }
 133         }).when(mockDevice).sendResponse(Mockito.anyObject());
 134         // exception handler mock
 135         Mockito.doAnswer(new Answer<Object>() {
 136             @Override
 137             public CoapResponse answer(InvocationOnMock invocation)
 138                     throws Throwable {
 139                 Object[] args = invocation.getArguments();
 140                 CoapResponse resp = (CoapResponse) args[0];
 141                 System.out.println("\t----exception response status : "
 142                         + resp.getStatus());
 143                 res = resp;
 144                 latch.countDown();
 145                 return null;
 146             }
 147         }).when(channel).writeAndFlush(Mockito.any());
 148     }
 149
 150     @After
 151     public void endTest() {
 152         AccountDBManager.getInstance().deleteRecord(Constants.TOKEN_TABLE,
 153                 mTokenTableCastingManager.convertObjectToMap(makeTokenTable()));
 154         AccountDBManager.getInstance().deleteRecord(Constants.USER_TABLE,
 155                 mUserTableCastingManager.convertObjectToMap(makeUserTable()));
 156     }
 157
 158     @Test
 159     public void testSignInOnDefaultRequestReceived() throws Exception {
 160         System.out.println("\t--------------Sign In Test------------");
 161         SignIn(di, accessToken);
 162         assertTrue(hashmapCheck(res, "expiresin"));
 163         assertTrue(methodCheck(res, ResponseStatus.CHANGED));
 164     }
 165
 166     @Test
 167     public void testSignInWithInvalidMethodOnDefaultRequestReceived()
 168             throws Exception {
 169         System.out.println(
 170                 "\t--------------Sign In With Invalid RequestMethod Test------------");
 171         SignInWithInvalidMethod(di, accessToken);
 172         assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
 173     }
 174
 175     @Test
 176     public void testWrongAccessTokenSignInOnDefaultRequestReceived()
 177             throws Exception {
 178         System.out.println(
 179                 "\t--------------Wrong AccessToken Sign In Test------------");
 180         String accessTokenNotStored = "5689c70ffa245effc563017fee36d250";
 181         // sign in request
 182         SignIn(di, accessTokenNotStored);
 183         assertTrue(methodCheck(res, ResponseStatus.UNAUTHORIZED));
 184     }
 185
 186     @Test
 187     public void testInvalidDeviceIdSignInOnDefaultRequestReceived()
 188             throws Exception {
 189         System.out.println(
 190                 "\t--------------Invalid DeviceId Sign In Test------------");
 191         String diNotStored = "F371C481-38E6-4D47-8320-7688D8A5B58C";
 192         SignIn(diNotStored, accessToken);
 193         assertTrue(methodCheck(res, ResponseStatus.UNAUTHORIZED));
 194     }
 195
 196     @Test
 197     public void testSignOutOnDefaultRequestReceived() throws Exception {
 198         System.out.println("\t--------------Sign Out Test------------");
 199         SignOut(di, accessToken);
 200         assertTrue(methodCheck(res, ResponseStatus.CHANGED));
 201     }
 202
 203     @Test
 204     public void testSignInWithNullPayloadOnDefaultRequestReceived()
 205             throws Exception {
 206         System.out.println(
 207                 "\t--------------Sign In With Null Payload Test------------");
 208         SignInWithNullPayload();
 209         assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
 210     }
 211
 212     @Test
 213     public void testSignOutWithNullPayloadOnDefaultRequestReceived()
 214             throws Exception {
 215         System.out.println(
 216                 "\t--------------Sign Out With Null Payload Test------------");
 217         // sign out request
 218         SignOutWithNullPayload();
 219         assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
 220     }
 221
 222     @Test
 223     public void testSignInWithBlankHashMapPayloadOnDefaultRequestReceived()
 224             throws Exception {
 225         System.out.println(
 226                 "\t--------------Sign In With Blank HashMap Payload Test------------");
 227         SignInWithBlankHashMapPayload();
 228         assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
 229     }
 230
 231     @Test
 232     public void testSignOutWithBlankHashMapPayloadOnDefaultRequestReceived()
 233             throws Exception {
 234         System.out.println(
 235                 "\t--------------Sign Out With Blank HashMap Test------------");
 236         SignOutWithBlankHashMapPayload();
 237         assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
 238     }
 239
 240     public void SignInWithInvalidMethod(String di, String accessToken)
 241             throws Exception {
 242         System.out.println("-----Sign In With Invalid Method (GET)");
 243         IRequest request = null;
 244         request = SignInWithInvalidMethodRequest(di, accessToken);
 245         receiver.channelRead(ctx, request);
 246     }
 247
 248     public void SignIn(String di, String accessToken) throws Exception {
 249         System.out.println("-----Sign In");
 250         IRequest request = null;
 251         request = SignInRequest(di, accessToken);
 252         receiver.channelRead(ctx, request);
 253     }
 254
 255     public void SignInWithBlankHashMapPayload() throws Exception {
 256         System.out.println("-----Sign In With Blank Hashmap Payload");
 257         IRequest request = null;
 258         request = SignInBlankHashmapPayloadRequest();
 259         receiver.channelRead(ctx, request);
 260     }
 261
 262     public void SignInWithNullPayload() throws Exception {
 263         System.out.println("-----Sign In With Null Payload");
 264         IRequest request = null;
 265         request = SignInNullPayloadRequest();
 266         receiver.channelRead(ctx, request);
 267     }
 268
 269     public void SignOut(String di, String accessToken) throws Exception {
 270         System.out.println("-----Sign Out");
 271         IRequest request = null;
 272         request = SignOutRequest(di, accessToken);
 273         receiver.channelRead(ctx, request);
 274     }
 275
 276     public void SignOutWithBlankHashMapPayload() throws Exception {
 277         System.out.println("-----Sign Out With Blank Hashmap Payload");
 278         IRequest request = null;
 279         request = SignOutBlankHashmapPayloadRequest();
 280         receiver.channelRead(ctx, request);
 281     }
 282
 283     public void SignOutWithNullPayload() throws Exception {
 284         System.out.println("-----Sign Out With Null Payload");
 285         IRequest request = null;
 286         request = SignOutNullPayloadRequest();
 287         receiver.channelRead(ctx, request);
 288     }
 289
 290     public IRequest SignInNullPayloadRequest() {
 291         IRequest request = null;
 292         request = MessageBuilder.createRequest(RequestMethod.POST,
 293                 DEFAULT_AUTH_LOGIN, null);
 294         return request;
 295     }
 296
 297     public IRequest SignInBlankHashmapPayloadRequest() {
 298         IRequest request = null;
 299         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 300         Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
 301         request = MessageBuilder.createRequest(RequestMethod.POST,
 302                 DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
 303                 cbor.encodingPayloadToCbor(payloadData));
 304         return request;
 305     }
 306
 307     public IRequest SignOutNullPayloadRequest() {
 308         IRequest request = null;
 309         request = MessageBuilder.createRequest(RequestMethod.POST,
 310                 DEFAULT_AUTH_LOGOUT, null);
 311         return request;
 312     }
 313
 314     public IRequest SignOutBlankHashmapPayloadRequest() {
 315         IRequest request = null;
 316         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 317         Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
 318         request = MessageBuilder.createRequest(RequestMethod.POST,
 319                 DEFAULT_AUTH_LOGOUT, null, ContentFormat.APPLICATION_CBOR,
 320                 cbor.encodingPayloadToCbor(payloadData));
 321         return request;
 322     }
 323
 324     public IRequest SignInWithInvalidMethodRequest(String deviceId,
 325             String accessToken) {
 326         IRequest request = null;
 327         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 328         payloadData.put("accesstoken", accessToken);
 329         payloadData.put("status", true);
 330         payloadData.put("di", deviceId);
 331         Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
 332         request = MessageBuilder.createRequest(RequestMethod.GET,
 333                 DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
 334                 cbor.encodingPayloadToCbor(payloadData));
 335         return request;
 336     }
 337
 338     public IRequest SignInRequest(String deviceId, String accessToken) {
 339         IRequest request = null;
 340         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 341         payloadData.put("accesstoken", accessToken);
 342         payloadData.put("login", true);
 343         payloadData.put("di", deviceId);
 344         payloadData.put("uid", uuid);
 345         Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
 346         request = MessageBuilder.createRequest(RequestMethod.POST,
 347                 DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
 348                 cbor.encodingPayloadToCbor(payloadData));
 349         return request;
 350     }
 351
 352     public IRequest SignOutRequest(String deviceId, String accessToken) {
 353         IRequest request = null;
 354         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 355         payloadData.put("accesstoken", accessToken);
 356         payloadData.put("login", false);
 357         payloadData.put("di", deviceId);
 358         payloadData.put("uid", uuid);
 359         Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
 360         request = MessageBuilder.createRequest(RequestMethod.POST,
 361                 DEFAULT_AUTH_LOGOUT, null, ContentFormat.APPLICATION_CBOR,
 362                 cbor.encodingPayloadToCbor(payloadData));
 363         return request;
 364     }
 365
 366     public boolean hashmapCheck(IResponse response, String propertyName) {
 367         HashMap<String, Object> payloadData = mCbor
 368                 .parsePayloadFromCbor(response.getPayload(), HashMap.class);
 369         if (payloadData.get(propertyName) != null)
 370             return true;
 371         else
 372             return false;
 373     }
 374
 375     public boolean methodCheck(IResponse response,
 376             ResponseStatus responseStatus) {
 377         if (responseStatus == response.getStatus())
 378             return true;
 379         else
 380             return false;
 381     }
 382
 383     private TokenTable makeTokenTable() {
 384         TokenTable tokenInfo = new TokenTable();
 385         tokenInfo.setUuid(uuid);
 386         tokenInfo.setDid(di);
 387         tokenInfo.setAccesstoken(accessToken);
 388         tokenInfo.setRefreshtoken(refreshToken);
 389         tokenInfo.setProvider(authProvider);
 390         tokenInfo.setExpiredtime(-1);
 391         Date currentTime = new Date();
 392         DateFormat transFormat = new SimpleDateFormat("yyyyMMddkkmm");
 393         tokenInfo.setIssuedtime(transFormat.format(currentTime));
 394         return tokenInfo;
 395     }
 396
 397     private UserTable makeUserTable() {
 398         UserTable userInfo = new UserTable();
 399         userInfo.setUuid(uuid);
 400         userInfo.setProvider(authProvider);
 401         userInfo.setUserid("userId");
 402         return userInfo;
 403     }
 404 }