-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <groupId>org.iotivity.cloud</groupId>
- <artifactId>CloudAccount</artifactId>
- <version>0.0.1-SNAPSHOT</version>
-
- <properties>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.iotivity.cloud</groupId>
+ <artifactId>CloudAccount</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+
+ <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.test.skip>true</maven.test.skip>
</properties>
-
- <dependencies>
- <dependency>
+
+ <dependencies>
+ <dependency>
<groupId>org.iotivity.cloud</groupId>
<artifactId>CloudStack</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
- <dependency>
- <groupId>org.mongodb</groupId>
- <artifactId>mongo-java-driver</artifactId>
- <version>3.2.0</version>
- </dependency>
- <dependency>
- <groupId>org.apache.oltu.oauth2</groupId>
- <artifactId>org.apache.oltu.oauth2.client</artifactId>
- <version>1.0.1</version>
- </dependency>
- <dependency>
- <groupId>org.apache.oltu.oauth2</groupId>
- <artifactId>
+ <dependency>
+ <groupId>org.mongodb</groupId>
+ <artifactId>mongo-java-driver</artifactId>
+ <version>3.2.0</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.oltu.oauth2</groupId>
+ <artifactId>org.apache.oltu.oauth2.client</artifactId>
+ <version>1.0.1</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.oltu.oauth2</groupId>
+ <artifactId>
org.apache.oltu.oauth2.common
</artifactId>
- <version>1.0.1</version>
- </dependency>
- <dependency>
- <groupId>org.apache.oltu.oauth2</groupId>
- <artifactId>
+ <version>1.0.1</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.oltu.oauth2</groupId>
+ <artifactId>
org.apache.oltu.oauth2.authzserver
</artifactId>
- <version>1.0.1</version>
- </dependency>
- <dependency>
+ <version>1.0.1</version>
+ </dependency>
+ <dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<artifactId>awaitility</artifactId>
<version>1.7.0</version>
</dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-api-mockito</artifactId>
+ <version>1.6.5</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-core</artifactId>
+ <version>1.6.5</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-module-junit4</artifactId>
+ <version>1.6.5</version>
+ <scope>test</scope>
+ </dependency>
<!-- For security tasks(certificates, signature, keystore) -->
<dependency>
</dependency>
<!-- For security tasks(certificates, signature, keystore) -->
- </dependencies>
-
- <build>
+ </dependencies>
+
+ <build>
<plugins>
<plugin>
<inherited>true</inherited>
<overWriteIfNewer>true</overWriteIfNewer>
</configuration>
</plugin>
- </plugins>
+ </plugins>
</build>
-
+
</project>
\ No newline at end of file
--- /dev/null
+/*
+ * //******************************************************************
+ * //
+ * // Copyright 2016 Samsung Electronics All Rights Reserved.
+ * //
+ * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+ * //
+ * // Licensed under the Apache License, Version 2.0 (the "License");
+ * // you may not use this file except in compliance with the License.
+ * // You may obtain a copy of the License at
+ * //
+ * // http://www.apache.org/licenses/LICENSE-2.0
+ * //
+ * // Unless required by applicable law or agreed to in writing, software
+ * // distributed under the License is distributed on an "AS IS" BASIS,
+ * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * // See the License for the specific language governing permissions and
+ * // limitations under the License.
+ * //
+ * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+ */
+
+package org.iotivity.cloud.accountserver.resources.account;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.concurrent.CountDownLatch;
+
+import org.iotivity.cloud.accountserver.Constants;
+import org.iotivity.cloud.accountserver.db.AccountDBManager;
+import org.iotivity.cloud.accountserver.db.TokenTable;
+import org.iotivity.cloud.accountserver.db.UserTable;
+import org.iotivity.cloud.accountserver.resources.acl.group.GroupResource;
+import org.iotivity.cloud.accountserver.util.TypeCastingManager;
+import org.iotivity.cloud.base.ServerSystem;
+import org.iotivity.cloud.base.ServerSystem.PersistentPacketReceiver;
+import org.iotivity.cloud.base.device.CoapDevice;
+import org.iotivity.cloud.base.device.Device;
+import org.iotivity.cloud.base.protocols.IRequest;
+import org.iotivity.cloud.base.protocols.IResponse;
+import org.iotivity.cloud.base.protocols.MessageBuilder;
+import org.iotivity.cloud.base.protocols.coap.CoapResponse;
+import org.iotivity.cloud.base.protocols.enums.ContentFormat;
+import org.iotivity.cloud.base.protocols.enums.RequestMethod;
+import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
+import org.iotivity.cloud.util.Cbor;
+import org.iotivity.cloud.util.Log;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelId;
+import io.netty.util.Attribute;
+
+public class AccountResourceTest {
+ private static final String REGISTER_URI = "/.well-known/ocf/account";
+ private static final String GROUP_URI = "/.well-known/ocf/acl/group";
+ private String di = "B371C481-38E6-4D47-8320-7688D8A5B58C";
+ private String authProvider = "Github";
+ private String authCode = "7af49183966f84e553dc";
+ String userId = "testuser";
+ private CoapDevice mockDevice = mock(
+ CoapDevice.class);
+ private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
+ IResponse res = null;
+ ServerSystem serverSystem = new ServerSystem();
+ final CountDownLatch latch = new CountDownLatch(
+ 1);
+ private TypeCastingManager<UserTable> mUserTableCastingManager = new TypeCastingManager<>();
+ private TypeCastingManager<TokenTable> mTokenTableCastingManager = new TypeCastingManager<>();
+
+ @Mock
+ ChannelHandlerContext ctx;
+
+ @InjectMocks
+ PersistentPacketReceiver receiver = serverSystem.new PersistentPacketReceiver();
+
+ @Before
+ public void setUp() throws Exception {
+ // create log file
+ Log.createfile();
+ // add resource
+ serverSystem.addResource(new AccountResource());
+ serverSystem.addResource(new GroupResource());
+ MockitoAnnotations.initMocks(this);
+ ChannelId channelId = mock(ChannelId.class);
+ // inject mocked coapDevice into the api
+ Channel channel = mock(Channel.class);
+ Attribute<Device> attribute = mock(Attribute.class);
+ Mockito.doReturn(channel).when(ctx).channel();
+ Mockito.doReturn(attribute).when(channel).attr(Mockito.any());
+ Mockito.doReturn(mockDevice).when(attribute).get();
+ Mockito.doReturn(channelId).when(channel).id();
+ Mockito.doReturn(
+ "0000000141f3edcfc2c3000000000001d0000000000000000000000000000000000000")
+ .when(channelId).asLongText();
+ Mockito.doAnswer(new Answer<Object>() {
+ @Override
+ public CoapResponse answer(InvocationOnMock invocation)
+ throws Throwable {
+ Object[] args = invocation.getArguments();
+ CoapResponse resp = (CoapResponse) args[0];
+ System.out.println(
+ "\t----Exception responsestatus : " + resp.getStatus());
+ res = resp;
+ latch.countDown();
+ return null;
+ }
+ }).when(channel).writeAndFlush(Mockito.any());
+ // callback mock
+ Mockito.doAnswer(new Answer<Object>() {
+ @Override
+ public CoapResponse answer(InvocationOnMock invocation)
+ throws Throwable {
+ Object[] args = invocation.getArguments();
+ CoapResponse resp = (CoapResponse) args[0];
+ System.out
+ .println("\t----payload : " + resp.getPayloadString());
+ System.out
+ .println("\t----responsestatus : " + resp.getStatus());
+ res = resp;
+ return resp;
+ }
+ }).when(mockDevice).sendResponse(Mockito.anyObject());
+ receiver.channelActive(ctx);
+ }
+
+ @After
+ public void end() throws Exception {
+ receiver.channelInactive(ctx);
+ }
+
+ @Test
+ public void testSignUpOnDefaultRequestReceived() throws Exception {
+ System.out.println("\t--------------Sign Up Test------------");
+ signUp(di, authProvider, authCode);
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ assertTrue(hashmapCheck(res, "accesstoken"));
+ assertTrue(hashmapCheck(res, "refreshtoken"));
+ assertTrue(hashmapCheck(res, "tokentype"));
+ assertTrue(hashmapCheck(res, "uid"));
+ }
+
+ @Test
+ public void testSignUpwithWrongAuthCodeOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Up with Wrong AuthCode Test------------");
+ String wrongAuthCode = "5fc4fcf376f8d7087a3a";
+ signUp(di, authProvider, wrongAuthCode);
+ assertTrue(methodCheck(res, ResponseStatus.INTERNAL_SERVER_ERROR));
+ }
+
+ @Test
+ public void testSignUpNullAuthProviderOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Up Null AuthProvider Test------------");
+ signUp(di, null, authCode);
+ assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
+ }
+
+ @Test
+ public void testSignUpNullAuthCodeOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Up with Null AuthCode Test------------");
+ signUp(di, authProvider, null);
+ assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
+ }
+
+ @Test
+ public void testSignUpNullDiOnDefaultRequestReceived() throws Exception {
+ System.out.println(
+ "\t--------------Sign Up with Null DeviceId Test------------");
+ signUp(null, authProvider, authCode);
+ assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
+ }
+
+ @Test
+ public void testSignUpInvalidMethodOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Up with Invalid Method (GET) Test------------");
+ signUpInvalidMethod(di, authProvider, authCode);
+ assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
+ }
+
+ @Test
+ public void testDeleteDeviceOnDefaultRequestReceived() throws Exception {
+ System.out.println(
+ "\t--------------Delete Device from all Groups Test------------");
+ // register the token table and user table to the DB
+ String uuid = "u0001";
+ HashMap<String, Object> tokenInfo = mTokenTableCastingManager
+ .convertObjectToMap(makeTokenTable(uuid));
+ HashMap<String, Object> userInfo = mUserTableCastingManager
+ .convertObjectToMap(makeUserTable(uuid));
+ AccountDBManager.getInstance()
+ .insertAndReplaceRecord(Constants.TOKEN_TABLE, tokenInfo);
+ AccountDBManager.getInstance().insertRecord(Constants.USER_TABLE,
+ userInfo);
+ createDefaultGroup(uuid);
+ shareDevice(ctx, di);
+ deleteDevice(di);
+ assertTrue(methodCheck(res, ResponseStatus.DELETED));
+ }
+
+ // @Test
+ public void testGetUserInfoUsingUuidOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Up with Invalid Method (GET) Test------------");
+ // register the token table and user table to the DB
+ String uuid = "u0001Get";
+ HashMap<String, Object> tokenInfo = mTokenTableCastingManager
+ .convertObjectToMap(makeTokenTable(uuid));
+ HashMap<String, Object> userInfo = mUserTableCastingManager
+ .convertObjectToMap(makeUserTable(uuid));
+ AccountDBManager.getInstance()
+ .insertAndReplaceRecord(Constants.TOKEN_TABLE, tokenInfo);
+ AccountDBManager.getInstance().insertRecord(Constants.USER_TABLE,
+ userInfo);
+ getUserInfoUsingUuid(uuid);
+ assertTrue(methodCheck(res, ResponseStatus.CONTENT));
+ }
+
+ public void getUserInfoUsingUuid(String uuid) throws Exception {
+ System.out.println("-----Get User Info : " + uuid);
+ IRequest request = null;
+ request = getUserInfoUsingUuidRequest(uuid);
+ receiver.channelRead(ctx, request);
+ }
+
+ public IRequest getUserInfoUsingUuidRequest(String uuid) {
+ IRequest request = MessageBuilder.createRequest(RequestMethod.GET,
+ REGISTER_URI, "uid=" + uuid);
+ return request;
+ }
+
+ public void createDefaultGroup(String uuid) throws Exception {
+ System.out.println("-----Create Default Group");
+ IRequest request = null;
+ request = createDefaultGroupRequest(uuid);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void deleteDevice(String di) throws Exception {
+ System.out.println("-----Delete Device");
+ IRequest request = null;
+ request = deleteDeviceRequest(di);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void signUp(String di, String authProvider, String authCode)
+ throws Exception {
+ System.out.println("-----Sign Up");
+ IRequest request = null;
+ request = signUpRequest(di, authProvider, authCode);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void signUpInvalidMethod(String di, String authProvider,
+ String authCode) throws Exception {
+ System.out.println("-----Sign Up Invalid RequestMethod");
+ IRequest request = null;
+ request = signUpInvalidMethodRequest(di, authProvider, authCode);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void shareDevice(ChannelHandlerContext ctx, String deviceId)
+ throws Exception {
+ System.out.println("-----Share Device");
+ IRequest request = null;
+ request = createShareDeviceRequest(deviceId);
+ receiver.channelRead(ctx, request);
+ }
+
+ public IRequest deleteDeviceRequest(String deviceId) {
+ IRequest request = MessageBuilder.createRequest(RequestMethod.DELETE,
+ REGISTER_URI, "di=" + deviceId + ";uid=u0001");
+ return request;
+ }
+
+ public IRequest createDefaultGroupRequest(String uuid) {
+ IRequest request = null;
+ HashMap<String, String> payloadData = new HashMap<String, String>();
+ payloadData.put("gmid", uuid);
+ payloadData.put("gtype", "Private");
+ Cbor<HashMap<String, String>> cbor = new Cbor<HashMap<String, String>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST, GROUP_URI,
+ null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest createShareDeviceRequest(String deviceId) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ ArrayList<String> diList = new ArrayList<>();
+ diList.add(deviceId);
+ payloadData.put("dilist", diList);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ GROUP_URI + "/" + "u0001", null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest signUpRequest(String deviceId, String authProvider,
+ String authCode) {
+ IRequest request = null;
+ HashMap<String, String> payloadData = new HashMap<String, String>();
+ payloadData.put("authcode", authCode);
+ payloadData.put("authprovider", authProvider);
+ payloadData.put("di", deviceId);
+ Cbor<HashMap<String, String>> cbor = new Cbor<HashMap<String, String>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST, REGISTER_URI,
+ null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest signUpInvalidMethodRequest(String deviceId,
+ String authProvider, String authCode) {
+ IRequest request = null;
+ HashMap<String, String> payloadData = new HashMap<String, String>();
+ payloadData.put("authcode", authCode);
+ payloadData.put("authprovider", authProvider);
+ payloadData.put("di", deviceId);
+ Cbor<HashMap<String, String>> cbor = new Cbor<HashMap<String, String>>();
+ request = MessageBuilder.createRequest(RequestMethod.GET, REGISTER_URI,
+ null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public boolean hashmapCheck(IResponse response, String propertyName) {
+ HashMap<String, Object> payloadData = mCbor
+ .parsePayloadFromCbor(response.getPayload(), HashMap.class);
+ if (payloadData.containsKey(propertyName))
+ return true;
+ else
+ return false;
+ }
+
+ public boolean methodCheck(IResponse response,
+ ResponseStatus responseStatus) {
+ if (responseStatus == response.getStatus())
+ return true;
+ else
+ return false;
+ }
+
+ private TokenTable makeTokenTable(String uuid) {
+ TokenTable tokenInfo = new TokenTable();
+ tokenInfo.setUuid(uuid);
+ tokenInfo.setDid(di);
+ tokenInfo.setAccesstoken("at0001");
+ tokenInfo.setRefreshtoken("rt0001");
+ tokenInfo.setProvider(authProvider);
+ tokenInfo.setExpiredtime(-1);
+ Date currentTime = new Date();
+ DateFormat transFormat = new SimpleDateFormat("yyyyMMddkkmm");
+ tokenInfo.setIssuedtime(transFormat.format(currentTime));
+ return tokenInfo;
+ }
+
+ private UserTable makeUserTable(String uuid) {
+ UserTable userInfo = new UserTable();
+ userInfo.setUuid(uuid);
+ userInfo.setProvider(authProvider);
+ userInfo.setUserid("userId");
+ return userInfo;
+ }
+
+}
--- /dev/null
+/*
+ * //******************************************************************
+ * //
+ * // Copyright 2016 Samsung Electronics All Rights Reserved.
+ * //
+ * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+ * //
+ * // Licensed under the Apache License, Version 2.0 (the "License");
+ * // you may not use this file except in compliance with the License.
+ * // You may obtain a copy of the License at
+ * //
+ * // http://www.apache.org/licenses/LICENSE-2.0
+ * //
+ * // Unless required by applicable law or agreed to in writing, software
+ * // distributed under the License is distributed on an "AS IS" BASIS,
+ * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * // See the License for the specific language governing permissions and
+ * // limitations under the License.
+ * //
+ * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+ */
+
+package org.iotivity.cloud.accountserver.resources.account.session;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.concurrent.CountDownLatch;
+
+import org.iotivity.cloud.accountserver.Constants;
+import org.iotivity.cloud.accountserver.db.AccountDBManager;
+import org.iotivity.cloud.accountserver.db.TokenTable;
+import org.iotivity.cloud.accountserver.db.UserTable;
+import org.iotivity.cloud.accountserver.util.TypeCastingManager;
+import org.iotivity.cloud.base.ServerSystem;
+import org.iotivity.cloud.base.ServerSystem.PersistentPacketReceiver;
+import org.iotivity.cloud.base.device.CoapDevice;
+import org.iotivity.cloud.base.device.Device;
+import org.iotivity.cloud.base.protocols.IRequest;
+import org.iotivity.cloud.base.protocols.IResponse;
+import org.iotivity.cloud.base.protocols.MessageBuilder;
+import org.iotivity.cloud.base.protocols.coap.CoapResponse;
+import org.iotivity.cloud.base.protocols.enums.ContentFormat;
+import org.iotivity.cloud.base.protocols.enums.RequestMethod;
+import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
+import org.iotivity.cloud.util.Cbor;
+import org.iotivity.cloud.util.Log;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelId;
+import io.netty.util.Attribute;
+
+public class SessionResourceTest {
+ private final String DEFAULT_AUTH_LOGIN = "/.well-known/ocf/account/session";
+ private final String DEFAULT_AUTH_LOGOUT = "/.well-known/ocf/account/session";
+ private String di = "d0001";
+ private String accessToken = "5f5536c896da7dd437316585b86ef9dd03441c40";
+ private String refreshToken = "rt0001";
+ private TypeCastingManager<UserTable> mUserTableCastingManager = new TypeCastingManager<>();
+ private TypeCastingManager<TokenTable> mTokenTableCastingManager = new TypeCastingManager<>();
+ ServerSystem serverSystem = new ServerSystem();
+ final CountDownLatch latch = new CountDownLatch(
+ 1);
+ private String uuid = "bc38f243-aab5-44d3-8eb9-4a54ebbaf359";
+ private String authProvider = "github";
+ private CoapDevice mockDevice = Mockito
+ .mock(CoapDevice.class);
+ private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
+ IResponse res = null;
+
+ @Mock
+ ChannelHandlerContext ctx;
+
+ @InjectMocks
+ PersistentPacketReceiver receiver = serverSystem.new PersistentPacketReceiver();
+
+ @Before
+ public void setUp() throws Exception {
+ // create log file
+ Log.createfile();
+ // add resource
+ serverSystem.addResource(new SessionResource());
+ MockitoAnnotations.initMocks(this);
+ ChannelId channelId = mock(ChannelId.class);
+ // inject mocked coapDevice into the api
+ Channel channel = mock(Channel.class);
+ Attribute<Device> attribute = mock(Attribute.class);
+ Mockito.doReturn(channel).when(ctx).channel();
+ Mockito.doReturn(attribute).when(channel).attr(Mockito.any());
+ Mockito.doReturn(mockDevice).when(attribute).get();
+ Mockito.doReturn(channelId).when(channel).id();
+ Mockito.doReturn(
+ "0000000141f3edcfc2c3000000000001d0000000000000000000000000000000000000")
+ .when(channelId).asLongText();
+ // register the token table and user table to the DB
+ HashMap<String, Object> tokenInfo = mTokenTableCastingManager
+ .convertObjectToMap(makeTokenTable());
+ HashMap<String, Object> userInfo = mUserTableCastingManager
+ .convertObjectToMap(makeUserTable());
+ AccountDBManager.getInstance()
+ .insertAndReplaceRecord(Constants.TOKEN_TABLE, tokenInfo);
+ AccountDBManager.getInstance().insertRecord(Constants.USER_TABLE,
+ userInfo);
+ // response handler mock
+ Mockito.doAnswer(new Answer<Object>() {
+ @Override
+ public CoapResponse answer(InvocationOnMock invocation)
+ throws Throwable {
+
+ Object[] args = invocation.getArguments();
+ CoapResponse resp = (CoapResponse) args[0];
+ System.out.println(
+ "\t----------payload : " + resp.getPayloadString());
+ System.out.println("\t---------method : " + resp.getMethod());
+ res = resp;
+ latch.countDown();
+ return resp;
+ }
+ }).when(mockDevice).sendResponse(Mockito.anyObject());
+ // exception handler mock
+ Mockito.doAnswer(new Answer<Object>() {
+ @Override
+ public CoapResponse answer(InvocationOnMock invocation)
+ throws Throwable {
+ Object[] args = invocation.getArguments();
+ CoapResponse resp = (CoapResponse) args[0];
+ System.out.println("\t----exception response status : "
+ + resp.getStatus());
+ res = resp;
+ latch.countDown();
+ return null;
+ }
+ }).when(channel).writeAndFlush(Mockito.any());
+ }
+
+ @After
+ public void endTest() {
+ AccountDBManager.getInstance().deleteRecord(Constants.TOKEN_TABLE,
+ mTokenTableCastingManager.convertObjectToMap(makeTokenTable()));
+ AccountDBManager.getInstance().deleteRecord(Constants.USER_TABLE,
+ mUserTableCastingManager.convertObjectToMap(makeUserTable()));
+ }
+
+ @Test
+ public void testSignInOnDefaultRequestReceived() throws Exception {
+ System.out.println("\t--------------Sign In Test------------");
+ SignIn(di, accessToken);
+ assertTrue(hashmapCheck(res, "expiresin"));
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ }
+
+ @Test
+ public void testSignInWithInvalidMethodOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign In With Invalid RequestMethod Test------------");
+ SignInWithInvalidMethod(di, accessToken);
+ assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
+ }
+
+ @Test
+ public void testWrongAccessTokenSignInOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Wrong AccessToken Sign In Test------------");
+ String accessTokenNotStored = "5689c70ffa245effc563017fee36d250";
+ // sign in request
+ SignIn(di, accessTokenNotStored);
+ assertTrue(methodCheck(res, ResponseStatus.UNAUTHORIZED));
+ }
+
+ @Test
+ public void testInvalidDeviceIdSignInOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Invalid DeviceId Sign In Test------------");
+ String diNotStored = "F371C481-38E6-4D47-8320-7688D8A5B58C";
+ SignIn(diNotStored, accessToken);
+ assertTrue(methodCheck(res, ResponseStatus.UNAUTHORIZED));
+ }
+
+ @Test
+ public void testSignOutOnDefaultRequestReceived() throws Exception {
+ System.out.println("\t--------------Sign Out Test------------");
+ SignOut(di, accessToken);
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ }
+
+ @Test
+ public void testSignInWithNullPayloadOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign In With Null Payload Test------------");
+ SignInWithNullPayload();
+ assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
+ }
+
+ @Test
+ public void testSignOutWithNullPayloadOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Out With Null Payload Test------------");
+ // sign out request
+ SignOutWithNullPayload();
+ assertTrue(methodCheck(res, ResponseStatus.BAD_REQUEST));
+ }
+
+ @Test
+ public void testSignInWithBlankHashMapPayloadOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign In With Blank HashMap Payload Test------------");
+ SignInWithBlankHashMapPayload();
+ assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
+ }
+
+ @Test
+ public void testSignOutWithBlankHashMapPayloadOnDefaultRequestReceived()
+ throws Exception {
+ System.out.println(
+ "\t--------------Sign Out With Blank HashMap Test------------");
+ SignOutWithBlankHashMapPayload();
+ assertTrue(methodCheck(res, ResponseStatus.PRECONDITION_FAILED));
+ }
+
+ public void SignInWithInvalidMethod(String di, String accessToken)
+ throws Exception {
+ System.out.println("-----Sign In With Invalid Method (GET)");
+ IRequest request = null;
+ request = SignInWithInvalidMethodRequest(di, accessToken);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void SignIn(String di, String accessToken) throws Exception {
+ System.out.println("-----Sign In");
+ IRequest request = null;
+ request = SignInRequest(di, accessToken);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void SignInWithBlankHashMapPayload() throws Exception {
+ System.out.println("-----Sign In With Blank Hashmap Payload");
+ IRequest request = null;
+ request = SignInBlankHashmapPayloadRequest();
+ receiver.channelRead(ctx, request);
+ }
+
+ public void SignInWithNullPayload() throws Exception {
+ System.out.println("-----Sign In With Null Payload");
+ IRequest request = null;
+ request = SignInNullPayloadRequest();
+ receiver.channelRead(ctx, request);
+ }
+
+ public void SignOut(String di, String accessToken) throws Exception {
+ System.out.println("-----Sign Out");
+ IRequest request = null;
+ request = SignOutRequest(di, accessToken);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void SignOutWithBlankHashMapPayload() throws Exception {
+ System.out.println("-----Sign Out With Blank Hashmap Payload");
+ IRequest request = null;
+ request = SignOutBlankHashmapPayloadRequest();
+ receiver.channelRead(ctx, request);
+ }
+
+ public void SignOutWithNullPayload() throws Exception {
+ System.out.println("-----Sign Out With Null Payload");
+ IRequest request = null;
+ request = SignOutNullPayloadRequest();
+ receiver.channelRead(ctx, request);
+ }
+
+ public IRequest SignInNullPayloadRequest() {
+ IRequest request = null;
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ DEFAULT_AUTH_LOGIN, null);
+ return request;
+ }
+
+ public IRequest SignInBlankHashmapPayloadRequest() {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest SignOutNullPayloadRequest() {
+ IRequest request = null;
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ DEFAULT_AUTH_LOGOUT, null);
+ return request;
+ }
+
+ public IRequest SignOutBlankHashmapPayloadRequest() {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ DEFAULT_AUTH_LOGOUT, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest SignInWithInvalidMethodRequest(String deviceId,
+ String accessToken) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ payloadData.put("accesstoken", accessToken);
+ payloadData.put("status", true);
+ payloadData.put("di", deviceId);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.GET,
+ DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest SignInRequest(String deviceId, String accessToken) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ payloadData.put("accesstoken", accessToken);
+ payloadData.put("login", true);
+ payloadData.put("di", deviceId);
+ payloadData.put("uid", uuid);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ DEFAULT_AUTH_LOGIN, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest SignOutRequest(String deviceId, String accessToken) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ payloadData.put("accesstoken", accessToken);
+ payloadData.put("login", false);
+ payloadData.put("di", deviceId);
+ payloadData.put("uid", uuid);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ DEFAULT_AUTH_LOGOUT, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public boolean hashmapCheck(IResponse response, String propertyName) {
+ HashMap<String, Object> payloadData = mCbor
+ .parsePayloadFromCbor(response.getPayload(), HashMap.class);
+ if (payloadData.get(propertyName) != null)
+ return true;
+ else
+ return false;
+ }
+
+ public boolean methodCheck(IResponse response,
+ ResponseStatus responseStatus) {
+ if (responseStatus == response.getStatus())
+ return true;
+ else
+ return false;
+ }
+
+ private TokenTable makeTokenTable() {
+ TokenTable tokenInfo = new TokenTable();
+ tokenInfo.setUuid(uuid);
+ tokenInfo.setDid(di);
+ tokenInfo.setAccesstoken(accessToken);
+ tokenInfo.setRefreshtoken(refreshToken);
+ tokenInfo.setProvider(authProvider);
+ tokenInfo.setExpiredtime(-1);
+ Date currentTime = new Date();
+ DateFormat transFormat = new SimpleDateFormat("yyyyMMddkkmm");
+ tokenInfo.setIssuedtime(transFormat.format(currentTime));
+ return tokenInfo;
+ }
+
+ private UserTable makeUserTable() {
+ UserTable userInfo = new UserTable();
+ userInfo.setUuid(uuid);
+ userInfo.setProvider(authProvider);
+ userInfo.setUserid("userId");
+ return userInfo;
+ }
+}
--- /dev/null
+
+/*
+ * //******************************************************************
+ * //
+ * // Copyright 2016 Samsung Electronics All Rights Reserved.
+ * //
+ * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+ * //
+ * // Licensed under the Apache License, Version 2.0 (the "License");
+ * // you may not use this file except in compliance with the License.
+ * // You may obtain a copy of the License at
+ * //
+ * // http://www.apache.org/licenses/LICENSE-2.0
+ * //
+ * // Unless required by applicable law or agreed to in writing, software
+ * // distributed under the License is distributed on an "AS IS" BASIS,
+ * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * // See the License for the specific language governing permissions and
+ * // limitations under the License.
+ * //
+ * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+ */
+package org.iotivity.cloud.accountserver.resources.acl.group;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.concurrent.CountDownLatch;
+
+import org.iotivity.cloud.accountserver.db.TokenTable;
+import org.iotivity.cloud.accountserver.db.UserTable;
+import org.iotivity.cloud.accountserver.util.TypeCastingManager;
+import org.iotivity.cloud.base.ServerSystem;
+import org.iotivity.cloud.base.ServerSystem.PersistentPacketReceiver;
+import org.iotivity.cloud.base.device.CoapDevice;
+import org.iotivity.cloud.base.device.Device;
+import org.iotivity.cloud.base.protocols.IRequest;
+import org.iotivity.cloud.base.protocols.IResponse;
+import org.iotivity.cloud.base.protocols.MessageBuilder;
+import org.iotivity.cloud.base.protocols.coap.CoapRequest;
+import org.iotivity.cloud.base.protocols.coap.CoapResponse;
+import org.iotivity.cloud.base.protocols.enums.ContentFormat;
+import org.iotivity.cloud.base.protocols.enums.Observe;
+import org.iotivity.cloud.base.protocols.enums.RequestMethod;
+import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
+import org.iotivity.cloud.util.Cbor;
+import org.iotivity.cloud.util.Log;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelId;
+import io.netty.util.Attribute;
+
+public class GroupResourceTest {
+ private static final String GROUP_URI = "/.well-known/ocf/acl/group";
+ private String di = "d0001";
+ private String accessToken = "5f5536c896da7dd437316585b86ef9dd03441c40";
+ private String refreshToken = "rt0001";
+ private String gid = null;
+ private TypeCastingManager<UserTable> mUserTableCastingManager = new TypeCastingManager<>();
+ private TypeCastingManager<TokenTable> mTokenTableCastingManager = new TypeCastingManager<>();
+ ServerSystem serverSystem = new ServerSystem();
+ final CountDownLatch latch = new CountDownLatch(
+ 1);
+ private String uuid = "bc38f243-aab5-44d3-8eb9-4a54ebbaf359";
+ private String authProvider = "github";
+ private CoapDevice mockDevice = Mockito
+ .mock(CoapDevice.class);
+ private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
+ IResponse res = null;
+ IResponse resObserver = null;
+
+ @Mock
+ ChannelHandlerContext ctx;
+
+ @InjectMocks
+ PersistentPacketReceiver receiver = serverSystem.new PersistentPacketReceiver();
+
+ @Before
+ public void setUp() throws Exception {
+ // create log file
+ Log.createfile();
+ // add resource
+ serverSystem.addResource(new GroupResource());
+ MockitoAnnotations.initMocks(this);
+ ChannelId channelId = mock(ChannelId.class);
+ // inject mocked coapDevice into the api
+ Channel channel = mock(Channel.class);
+ Attribute<Device> attribute = mock(Attribute.class);
+ Mockito.doReturn(channel).when(ctx).channel();
+ Mockito.doReturn(attribute).when(channel).attr(Mockito.any());
+ Mockito.doReturn(mockDevice).when(attribute).get();
+ Mockito.doReturn(channelId).when(channel).id();
+ Mockito.doReturn(
+ "0000000141f3edcfc2c3000000000001d0000000000000000000000000000000000000")
+ .when(channelId).asLongText();
+ Mockito.doAnswer(new Answer<Object>() {
+ @Override
+ public CoapResponse answer(InvocationOnMock invocation)
+ throws Throwable {
+ Object[] args = invocation.getArguments();
+ CoapResponse resp = (CoapResponse) args[0];
+ System.out.println(
+ "\t----------payload : " + resp.getPayloadString());
+ System.out.println("\t---------method : " + resp.getStatus());
+ res = resp;
+ HashMap<String, Object> payloadData = mCbor
+ .parsePayloadFromCbor(resp.getPayload(), HashMap.class);
+ if (payloadData.containsKey("gid")) {
+ gid = (String) payloadData.get("gid");
+ }
+ latch.countDown();
+ return resp;
+ }
+ }).when(mockDevice).sendResponse(Mockito.anyObject());
+ }
+
+ @Test
+ public void testCreateGroup() throws Exception {
+ System.out.println("\t--------------Create Group Test------------");
+ createGroup(ctx, uuid + "create", "Public");
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ assertTrue(hashmapCheck(res, "gid"));
+
+ }
+
+ @Test
+ public void testFindMyGroup() throws Exception {
+ System.out.println("\t--------------Find My Group Test------------");
+ String uuid = this.uuid + "find";
+ createGroup(ctx, uuid, "Public");
+ findGroup(ctx, uuid);
+ assertTrue(methodCheck(res, ResponseStatus.CONTENT));
+ assertTrue(hashmapCheck(res, "gidlist"));
+ }
+
+ @Test
+ public void testDeleteGroup() throws Exception {
+ System.out.println("\t--------------Delete Group Test------------");
+ String uuid = this.uuid + "delete";
+ createGroup(ctx, uuid, "Public");
+ deleteGroup(ctx, uuid);
+ System.out.println("\t--------res : " + res.getStatus());
+ assertTrue(methodCheck(res, ResponseStatus.DELETED));
+ }
+
+ @Test
+ public void testJoinToinvitedGroup() throws Exception {
+ System.out.println(
+ "\t--------------Join to invited group Test------------");
+ String uuid = this.uuid + "join";
+ createGroup(ctx, uuid, "Public");
+ joinGroup(ctx, "u0002");
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ }
+
+ @Test
+ public void testObserveGroup() throws Exception {
+ System.out.println("\t--------------Observe Group Test------------");
+ String uuid = this.uuid + "obs";
+ createGroup(ctx, uuid, "Public");
+ observeGroup(ctx, uuid);
+ assertTrue(methodCheck(res, ResponseStatus.CONTENT));
+ assertTrue(hashmapCheck(res, "gid"));
+ assertTrue(hashmapCheck(res, "gmid"));
+ assertTrue(hashmapCheck(res, "midlist"));
+ assertTrue(hashmapCheck(res, "dilist"));
+ }
+
+ @Test
+ public void testShareDeviceIntoGroup() throws Exception {
+ System.out.println(
+ "\t--------------Share device into group Test------------");
+ String uuid = this.uuid + "share";
+ createGroup(ctx, uuid, "Public");
+ shareDevice(ctx, "d0002");
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ }
+
+ @Test
+ public void testShareDeviceNotification() throws Exception {
+ System.out.println(
+ "\t--------------Share device Notification into group Test------------");
+ String uuid = this.uuid + "share";
+ String uuidGuest = "u0002guest";
+ ChannelHandlerContext ctxGuest = mock(ChannelHandlerContext.class);
+ ChannelId channelIdGuest = mock(ChannelId.class);
+ CoapDevice mockDeviceGuest = mock(CoapDevice.class);
+ // inject mocked coapDevice into the api
+ Channel channelGuest = mock(Channel.class);
+ Attribute<Device> attributeGuest = mock(Attribute.class);
+ Mockito.doReturn(channelGuest).when(ctxGuest).channel();
+ Mockito.doReturn(attributeGuest).when(channelGuest).attr(Mockito.any());
+ Mockito.doReturn(mockDeviceGuest).when(attributeGuest).get();
+ Mockito.doReturn(channelIdGuest).when(channelGuest).id();
+ Mockito.doReturn(
+ "0000000141f3edcfc2c3000000000001d0000000000000000000000000000000000001")
+ .when(channelIdGuest).asLongText();
+ Mockito.doAnswer(new Answer<Object>() {
+ @Override
+ public CoapResponse answer(InvocationOnMock invocation)
+ throws Throwable {
+ Object[] args = invocation.getArguments();
+ CoapResponse resp = (CoapResponse) args[0];
+ System.out.println("\t----------new member payload : "
+ + resp.getPayloadString());
+ System.out.println(
+ "\t---------new member method : " + resp.getStatus());
+ resObserver = resp;
+ return resp;
+ }
+ }).when(mockDeviceGuest).sendResponse(Mockito.anyObject());
+ createGroup(ctx, uuid, "Public");
+ joinGroup(ctxGuest, uuidGuest);
+ observeGroup(ctxGuest, uuidGuest);
+ shareDevice(ctx, "d0002");
+ // assertion for the group master
+ assertTrue(methodCheck(res, ResponseStatus.CHANGED));
+ // assertion for the observer
+ assertTrue(methodCheck(resObserver, ResponseStatus.CONTENT));
+
+ }
+
+ public void shareDevice(ChannelHandlerContext ctx, String deviceId)
+ throws Exception {
+ System.out.println("-----Share Device");
+ IRequest request = null;
+ request = createShareDeviceRequest(deviceId);
+ receiver.channelRead(ctx, request);
+ }
+
+ public IRequest createShareDeviceRequest(String deviceId) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ ArrayList<String> diList = new ArrayList<>();
+ diList.add(deviceId);
+ payloadData.put("dilist", diList);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ GROUP_URI + "/" + gid, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public void createGroup(ChannelHandlerContext ctx, String gmid,
+ String gtype) throws Exception {
+ System.out.println("-----Create Group");
+ IRequest request = null;
+ request = createGroupRequest(gmid, gtype);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void findGroup(ChannelHandlerContext ctx, String uuid)
+ throws Exception {
+ System.out.println("-----Find Group");
+ IRequest request = null;
+ request = findGroupRequest(uuid);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void observeGroup(ChannelHandlerContext ctx, String uuid)
+ throws Exception {
+ System.out.println("-----Observe Group");
+ IRequest request = null;
+ request = observeGroupRequest(uuid);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void joinGroup(ChannelHandlerContext ctx, String uuid)
+ throws Exception {
+ System.out.println("-----Join Group");
+ IRequest request = null;
+ request = joinGroupRequest(uuid);
+ receiver.channelRead(ctx, request);
+ }
+
+ public void deleteGroup(ChannelHandlerContext ctx, String uuid)
+ throws Exception {
+ System.out.println("-----Delete Group");
+ IRequest request = null;
+ request = deleteGroupRequest(uuid);
+ receiver.channelRead(ctx, request);
+ }
+
+ public IRequest deleteGroupRequest(String uuid) {
+ IRequest request = null;
+ request = MessageBuilder.createRequest(RequestMethod.DELETE, GROUP_URI,
+ "gid=" + gid + ";" + "gmid=" + uuid);
+ return request;
+ }
+
+ public IRequest findGroupRequest(String uuid) {
+ IRequest request = null;
+ request = MessageBuilder.createRequest(RequestMethod.GET, GROUP_URI,
+ "mid=" + uuid);
+ return request;
+ }
+
+ public IRequest observeGroupRequest(String uuid) {
+ IRequest request = null;
+ request = MessageBuilder.createRequest(RequestMethod.GET,
+ GROUP_URI + "/" + gid, "mid=" + uuid);
+ ((CoapRequest) request).setObserve(Observe.SUBSCRIBE);
+ return request;
+ }
+
+ public IRequest joinGroupRequest(String uuid) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ ArrayList<String> midList = new ArrayList<>();
+ midList.add(uuid);
+ payloadData.put("midlist", midList);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST,
+ GROUP_URI + "/" + gid, null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public IRequest createGroupRequest(String uuid, String gtype) {
+ IRequest request = null;
+ HashMap<String, Object> payloadData = new HashMap<String, Object>();
+ payloadData.put("gmid", uuid);
+ payloadData.put("gtype", gtype);
+ Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
+ request = MessageBuilder.createRequest(RequestMethod.POST, GROUP_URI,
+ null, ContentFormat.APPLICATION_CBOR,
+ cbor.encodingPayloadToCbor(payloadData));
+ return request;
+ }
+
+ public boolean hashmapCheck(IResponse response, String propertyName) {
+ HashMap<String, Object> payloadData = mCbor
+ .parsePayloadFromCbor(response.getPayload(), HashMap.class);
+ if (payloadData.containsKey(propertyName))
+ return true;
+ else
+ return false;
+ }
+
+ public boolean methodCheck(IResponse response,
+ ResponseStatus responseStatus) {
+ if (responseStatus == response.getStatus())
+ return true;
+ else
+ return false;
+ }
+
+ private TokenTable makeTokenTable() {
+ TokenTable tokenInfo = new TokenTable();
+ tokenInfo.setUuid(uuid);
+ tokenInfo.setDid(di);
+ tokenInfo.setAccesstoken(accessToken);
+ tokenInfo.setRefreshtoken(refreshToken);
+ tokenInfo.setProvider(authProvider);
+ tokenInfo.setExpiredtime(-1);
+ Date currentTime = new Date();
+ DateFormat transFormat = new SimpleDateFormat("yyyyMMddkkmm");
+ tokenInfo.setIssuedtime(transFormat.format(currentTime));
+ return tokenInfo;
+ }
+
+ private UserTable makeUserTable() {
+ UserTable userInfo = new UserTable();
+ userInfo.setUuid(uuid);
+ userInfo.setProvider(authProvider);
+ userInfo.setUserid("userId");
+ return userInfo;
+ }
+}
projects / platform / upstream / iotivity.git / commitdiff