service/notification/examples/android/NotiConsumerExample/app/src/androidTest/java/org/iotivity/service/ns/sample/consumer/ExampleUnitTest.java

   1 /*
   2 * Copyright 2016 Samsung Electronics All Rights Reserved.
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *      http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 package org.iotivity.service.ns.sample.consumer;
  18
  19 import android.app.Application;
  20 import android.content.Context;
  21 import android.support.test.runner.AndroidJUnit4;
  22 import android.test.ApplicationTestCase;
  23 import android.util.Log;
  24
  25 import org.iotivity.base.ModeType;
  26 import org.iotivity.base.OcPlatform;
  27 import org.iotivity.base.PlatformConfig;
  28 import org.iotivity.base.QualityOfService;
  29 import org.iotivity.base.ServiceType;
  30 import org.iotivity.service.ns.common.Message;
  31 import org.iotivity.service.ns.common.NSException;
  32 import org.iotivity.service.ns.common.NSErrorCode;
  33 import org.iotivity.service.ns.common.Topic;
  34 import org.iotivity.service.ns.common.TopicsList;
  35 import org.iotivity.service.ns.common.SyncInfo;
  36 import org.iotivity.service.ns.consumer.ConsumerService;
  37 import org.iotivity.service.ns.provider.ProviderService;
  38 import org.iotivity.service.ns.consumer.Provider;
  39
  40 import org.junit.After;
  41 import org.junit.Before;
  42 import org.junit.BeforeClass;
  43 import org.junit.Test;
  44 import org.junit.runner.RunWith;
  45
  46 import java.util.Iterator;
  47 import java.util.concurrent.CountDownLatch;
  48 import java.util.concurrent.TimeUnit;
  49
  50 /**
  51  * To work on unit tests, switch the Test Artifact in the Build Variants view.
  52  */
  53 @RunWith(AndroidJUnit4.class)
  54 public class ExampleUnitTest extends ApplicationTestCase<Application> {
  55     public ExampleUnitTest() {
  56         super(Application.class);
  57     }
  58
  59     private static Context                   mContext = null;
  60     private ProviderService                  gProviderRes;
  61     private ProviderSimulator                gProviderSimul;
  62     private static ConsumerService           gConsumerRes;
  63     private static DiscoveryCallbackListener disCb;
  64     private static ProviderCallbackListener  provCb;
  65     CountDownLatch                           lockObject;
  66     Response                                 response;
  67     private static String                    TAG      = "ConsumerExample UnitTest";
  68
  69     public void startBefore(boolean subControllability) {
  70         Log.i(TAG, "startConsumerBefore - IN");
  71         try {
  72             gConsumerRes.start(disCb);
  73             gProviderRes.start(gProviderSimul, gProviderSimul,
  74                     subControllability, "nothing", false);
  75             lockObject.await(4000, TimeUnit.MILLISECONDS);
  76         } catch (Exception e) {
  77             e.printStackTrace();
  78         }
  79         Log.i(TAG, "startConsumerBefore - OUT");
  80     }
  81
  82     public void startAfter(boolean subControllability) {
  83         Log.i(TAG, "startConsumerAfter - IN");
  84         try {
  85             gProviderRes.start(gProviderSimul, gProviderSimul,
  86                     subControllability, "nothing", false);
  87             gConsumerRes.start(disCb);
  88             lockObject.await(4000, TimeUnit.MILLISECONDS);
  89         } catch (Exception e) {
  90             e.printStackTrace();
  91         }
  92         Log.i(TAG, "startConsumerAfter - OUT");
  93     }
  94
  95     public void setListener(Provider mProvider) {
  96         try {
  97             mProvider.setListener(provCb, provCb, provCb);
  98         } catch (Exception e) {
  99             e.printStackTrace();
 100         }
 101     }
 102
 103     public void subscribe(Provider.ProviderState state) {
 104         lockObject = new CountDownLatch(1);
 105         response = new Response();
 106         provCb.set(lockObject, response);
 107         provCb.setState(state);
 108         Provider mProvider = disCb.getProvider();
 109         setListener(mProvider);
 110         try {
 111             if (!mProvider.isSubscribed()) {
 112                 Log.i(TAG, "not subscribed");
 113                 mProvider.subscribe();
 114             }
 115             lockObject.await(4000, TimeUnit.MILLISECONDS);
 116         } catch (Exception e) {
 117             e.printStackTrace();
 118         }
 119     }
 120     public void unsubscribe() {
 121         lockObject = new CountDownLatch(1);
 122         response = new Response();
 123         provCb.set(lockObject, response);
 124         provCb.setState(Provider.ProviderState.STOPPED);
 125         Provider mProvider = disCb.getProvider();
 126         setListener(mProvider);
 127         try {
 128             if (mProvider.isSubscribed()) {
 129                 Log.i(TAG, "subscribed");
 130                 mProvider.unsubscribe();
 131             }
 132             lockObject.await(4000, TimeUnit.MILLISECONDS);
 133         } catch (Exception e) {
 134             e.printStackTrace();
 135         }
 136     }
 137
 138     public long sendMessage() {
 139         lockObject = new CountDownLatch(1);
 140         response = new Response();
 141         provCb.set(lockObject, response);
 142         org.iotivity.service.ns.common.Message msg = gProviderSimul
 143                 .getMessage();
 144         long Id = msg.getMessageId();
 145         provCb.setId(Id);
 146         try {
 147             gProviderRes.sendMessage(msg);
 148             lockObject.await(4000, TimeUnit.MILLISECONDS);
 149         } catch (Exception e) {
 150             e.printStackTrace();
 151         }
 152         return Id;
 153     }
 154
 155     public void sendSyncInfo(long id, SyncInfo.SyncType type) {
 156         try {
 157             lockObject = new CountDownLatch(1);
 158             response = new Response();
 159             provCb.set(lockObject, response);
 160             provCb.setType(type);
 161             gProviderRes.sendSyncInfo(id, type);
 162             lockObject.await(4000, TimeUnit.MILLISECONDS);
 163         } catch (Exception e) {
 164             e.printStackTrace();
 165         }
 166     }
 167
 168     public void providerSendSyncInfo(Provider provider, long id,
 169             SyncInfo.SyncType type) {
 170         try {
 171             lockObject = new CountDownLatch(1);
 172             response = new Response();
 173             provCb.set(lockObject, response);
 174             provCb.setType(type);
 175             provider.sendSyncInfo(id, type);
 176             lockObject.await(4000, TimeUnit.MILLISECONDS);
 177         } catch (Exception e) {
 178             e.printStackTrace();
 179         }
 180     }
 181
 182     public void registerTopic(String topic) {
 183         lockObject = new CountDownLatch(1);
 184         response = new Response();
 185         provCb.set(lockObject, response);
 186         provCb.setState(Provider.ProviderState.TOPIC);
 187         try {
 188             gProviderRes.registerTopic(topic);
 189             lockObject.await(4000, TimeUnit.MILLISECONDS);
 190         } catch (Exception e) {
 191             e.printStackTrace();
 192         }
 193     }
 194
 195     @BeforeClass
 196     public static void Initialize() {
 197         PlatformConfig platformConfig = new PlatformConfig(mContext,
 198                 ServiceType.IN_PROC, ModeType.CLIENT_SERVER, "0.0.0.0",
 199                 0, // Uses randomly available port
 200                 QualityOfService.LOW);
 201
 202         OcPlatform.Configure(platformConfig);
 203         try {
 204             OcPlatform.stopPresence(); // Initialize OcPlatform
 205         } catch (Exception e) {
 206             e.printStackTrace();
 207         }
 208     }
 209
 210     @Before
 211     public void SetUp() {
 212         Log.i(TAG, "SetUp - IN");
 213         disCb = new DiscoveryCallbackListener();
 214         provCb = new ProviderCallbackListener();
 215         gConsumerRes = ConsumerService.getInstance();
 216         gProviderRes = ProviderService.getInstance();
 217         gProviderSimul = new ProviderSimulator();
 218         lockObject = new CountDownLatch(1);
 219         response = new Response();
 220         disCb.set(lockObject, response);
 221         Log.i(TAG, "SetUp - OUT");
 222     }
 223
 224     @After
 225     public void TearDown() {
 226         Log.i(TAG, "TearDown - IN");
 227         try {
 228             gConsumerRes.stop();
 229             gProviderRes.stop();
 230             lockObject = new CountDownLatch(1);
 231             lockObject.await(2000, TimeUnit.MILLISECONDS);
 232         } catch (Exception e) {
 233             e.printStackTrace();
 234         }
 235         Log.i(TAG, "TearDown - OUT");
 236     }
 237
 238     @Test
 239     public void DiscoverProviderWithNonAccepterWhenStartedConsumerFirst() {
 240         startBefore(false);
 241         assertEquals(true, response.get());
 242     }
 243
 244     @Test
 245     public void DiscoverProviderWithNonAccepterWhenStartedConsumerAfter() {
 246         startAfter(false);
 247         assertEquals(true, response.get());
 248     }
 249
 250     @Test
 251     public void DiscoverProviderWithNonAccepterWhenRescan() {
 252         startAfter(false);
 253         assertEquals(true, response.get());
 254         try {
 255             gConsumerRes.rescanProvider();
 256         } catch (Exception e) {
 257             e.printStackTrace();
 258         }
 259         assertEquals(true, response.get());
 260     }
 261
 262     @Test
 263     public void ExpectSubscribeSuccess() {
 264         startAfter(false);
 265         assertEquals(true, response.get());
 266
 267         Provider.ProviderState state = Provider.ProviderState.ALLOW;
 268         subscribe(state);
 269         assertEquals(true, response.get());
 270     }
 271     @Test
 272     public void ExpectUnSubscribeSuccess() {
 273         startAfter(false);
 274         assertEquals(true, response.get());
 275
 276         Provider.ProviderState state = Provider.ProviderState.ALLOW;
 277         subscribe(state);
 278         assertEquals(true, response.get());
 279         unsubscribe();
 280         assertEquals(true, response.get());
 281     }
 282     @Test
 283     public void ExpectReceiveNotification() {
 284         startAfter(false);
 285         assertEquals(true, response.get());
 286
 287         Provider.ProviderState state = Provider.ProviderState.ALLOW;
 288         subscribe(state);
 289         assertEquals(true, response.get());
 290
 291         sendMessage();
 292         assertEquals(true, response.get());
 293
 294     }
 295
 296     @Test
 297     public void DiscoverProviderWithAccepterisProvider() {
 298         startAfter(true);
 299         assertEquals(true, response.get());
 300     }
 301
 302     @Test
 303     public void ExpectReceiveNotificationWithAccepterisProvider() {
 304         startAfter(true);
 305         assertEquals(true, response.get());
 306
 307         Provider mProvider = disCb.getProvider();
 308         setListener(mProvider);
 309
 310         sendMessage();
 311         assertEquals(true, response.get());
 312     }
 313
 314     @Test
 315     public void ExpectCallbackReadCheckWhenProviderNotifySync() {
 316         startAfter(true);
 317         assertEquals(true, response.get());
 318
 319         Provider mProvider = disCb.getProvider();
 320         setListener(mProvider);
 321
 322         long id = sendMessage();
 323         assertEquals(true, response.get());
 324
 325         sendSyncInfo(id, SyncInfo.SyncType.READ);
 326         assertEquals(true, response.get());
 327     }
 328
 329     @Test
 330     public void ExpectCallbackDismissCheckWhenProviderNotifySync() {
 331         startAfter(true);
 332         assertEquals(true, response.get());
 333
 334         Provider mProvider = disCb.getProvider();
 335         setListener(mProvider);
 336
 337         long id = sendMessage();
 338         assertEquals(true, response.get());
 339
 340         sendSyncInfo(id, SyncInfo.SyncType.DELETED);
 341         assertEquals(true, response.get());
 342     }
 343
 344     @Test
 345     public void ExpectCallbackReadCheckWhenConsumerPostSync() {
 346         startAfter(true);
 347         assertEquals(true, response.get());
 348
 349         Provider mProvider = disCb.getProvider();
 350         setListener(mProvider);
 351
 352         long id = sendMessage();
 353         assertEquals(true, response.get());
 354
 355         providerSendSyncInfo(mProvider, id, SyncInfo.SyncType.READ);
 356         assertEquals(true, response.get());
 357     }
 358
 359     @Test
 360     public void ExpectCallbackDismissCheckWhenConsumerPostSync() {
 361         startAfter(true);
 362         assertEquals(true, response.get());
 363
 364         Provider mProvider = disCb.getProvider();
 365         setListener(mProvider);
 366
 367         long id = sendMessage();
 368         assertEquals(true, response.get());
 369
 370         providerSendSyncInfo(mProvider, id, SyncInfo.SyncType.DELETED);
 371         assertEquals(true, response.get());
 372     }
 373
 374     @Test
 375     public void ExpectCallbackTopicUpdated() {
 376         startAfter(true);
 377         assertEquals(true, response.get());
 378
 379         Provider mProvider = disCb.getProvider();
 380         setListener(mProvider);
 381
 382         registerTopic("OIC_TOPIC1");
 383         assertEquals(true, response.get());
 384     }
 385
 386     @Test
 387     public void ExpectEQTopicList() {
 388         startAfter(true);
 389         assertEquals(true, response.get());
 390
 391         Provider mProvider = disCb.getProvider();
 392         setListener(mProvider);
 393
 394         try {
 395             registerTopic("OIC_TOPIC1");
 396             assertEquals(true, response.get());
 397             registerTopic("OIC_TOPIC2");
 398             assertEquals(true, response.get());
 399             registerTopic("OIC_TOPIC3");
 400             assertEquals(true, response.get());
 401
 402             response = new Response();
 403             Iterator<Topic> it = mProvider.getTopicList().getTopicsList()
 404                     .iterator();
 405             Iterator<Topic> it2 = gProviderRes.getRegisteredTopicList()
 406                     .getTopicsList().iterator();
 407             while (it.hasNext()) {
 408                 Topic element = it.next();
 409                 Topic element2 = it2.next();
 410                 Log.i(TAG, element2.getTopicName());
 411                 if (!element.getTopicName().equals(element2.getTopicName())) {
 412                     response.set(false);
 413                     break;
 414                 }
 415                 response.set(true);
 416             }
 417         } catch (Exception e) {
 418             e.printStackTrace();
 419         }
 420         assertEquals(true, response.get());
 421     }
 422
 423     @Test
 424     public void ExpectFailUpdateTopicOnConsumer() {
 425         startAfter(true);
 426         assertEquals(true, response.get());
 427
 428         Provider mProvider = disCb.getProvider();
 429         setListener(mProvider);
 430
 431         registerTopic("OIC_TOPIC1");
 432         assertEquals(true, response.get());
 433
 434         try {
 435             TopicsList list = mProvider.getTopicList();
 436             Iterator<Topic> it = list.getTopicsList().iterator();
 437             while (it.hasNext()) {
 438                 Topic element = it.next();
 439                 element.setState(Topic.TopicState.SUBSCRIBED);
 440             }
 441             mProvider.updateTopicList(list);
 442         } catch (NSException e) {
 443             e.printStackTrace();
 444             assertEquals(NSErrorCode.ERROR, e.getErrorCode());
 445         }
 446     }
 447
 448     @Test
 449     public void ExpectCallbackStoppedProvider() {
 450         startAfter(true);
 451         assertEquals(true, response.get());
 452
 453         Provider mProvider = disCb.getProvider();
 454         setListener(mProvider);
 455
 456         lockObject = new CountDownLatch(1);
 457         response = new Response();
 458         provCb.set(lockObject, response);
 459         provCb.setState(Provider.ProviderState.STOPPED);
 460
 461         try {
 462             gProviderRes.stop();
 463             lockObject.await(4000, TimeUnit.MILLISECONDS);
 464         } catch (Exception e) {
 465             e.printStackTrace();
 466         }
 467
 468         assertEquals(true, response.get());
 469
 470     }
 471 }
 472
 473 class DiscoveryCallbackListener
 474         implements ConsumerService.OnProviderDiscoveredListener {
 475     private CountDownLatch mLockObject;
 476     private Response       mResponse;
 477     private Provider       mProvider;
 478     private static String  TAG = "UnitTest DiscoveryCallbackListener";
 479
 480     public void set(CountDownLatch lockObject, Response response) {
 481         mLockObject = lockObject;
 482         mResponse = response;
 483     }
 484
 485     public Provider getProvider() {
 486         return mProvider;
 487     }
 488
 489     @Override
 490     public void onProviderDiscovered(Provider provider) {
 491         Log.i(TAG, provider.getProviderId());
 492         mProvider = provider;
 493         if (mResponse != null) {
 494             Log.i(TAG, "onProviderDiscovered: Lock released");
 495             mResponse.set(true);
 496             mLockObject.countDown();
 497         }
 498     }
 499 }
 500
 501 class ProviderCallbackListener implements Provider.OnProviderStateListener,
 502         Provider.OnMessageReceivedListener, Provider.OnSyncInfoReceivedListener {
 503
 504     private CountDownLatch         mLockObject;
 505     private Response               mResponse;
 506     private Provider.ProviderState mState;
 507     private SyncInfo.SyncType      mType;
 508     private long                   mId;
 509     private static String          TAG = "UnitTest ProviderCallbackListener";
 510
 511     public void set(CountDownLatch lockObject, Response response) {
 512         mLockObject = lockObject;
 513         mResponse = response;
 514     }
 515
 516     public void setState(Provider.ProviderState state) {
 517         mState = state;
 518     }
 519
 520     public void setId(long id) {
 521         mId = id;
 522     }
 523
 524     void setType(SyncInfo.SyncType type) {
 525         mType = type;
 526     }
 527
 528     @Override
 529     public void onProviderStateReceived(Provider.ProviderState state) {
 530         Log.i(TAG, "onProviderStateReceived: " + state);
 531         if (mState == state) {
 532             Log.i(TAG, "onProviderStateReceived: Lock released");
 533             mResponse.set(true);
 534             mLockObject.countDown();
 535         }
 536
 537     }
 538
 539     @Override
 540     public void onMessageReceived(org.iotivity.service.ns.common.Message msg) {
 541         Log.i(TAG, "onMessageReceived: " + msg.getMessageId());
 542         if (mId == msg.getMessageId()) {
 543             Log.i(TAG, "onMessageReceived: Lock released");
 544             mResponse.set(true);
 545             mLockObject.countDown();
 546         }
 547     }
 548
 549     @Override
 550     public void onSyncInfoReceived(SyncInfo syncInfo) {
 551         Log.i(TAG, "onSyncInfoReceived: " + syncInfo.getState());
 552         if (mType == syncInfo.getState()) {
 553             Log.i(TAG, "onSyncInfoReceived: Lock released");
 554             mResponse.set(true);
 555             mLockObject.countDown();
 556         }
 557     }
 558 }
 559
 560 class Response {
 561     private boolean state;
 562
 563     Response() {
 564         state = false;
 565     }
 566
 567     public void set(boolean val) {
 568         state = val;
 569     }
 570
 571     public boolean get() {
 572         return state;
 573     }
 574 }