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
  27 import java.text.DateFormat;
  28 import java.text.SimpleDateFormat;
  29 import java.util.Date;
  30 import java.util.HashMap;
  31 import java.util.concurrent.CountDownLatch;
  32
  33 import org.iotivity.cloud.accountserver.Constants;
  34 import org.iotivity.cloud.accountserver.db.AccountDBManager;
  35 import org.iotivity.cloud.accountserver.db.MongoDB;
  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.device.CoapDevice;
  40 import org.iotivity.cloud.base.exception.ServerException;
  41 import org.iotivity.cloud.base.protocols.IRequest;
  42 import org.iotivity.cloud.base.protocols.IResponse;
  43 import org.iotivity.cloud.base.protocols.MessageBuilder;
  44 import org.iotivity.cloud.base.protocols.coap.CoapResponse;
  45 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  46 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
  47 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  48 import org.iotivity.cloud.util.Cbor;
  49 import org.junit.Before;
  50 import org.junit.Test;
  51 import org.mockito.Mockito;
  52 import org.mockito.MockitoAnnotations;
  53 import org.mockito.invocation.InvocationOnMock;
  54 import org.mockito.stubbing.Answer;
  55
  56 public class SessionResourceTest {
  57     private static final String            DEFAULT_AUTH_LOGIN        = "/.well-known/ocf/account/session";
  58     private static final String            DEFAULT_AUTH_LOGOUT       = "/.well-known/ocf/account/session";
  59     private static final String            DEVICE_ID                 = "d0001";
  60     private static final String            ACCESS_TOKEN              = "5f5536c896da7dd437316585b86ef9dd03441c40";
  61     private static final String            REFRESH_TOKEN             = "rt0001";
  62     private static final String            USER_UUID                 = "bc38f243-aab5-44d3-8eb9-4a54ebbaf359";
  63     private static final String            AUTH_PROVIDER             = "Github";
  64     private TypeCastingManager<UserTable>  mUserTableCastingManager  = new TypeCastingManager<>();
  65     private TypeCastingManager<TokenTable> mTokenTableCastingManager = new TypeCastingManager<>();
  66     private CountDownLatch                 mLatch                    = new CountDownLatch(
  67             1);
  68     private CoapDevice                     mMockDevice               = Mockito
  69             .mock(CoapDevice.class);
  70     private Cbor<HashMap<String, Object>>  mCbor                     = new Cbor<>();
  71     private IResponse                      mResponse                 = null;
  72     private SessionResource                mSessionResource          = new SessionResource();
  73
  74     @Before
  75     public void setUp() throws Exception {
  76         MockitoAnnotations.initMocks(this);
  77         // reset data base
  78         resetDB();
  79         // register the token table and user table to the DB
  80         HashMap<String, Object> tokenInfo = mTokenTableCastingManager
  81                 .convertObjectToMap(makeTokenTable());
  82         HashMap<String, Object> userInfo = mUserTableCastingManager
  83                 .convertObjectToMap(makeUserTable());
  84         AccountDBManager.getInstance()
  85                 .insertAndReplaceRecord(Constants.TOKEN_TABLE, tokenInfo);
  86         AccountDBManager.getInstance().insertRecord(Constants.USER_TABLE,
  87                 userInfo);
  88         // response handler mock
  89         Mockito.doAnswer(new Answer<Object>() {
  90             @Override
  91             public CoapResponse answer(InvocationOnMock invocation)
  92                     throws Throwable {
  93
  94                 Object[] args = invocation.getArguments();
  95                 CoapResponse resp = (CoapResponse) args[0];
  96                 System.out.println(
  97                         "\t----------payload : " + resp.getPayloadString());
  98                 System.out.println("\t---------method : " + resp.getStatus());
  99                 mResponse = resp;
 100                 mLatch.countDown();
 101                 return null;
 102             }
 103         }).when(mMockDevice).sendResponse(Mockito.anyObject());
 104     }
 105
 106     @Test
 107     public void testSignInOnDefaultRequestReceived() throws Exception {
 108         getTestMethodName();
 109         SignIn(DEVICE_ID, ACCESS_TOKEN);
 110         assertTrue(hashmapCheck(mResponse, "expiresin"));
 111         assertTrue(methodCheck(mResponse, ResponseStatus.CHANGED));
 112     }
 113
 114     @Test(expected = ServerException.UnAuthorizedException.class)
 115     public void testSignInExpiredTokenOnDefaultRequestReceived()
 116             throws Exception {
 117         getTestMethodName();
 118         TokenTable tokenTable = makeTokenTable();
 119         tokenTable.setExpiredtime(0);
 120         HashMap<String, Object> tokenInfo = mTokenTableCastingManager
 121                 .convertObjectToMap(tokenTable);
 122         Thread.sleep(500);
 123         AccountDBManager.getInstance()
 124                 .insertAndReplaceRecord(Constants.TOKEN_TABLE, tokenInfo);
 125         SignIn(DEVICE_ID, ACCESS_TOKEN);
 126     }
 127
 128     @Test(expected = ServerException.BadRequestException.class)
 129     public void testSignInWithInvalidMethodOnDefaultRequestReceived()
 130             throws Exception {
 131         getTestMethodName();
 132         SignInWithInvalidMethod(DEVICE_ID, ACCESS_TOKEN);
 133     }
 134
 135     @Test(expected = ServerException.UnAuthorizedException.class)
 136     public void testWrongAccessTokenSignInOnDefaultRequestReceived()
 137             throws Exception {
 138         getTestMethodName();
 139         String accessTokenNotStored = "5689c70ffa245effc563017fee36d250";
 140         // sign in request
 141         SignIn(DEVICE_ID, accessTokenNotStored);
 142     }
 143
 144     @Test(expected = ServerException.UnAuthorizedException.class)
 145     public void testInvalidDeviceIdSignInOnDefaultRequestReceived()
 146             throws Exception {
 147         getTestMethodName();
 148         String diNotStored = "F371C481-38E6-4D47-8320-7688D8A5B58C";
 149         SignIn(diNotStored, ACCESS_TOKEN);
 150     }
 151
 152     @Test
 153     public void testSignOutOnDefaultRequestReceived() throws Exception {
 154         getTestMethodName();
 155         SignOut(DEVICE_ID, ACCESS_TOKEN);
 156         assertTrue(methodCheck(mResponse, ResponseStatus.CHANGED));
 157     }
 158
 159     public void getTestMethodName() {
 160         StackTraceElement[] stacks = new Throwable().getStackTrace();
 161         StackTraceElement currentStack = stacks[1];
 162         System.out.println("\t---Test Name : " + currentStack.getMethodName());
 163     }
 164
 165     @Test(expected = ServerException.BadRequestException.class)
 166     public void testSignInWithNullPayloadOnDefaultRequestReceived()
 167             throws Exception {
 168         getTestMethodName();
 169         SignInWithNullPayload();
 170     }
 171
 172     @Test(expected = ServerException.BadRequestException.class)
 173     public void testSignOutWithNullPayloadOnDefaultRequestReceived()
 174             throws Exception {
 175         getTestMethodName();
 176         SignOutWithNullPayload();
 177     }
 178
 179     @Test(expected = ServerException.PreconditionFailedException.class)
 180     public void testSignInWithBlankHashMapPayloadOnDefaultRequestReceived()
 181             throws Exception {
 182         getTestMethodName();
 183         SignInWithBlankHashMapPayload();
 184     }
 185
 186     @Test(expected = ServerException.PreconditionFailedException.class)
 187     public void testSignOutWithBlankHashMapPayloadOnDefaultRequestReceived()
 188             throws Exception {
 189         getTestMethodName();
 190         SignOutWithBlankHashMapPayload();
 191     }
 192
 193     private void SignInWithInvalidMethod(String di, String accessToken)
 194             throws Exception {
 195         System.out.println("-----Sign In With Invalid Method (GET)");
 196         IRequest request = null;
 197         request = SignInWithInvalidMethodRequest(di, accessToken);
 198         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 199     }
 200
 201     private void SignIn(String di, String accessToken) throws Exception {
 202         System.out.println("-----Sign In");
 203         IRequest request = null;
 204         request = SignInRequest(di, accessToken);
 205         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 206     }
 207
 208     private void SignInWithBlankHashMapPayload() throws Exception {
 209         System.out.println("-----Sign In With Blank Hashmap Payload");
 210         IRequest request = null;
 211         request = SignInBlankHashmapPayloadRequest();
 212         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 213     }
 214
 215     private void SignInWithNullPayload() throws Exception {
 216         System.out.println("-----Sign In With Null Payload");
 217         IRequest request = null;
 218         request = SignInNullPayloadRequest();
 219         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 220     }
 221
 222     private void SignOut(String di, String accessToken) throws Exception {
 223         System.out.println("-----Sign Out");
 224         IRequest request = null;
 225         request = SignOutRequest(di, accessToken);
 226         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 227     }
 228
 229     private void SignOutWithBlankHashMapPayload() throws Exception {
 230         System.out.println("-----Sign Out With Blank Hashmap Payload");
 231         IRequest request = null;
 232         request = SignOutBlankHashmapPayloadRequest();
 233         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 234     }
 235
 236     private void SignOutWithNullPayload() throws Exception {
 237         System.out.println("-----Sign Out With Null Payload");
 238         IRequest request = null;
 239         request = SignOutNullPayloadRequest();
 240         mSessionResource.onDefaultRequestReceived(mMockDevice, request);
 241     }
 242
 243     private IRequest SignInNullPayloadRequest() {
 244         IRequest request = null;
 245         request = MessageBuilder.createRequest(RequestMethod.POST,
 246                 DEFAULT_AUTH_LOGIN, null);
 247         return request;
 248     }
 249
 250     private IRequest SignInBlankHashmapPayloadRequest() {
 251         IRequest request = null;
 252         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 253         request = MessageBuilder.createRequest(RequestMethod.POST,
 254                 DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
 255                 mCbor.encodingPayloadToCbor(payloadData));
 256         return request;
 257     }
 258
 259     private IRequest SignOutNullPayloadRequest() {
 260         IRequest request = null;
 261         request = MessageBuilder.createRequest(RequestMethod.POST,
 262                 DEFAULT_AUTH_LOGOUT, null);
 263         return request;
 264     }
 265
 266     private IRequest SignOutBlankHashmapPayloadRequest() {
 267         IRequest request = null;
 268         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 269         request = MessageBuilder.createRequest(RequestMethod.POST,
 270                 DEFAULT_AUTH_LOGOUT, null, ContentFormat.APPLICATION_CBOR,
 271                 mCbor.encodingPayloadToCbor(payloadData));
 272         return request;
 273     }
 274
 275     private IRequest SignInWithInvalidMethodRequest(String deviceId,
 276             String accessToken) {
 277         IRequest request = null;
 278         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 279         payloadData.put("accesstoken", accessToken);
 280         payloadData.put("status", true);
 281         payloadData.put("di", deviceId);
 282         request = MessageBuilder.createRequest(RequestMethod.GET,
 283                 DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
 284                 mCbor.encodingPayloadToCbor(payloadData));
 285         return request;
 286     }
 287
 288     private IRequest SignInRequest(String deviceId, String accessToken) {
 289         IRequest request = null;
 290         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 291         payloadData.put("accesstoken", accessToken);
 292         payloadData.put("login", true);
 293         payloadData.put("di", deviceId);
 294         payloadData.put("uid", USER_UUID);
 295         request = MessageBuilder.createRequest(RequestMethod.POST,
 296                 DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
 297                 mCbor.encodingPayloadToCbor(payloadData));
 298         return request;
 299     }
 300
 301     private IRequest SignOutRequest(String deviceId, String accessToken) {
 302         IRequest request = null;
 303         HashMap<String, Object> payloadData = new HashMap<String, Object>();
 304         payloadData.put("accesstoken", accessToken);
 305         payloadData.put("login", false);
 306         payloadData.put("di", deviceId);
 307         payloadData.put("uid", USER_UUID);
 308         request = MessageBuilder.createRequest(RequestMethod.POST,
 309                 DEFAULT_AUTH_LOGOUT, null, ContentFormat.APPLICATION_CBOR,
 310                 mCbor.encodingPayloadToCbor(payloadData));
 311         return request;
 312     }
 313
 314     private boolean hashmapCheck(IResponse response, String propertyName) {
 315         HashMap<String, Object> payloadData = mCbor
 316                 .parsePayloadFromCbor(response.getPayload(), HashMap.class);
 317         if (payloadData.get(propertyName) != null)
 318             return true;
 319         else
 320             return false;
 321     }
 322
 323     private boolean methodCheck(IResponse response,
 324             ResponseStatus responseStatus) {
 325         if (responseStatus == response.getStatus())
 326             return true;
 327         else
 328             return false;
 329     }
 330
 331     private TokenTable makeTokenTable() {
 332         TokenTable tokenInfo = new TokenTable();
 333         tokenInfo.setUuid(USER_UUID);
 334         tokenInfo.setDid(DEVICE_ID);
 335         tokenInfo.setAccesstoken(ACCESS_TOKEN);
 336         tokenInfo.setRefreshtoken(REFRESH_TOKEN);
 337         tokenInfo.setProvider(AUTH_PROVIDER);
 338         tokenInfo.setExpiredtime(-1);
 339         Date currentTime = new Date();
 340         DateFormat transFormat = new SimpleDateFormat("yyyyMMddkkmm");
 341         tokenInfo.setIssuedtime(transFormat.format(currentTime));
 342         return tokenInfo;
 343     }
 344
 345     private UserTable makeUserTable() {
 346         UserTable userInfo = new UserTable();
 347         userInfo.setUuid(USER_UUID);
 348         userInfo.setProvider(AUTH_PROVIDER);
 349         userInfo.setUserid("userId");
 350         return userInfo;
 351     }
 352
 353     private void resetDB() throws Exception {
 354         MongoDB mongoDB = new MongoDB(Constants.DB_NAME);
 355         mongoDB.deleteTable(Constants.GROUP_TABLE);
 356         mongoDB.createTable(Constants.GROUP_TABLE);
 357         mongoDB.deleteTable(Constants.USER_TABLE);
 358         mongoDB.createTable(Constants.USER_TABLE);
 359         mongoDB.deleteTable(Constants.TOKEN_TABLE);
 360         mongoDB.createTable(Constants.TOKEN_TABLE);
 361     }
 362 }