19e5a5b4708981404e3eaa07dabeb55000229e3a
[iotivity.git] / cloud / messagequeue / src / test / java / org / iotivity / cloud / mqserver / resources / MQBrokerResourceTest.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.mqserver.resources;
24
25 import static com.jayway.awaitility.Awaitility.await;
26 import static java.util.concurrent.TimeUnit.SECONDS;
27 import static org.junit.Assert.assertFalse;
28 import static org.junit.Assert.assertTrue;
29 import static org.mockito.Mockito.mock;
30 import static org.mockito.Mockito.timeout;
31 import static org.mockito.Mockito.verify;
32
33 import java.util.ArrayList;
34 import java.util.HashMap;
35 import java.util.concurrent.CountDownLatch;
36 import java.util.concurrent.atomic.AtomicBoolean;
37
38 import org.iotivity.cloud.base.device.CoapDevice;
39 import org.iotivity.cloud.base.exception.ServerException.ForbiddenException;
40 import org.iotivity.cloud.base.exception.ServerException.NotFoundException;
41 import org.iotivity.cloud.base.exception.ServerException.PreconditionFailedException;
42 import org.iotivity.cloud.base.protocols.IRequest;
43 import org.iotivity.cloud.base.protocols.IResponse;
44 import org.iotivity.cloud.base.protocols.MessageBuilder;
45 import org.iotivity.cloud.base.protocols.coap.CoapRequest;
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.Observe;
49 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
50 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
51 import org.iotivity.cloud.util.Cbor;
52 import org.junit.Before;
53 import org.junit.Test;
54 import org.mockito.Mockito;
55 import org.mockito.invocation.InvocationOnMock;
56 import org.mockito.stubbing.Answer;
57
58 public class MQBrokerResourceTest {
59     private final String     MQ_BROKER_URI     = "/.well-known/ocf/ps";
60
61     private MQBrokerResource mMqBrokerResource = null;
62     private String           mTopicPrefix      = null;
63     private CoapDevice       mMockDevice       = null;
64     IResponse                mResponse         = null;
65     CountDownLatch           mLatch            = null;
66
67     @Before
68     // setup for each test
69     public void setUp() throws Exception {
70         mMqBrokerResource = new MQBrokerResource();
71
72         // insert user's zookeper and broker addresses
73         String zookeeper = "127.0.0.1:2181";
74         String broker = "127.0.0.1:9092";
75
76         mTopicPrefix = "mqtestTopic";
77         mMqBrokerResource.setKafkaInformation(zookeeper, broker);
78         mLatch = new CountDownLatch(1);
79         mResponse = null; // initialize response packet
80         mMockDevice = mock(CoapDevice.class);
81
82         // callback mock
83         Mockito.doAnswer(new Answer<Object>() {
84             @Override
85             public CoapResponse answer(InvocationOnMock invocation)
86                     throws Throwable {
87                 Object[] args = invocation.getArguments();
88                 CoapResponse resp = (CoapResponse) args[0];
89                 mResponse = resp;
90                 mLatch.countDown();
91                 return resp;
92             }
93         }).when(mMockDevice).sendResponse(Mockito.anyObject());
94     }
95
96     @Test
97     // test topic creation
98     public void testTopicCreationOnDefaultRequestReceived() throws Exception {
99         System.out.println("\t--------------Topic Creation Test------------");
100         CreateTopic(mMockDevice, mTopicPrefix);
101         // assertion: if the response status is "CREATED"
102         assertTrue(mLatch.await(1L, SECONDS));
103         assertTrue(methodCheck(mResponse, ResponseStatus.CREATED));
104     }
105
106     @Test
107     // test subtopic create
108     public void testSubTopicCreationOnDefaultRequestReceived() throws Exception {
109         System.out
110                 .println("\t--------------SubTopic Creation Test------------");
111         String mainTopic = mTopicPrefix + "Main";
112         String subTopic = mTopicPrefix + "Sub";
113         // create main topic
114         CreateTopic(mMockDevice, mainTopic);
115         // create sub topic
116         CreateSubTopic(mMockDevice, mainTopic, subTopic);
117         // assertion: if the response status is "CREATED"
118         assertTrue(mLatch.await(1L, SECONDS));
119         assertTrue(methodCheck(mResponse, ResponseStatus.CREATED));
120     }
121
122     @Test
123     // test topic publish
124     public void testTopicPublishOnDefaultRequestReceived() throws Exception {
125         System.out.println("\t--------------Topic Publish Test------------");
126         String topic = mTopicPrefix + "ForPub";
127         // topic creation
128         CreateTopic(mMockDevice, topic);
129         // topic publish
130         PublishTopic(mMockDevice, topic);
131         // assertion: if the response status is "CHANGED"
132         assertTrue(mLatch.await(1L, SECONDS));
133         assertTrue(methodCheck(mResponse, ResponseStatus.CHANGED));
134     }
135
136     @Test
137     // test subscribe request
138     public void testSubscribeOnDefaultRequestReceived() throws Exception {
139         System.out.println("\t--------------Topic Subscribe Test------------");
140         CoapDevice mockSubscriber = mock(CoapDevice.class);
141         String topic = mTopicPrefix + "SubscribeTest";
142         // create topic
143         CreateTopic(mMockDevice, topic);
144         // publish topic
145         PublishTopic(mMockDevice, topic);
146         // callback mock for subscriber
147         Mockito.doAnswer(new Answer<Object>() {
148             @Override
149             public CoapResponse answer(InvocationOnMock invocation)
150                     throws Throwable {
151                 Object[] args = invocation.getArguments();
152                 CoapResponse resp = (CoapResponse) args[0];
153                 // assertion: if the response status is "CONTENT"
154                 // assertion: if the response payload has the "message" property
155                 assertTrue(methodCheck(resp, ResponseStatus.CONTENT));
156                 assertTrue(hashmapCheck(resp, "message"));
157                 return resp;
158             }
159         }).when(mockSubscriber).sendResponse(Mockito.anyObject());
160         // subscribe topic
161         SubscribeTopic(mockSubscriber, topic, Observe.SUBSCRIBE);
162     }
163
164     @Test
165     // test unsubscribe request
166     public void testUnSubscribeOnDefaultRequestReceived() throws Exception {
167         System.out
168                 .println("\t--------------Topic Unsubscribe Test------------");
169         CountDownLatch latchSubscriber = new CountDownLatch(2);
170         CoapDevice mockSubscriber = mock(CoapDevice.class);
171         String topic = mTopicPrefix + "UnSubscribeTest";
172         // create topic
173         CreateTopic(mMockDevice, topic);
174         // publish topic
175         PublishTopic(mMockDevice, topic);
176         // callback mock for subscriber
177         Mockito.doAnswer(new Answer<Object>() {
178             @Override
179             public CoapResponse answer(InvocationOnMock invocation)
180                     throws Throwable {
181                 Object[] args = invocation.getArguments();
182                 CoapResponse resp = (CoapResponse) args[0];
183                 latchSubscriber.countDown();
184                 if (latchSubscriber.getCount() == 0) {
185                     // assertion: if the response payload has the "message"
186                     // property
187                     assertTrue(methodCheck(resp, ResponseStatus.CONTENT));
188                     assertTrue(hashmapCheck(resp, "message"));
189                 }
190                 return resp;
191             }
192         }).when(mockSubscriber).sendResponse(Mockito.anyObject());
193         // subscribe topic
194         SubscribeTopic(mockSubscriber, topic, Observe.SUBSCRIBE);
195         // unsubscribe topic
196         SubscribeTopic(mockSubscriber, topic, Observe.UNSUBSCRIBE);
197     }
198
199     @Test
200     // test delete request
201     public void testDeleteTopicOnDefaultRequestReceived() throws Exception {
202         System.out.println("\t--------------Topic Delete Test------------");
203         String topic = mTopicPrefix + "DeleteTest";
204         // create topic
205         CreateTopic(mMockDevice, topic);
206         // delete topic
207         DeleteTopic(mMockDevice, topic);
208         // assertion: if the response status is "DELETED"
209         assertTrue(methodCheck(mResponse, ResponseStatus.DELETED));
210         assertTrue(mLatch.await(1L, SECONDS));
211     }
212
213     @Test
214     // test delete subtopic request
215     public void testDeleteSubTopicOnDefaultRequestReceived() throws Exception {
216         System.out.println("\t--------------Subtopic Delete Test------------");
217         String topic = mTopicPrefix + "DeleteTest";
218         String subTopic = mTopicPrefix + "DeleteTestSub";
219         // create topic
220         CreateTopic(mMockDevice, topic);
221         // create subtopic
222         CreateSubTopic(mMockDevice, topic, subTopic);
223         // delete subtopic
224         DeleteSubTopic(mMockDevice, topic, subTopic);
225         // assertion: if the response status is "DELETED"
226         assertTrue(methodCheck(mResponse, ResponseStatus.DELETED));
227     }
228
229     @Test
230     // test notify
231     public void testTopicSubscribeNofityOnDefaultRequestReceived()
232             throws Exception {
233         System.out
234                 .println("\t--------------Topic Publish Notify Test------------");
235         CoapDevice mockSubscriber = mock(CoapDevice.class);
236         CountDownLatch latchSubscriber = new CountDownLatch(2);
237         AtomicBoolean countTrue = new AtomicBoolean();
238         countTrue.set(false);
239         String topic = mTopicPrefix + "NotifyTest";
240         // callback mock for subscriber
241         Mockito.doAnswer(new Answer<Object>() {
242             @Override
243             public CoapResponse answer(InvocationOnMock invocation)
244                     throws Throwable {
245                 Object[] args = invocation.getArguments();
246                 CoapResponse resp = (CoapResponse) args[0];
247                 latchSubscriber.countDown();
248                 // assertion for subscriber
249                 if (latchSubscriber.getCount() == 0) {
250                     assertTrue(methodCheck(resp, ResponseStatus.CONTENT));
251                     assertTrue(hashmapCheck(resp, "message"));
252                 }
253                 return resp;
254             }
255         }).when(mockSubscriber).sendResponse(Mockito.anyObject());
256         // create topic
257         CreateTopic(mMockDevice, topic);
258         // publish topic (publisher)
259         PublishTopic(mMockDevice, topic);
260         // subscribe topic (subscriber)
261         SubscribeTopic(mockSubscriber, topic, Observe.SUBSCRIBE);
262         await().atMost(2, SECONDS).untilFalse(countTrue);
263         PublishTopic(mMockDevice, topic);
264         // verity if subscriber receives two responses
265         assertTrue(latchSubscriber.await(2L, SECONDS));
266         verify(mockSubscriber, timeout(5000).times(2)).sendResponse(
267                 Mockito.anyObject());
268     }
269
270     @Test
271     // test discover request
272     public void testTopicDiscoverOnDefaultRequestReceived() throws Exception {
273         System.out.println("\t--------------Topic Discover Test------------");
274         String topic = mTopicPrefix + "DiscoverTest";
275         String subTopic = topic + "sub";
276         // create topic
277         CreateTopic(mMockDevice, topic);
278         // create sub topic
279         CreateSubTopic(mMockDevice, topic, subTopic);
280         // discover topic
281         DiscoverTopic();
282         // assertion 1: if the response status is "CONTENT"
283         // assertion 2: if the response payload has "topiclist" property
284         // and there is the topic created in this unit test in the array
285         boolean methodCheck = methodCheck(mResponse, ResponseStatus.CONTENT);
286         Cbor<HashMap<String, ArrayList<String>>> mArrayCbor = new Cbor<>();
287         HashMap<String, ArrayList<String>> payloadData = mArrayCbor
288                 .parsePayloadFromCbor(mResponse.getPayload(), HashMap.class);
289         ArrayList<String> topicList = payloadData.get("topiclist");
290         System.out.println("\ttopicList : " + topicList);
291         assertTrue(methodCheck);
292         assertTrue(topicList.contains("/.well-known/ocf/ps/" + topic));
293         assertTrue(topicList.contains("/.well-known/ocf/ps/" + topic + "/"
294                 + subTopic));
295     }
296
297     @Test
298     // topic read request
299     public void testTopicReadOnDefaultRequestReceived() throws Exception {
300         System.out.println("\t--------------Topic Read Test------------");
301         String topic = mTopicPrefix + "ReadTest";
302         // create topic
303         CreateTopic(mMockDevice, topic);
304         // publish topic
305         PublishTopic(mMockDevice, topic);
306         // read topic
307         ReadTopic(topic);
308         // assertion1 : if the response status is "CONTENT"
309         // assertion2 : if the response payload has the "message" property
310         assertTrue(methodCheck(mResponse, ResponseStatus.CONTENT));
311         assertTrue(hashmapCheck(mResponse, "message"));
312     }
313
314     @Test(expected = NotFoundException.class)
315     public void testNotCreatedTopicDeleteOnDefaultRequestReceived()
316             throws Exception {
317         System.out
318                 .println("\t--------------Not Created Topic Delete Test------------");
319         String topic = mTopicPrefix + "NotCreatedTopicDeleteTest";
320
321         DeleteTopic(mMockDevice, topic);
322     }
323
324     @Test(expected = NotFoundException.class)
325     public void testNotCreatedSubtopicDeleteOnDefaultRequestReceived()
326             throws Exception {
327         System.out
328                 .println("\t--------------Not Created Subtopic Delete Test------------");
329         String topic = mTopicPrefix + "Maintopic";
330
331         CreateTopic(mMockDevice, topic);
332
333         topic += "/" + "NotCreatedSubtopicTest";
334
335         DeleteTopic(mMockDevice, topic);
336     }
337
338     @Test(expected = ForbiddenException.class)
339     // duplicate topic creation
340     public void testDuplicatedTopicCreateOnDefaultRequestReceived()
341             throws Exception {
342         System.out
343                 .println("\t--------------Duplicated Topic Creation Test------------");
344         String topic = mTopicPrefix + "DuplicateTest";
345         // create topic
346         CreateTopic(mMockDevice, topic);
347         // create topic again
348         CreateTopic(mMockDevice, topic);
349     }
350
351     @Test(expected = ForbiddenException.class)
352     // duplicate subtopic creation
353     public void testDuplicatedSubtopicCreateOnDefaultRequestReceived()
354             throws Exception {
355         System.out
356                 .println("\t--------------Duplicated Subtopic Creation Test------------");
357
358         String topic = mTopicPrefix + "DuplicateTest2";
359
360         // create topic
361         CreateTopic(mMockDevice, topic);
362
363         // create subtopic
364         topic += "/subtopic";
365         CreateTopic(mMockDevice, topic);
366
367         // create subtopic again
368         CreateTopic(mMockDevice, topic);
369     }
370
371     @Test(expected = NotFoundException.class)
372     // publish not created topic
373     public void testNotCreatedTopicPublishOnDefaultRequestReceived()
374             throws Exception {
375         System.out
376                 .println("\t--------------Not Created Topic Publish Test------------");
377         String topic = mTopicPrefix + "NotCreatedTopicTest";
378         // publish not created topic
379         PublishTopic(mMockDevice, topic);
380     }
381
382     @Test(expected = NotFoundException.class)
383     // subscribe not created topic
384     public void testNotCreatedTopicSubscribeOnDefaultRequestReceived()
385             throws Exception {
386         System.out
387                 .println("\t--------------Not Created Topic Subscribe Test------------");
388         String topic = mTopicPrefix + "NotCreatedTopicSubscribeTest";
389         SubscribeTopic(mMockDevice, topic, Observe.SUBSCRIBE);
390     }
391
392     @Test(expected = NotFoundException.class)
393     // unsubscribe not created topic
394     public void testNotCreatedTopicUnSubscribeOnDefaultRequestReceived()
395             throws Exception {
396         System.out
397                 .println("\t--------------Not Created Topic Unsubscribe Test------------");
398         String topic = mTopicPrefix + "NotCreatedTopicUnSubscribeTest";
399         SubscribeTopic(mMockDevice, topic, Observe.UNSUBSCRIBE);
400     }
401
402     @Test(expected = PreconditionFailedException.class)
403     public void testTopicPublishWithoutMessage() throws Exception {
404         System.out
405                 .println("\t--------------Topic Publish Without Message Test------------");
406         String topic = mTopicPrefix + "ForPubWithoutMessage";
407
408         // topic creation
409         CreateTopic(mMockDevice, topic);
410
411         // topic publish without message
412         String requestUri = MQ_BROKER_URI + "/" + topic;
413         IRequest request = MessageBuilder.createRequest(RequestMethod.POST,
414                 requestUri, null);
415
416         mMqBrokerResource.onDefaultRequestReceived(mMockDevice, request);
417     }
418
419     @Test(expected = NotFoundException.class)
420     // create subtopic under not created maintopic
421     public void testSubTopicCreateUnderNotCreatedTopicOnDefaultRequestReceived()
422             throws Exception {
423         System.out
424                 .println("\t--------------Create Subtopic under Not Created Maintopic  ------------");
425         String mainTopic = mTopicPrefix + "NotCreatedMain";
426         String subTopic = mTopicPrefix + "NotCreatedSub";
427         // create sub topic
428         CreateSubTopic(mMockDevice, mainTopic, subTopic);
429     }
430
431     @Test
432     // create topic which has 'core.light' rt
433     public void testTopicCreationWithRtOnDefaultRequestReceived()
434             throws Exception {
435         System.out
436                 .println("\t--------------Topic Creation with RT Test------------");
437         String topicName = mTopicPrefix + "RtTest";
438         String rt = "rt=core.light";
439         CreateTopicWithRt(mMockDevice, topicName, rt);
440         // assertion: if the response status is "CREATED"
441         assertTrue(methodCheck(mResponse, ResponseStatus.CREATED));
442     }
443
444     @Test
445     // create topic which has 'core.light' rt
446     public void testSubtopicCreationWithRtOnDefaultRequestReceived()
447             throws Exception {
448         System.out
449                 .println("\t--------------Subtopic Creation with RT Test------------");
450         String topicName = mTopicPrefix + "RtTest2";
451         String rt = "rt=core.light";
452
453         // create main topic
454         CreateTopicWithRt(mMockDevice, topicName, rt);
455
456         // create sub topic
457         topicName += "/subtopic";
458         CreateTopicWithRt(mMockDevice, topicName, rt);
459
460         assertTrue(methodCheck(mResponse, ResponseStatus.CREATED));
461     }
462
463     @Test
464     // test discover request with rt
465     public void testDiscoverTopicWithRtOnDefaultRequestReceived()
466             throws Exception {
467         System.out
468                 .println("\t--------------Topic Discover with Rt Test------------");
469         String topicName = mTopicPrefix + "DiscoverRtTest";
470         String topicNameWithoutRt = mTopicPrefix + "DiscoverRtTestWithoutRt";
471         String rt = "rt=core.light";
472         // create topic with rt
473         CreateTopicWithRt(mMockDevice, topicName, rt);
474         // create topic
475         CreateTopic(mMockDevice, topicNameWithoutRt);
476         // discover topic
477         DiscoverTopicWithRt(rt);
478         // assertion 1: if the response status is "CONTENT"
479         // assertion 2: if topic list contains the topic with rt
480         // assertion 3: if topic list contains no topics which does not have the
481         // rt
482         Cbor<HashMap<String, ArrayList<String>>> mArrayCbor = new Cbor<>();
483         HashMap<String, ArrayList<String>> payloadData = mArrayCbor
484                 .parsePayloadFromCbor(mResponse.getPayload(), HashMap.class);
485         ArrayList<String> topicList = payloadData.get("topiclist");
486         System.out.println("\ttopicList : " + topicList);
487         assertTrue(methodCheck(mResponse, ResponseStatus.CONTENT));
488         assertTrue(topicList.contains("/.well-known/ocf/ps/" + topicName));
489         assertFalse(topicList.contains("/.well-known/ocf/ps/"
490                 + topicNameWithoutRt));
491     }
492
493     private IRequest PublishTopicRequest(String topicName) {
494         IRequest request = null;
495         HashMap<String, Object> tags = new HashMap<String, Object>();
496         HashMap<String, Object> message = new HashMap<String, Object>();
497         message.put("status", "on");
498         message.put("brightness", 20);
499         tags.put("message", message);
500         Cbor<HashMap<String, Object>> cbor = new Cbor<HashMap<String, Object>>();
501         String uri = MQ_BROKER_URI + "/" + topicName;
502         request = MessageBuilder.createRequest(RequestMethod.POST, uri, null,
503                 ContentFormat.APPLICATION_CBOR,
504                 cbor.encodingPayloadToCbor(tags));
505         return request;
506     }
507
508     private IRequest CreateTopicRequest(String topicName) {
509         IRequest request = null;
510         request = MessageBuilder.createRequest(RequestMethod.PUT, MQ_BROKER_URI
511                 + "/" + topicName, null);
512         return request;
513     }
514
515     private IRequest CreateSubTopicRequest(String topicName, String subTopicName) {
516         IRequest request = null;
517         String uri = MQ_BROKER_URI + "/" + topicName + "/" + subTopicName;
518         request = MessageBuilder.createRequest(RequestMethod.PUT, uri, null);
519         return request;
520     }
521
522     private IRequest CreateTopicWithRtRequest(String topicName, String type) {
523         IRequest request = null;
524         request = MessageBuilder.createRequest(RequestMethod.PUT, MQ_BROKER_URI
525                 + "/" + topicName, type);
526         return request;
527     }
528
529     private IRequest DeleteTopicRequest(String topicName) {
530         IRequest request = null;
531         String uri = MQ_BROKER_URI + "/" + topicName;
532         request = MessageBuilder.createRequest(RequestMethod.DELETE, uri, null);
533         return request;
534     }
535
536     private IRequest SubscribeTopicRequest(String topicName) {
537         IRequest request = null;
538         String uri = MQ_BROKER_URI + "/" + topicName;
539         request = MessageBuilder.createRequest(RequestMethod.GET, uri, null);
540         return request;
541     }
542
543     private IRequest DiscoverTopicRequest() {
544         IRequest request = null;
545         request = MessageBuilder.createRequest(RequestMethod.GET,
546                 MQ_BROKER_URI, null);
547         return request;
548     }
549
550     private IRequest DiscoverTopicWithRtRequest(String rt) {
551         IRequest request = null;
552         request = MessageBuilder.createRequest(RequestMethod.GET,
553                 MQ_BROKER_URI, rt);
554         return request;
555     }
556
557     private CoapRequest ReadTopicRequest(String topicName) {
558         IRequest request = null;
559         String uri = MQ_BROKER_URI + "/" + topicName;
560         request = MessageBuilder.createRequest(RequestMethod.GET, uri, null);
561         CoapRequest mqRequest = (CoapRequest) request;
562         return mqRequest;
563     }
564
565     private void CreateTopicWithRt(CoapDevice mockDevice, String topicName,
566             String type) throws Exception {
567         System.out.println("-----CreateTopic || topic : " + topicName);
568         IRequest request = null;
569         request = CreateTopicWithRtRequest(topicName, type);
570         mMqBrokerResource.onDefaultRequestReceived(mockDevice, request);
571     }
572
573     private void CreateTopic(CoapDevice mockDevice, String topicName)
574             throws Exception {
575         System.out.println("-----CreateTopic || topic : " + topicName);
576         IRequest request = null;
577         request = CreateTopicRequest(topicName);
578         mMqBrokerResource.onDefaultRequestReceived(mockDevice, request);
579     }
580
581     private void CreateSubTopic(CoapDevice mockDevice, String mainTopicName,
582             String subTopicName) throws Exception {
583         System.out.println("-----CreateSubTopic || topic : " + mainTopicName
584                 + " || subtopic : " + subTopicName);
585         IRequest subTopicRequest = null;
586         subTopicRequest = CreateSubTopicRequest(mainTopicName, subTopicName);
587         mMqBrokerResource.onDefaultRequestReceived(mockDevice, subTopicRequest);
588     }
589
590     private void PublishTopic(CoapDevice mockDevice, String topicName)
591             throws Exception {
592         System.out.println("-----PublishTopic : " + topicName);
593         IRequest request = null;
594         request = PublishTopicRequest(topicName);
595         mMqBrokerResource.onDefaultRequestReceived(mockDevice, request);
596     }
597
598     private void SubscribeTopic(CoapDevice mockSubscriber, String topicName,
599             Observe observe) throws Exception {
600         System.out.println("-----SubscribeTopic : " + topicName);
601         IRequest requestSubscribe = null;
602         requestSubscribe = SubscribeTopicRequest(topicName);
603         CoapRequest mqRequest = (CoapRequest) requestSubscribe;
604         mqRequest.setObserve(observe);
605         mMqBrokerResource.onDefaultRequestReceived(mockSubscriber, mqRequest);
606     }
607
608     private void DeleteTopic(CoapDevice mockDevice, String topicName)
609             throws Exception {
610         System.out.println("-----DeleteTopic : " + topicName);
611         IRequest requestToDelete = null;
612         requestToDelete = DeleteTopicRequest(topicName);
613         mMqBrokerResource.onDefaultRequestReceived(mockDevice, requestToDelete);
614     }
615
616     private void DeleteSubTopic(CoapDevice mockDevice, String topicName,
617             String subTopicName) throws Exception {
618         System.out.println("-----DeleteTopic : " + topicName);
619         String deleteUri = topicName + "/" + subTopicName;
620         IRequest requestToDelete = null;
621         requestToDelete = DeleteTopicRequest(deleteUri);
622         mMqBrokerResource.onDefaultRequestReceived(mockDevice, requestToDelete);
623     }
624
625     private void DiscoverTopic() throws Exception {
626         System.out.println("-----DiscoverTopic : ");
627         IRequest requestToDiscover = null;
628         requestToDiscover = DiscoverTopicRequest();
629         mMqBrokerResource.onDefaultRequestReceived(mMockDevice,
630                 requestToDiscover);
631     }
632
633     private void DiscoverTopicWithRt(String rt) throws Exception {
634         System.out.println("-----DiscoverTopicWithRt : ");
635         IRequest requestToDiscover = null;
636         requestToDiscover = DiscoverTopicWithRtRequest(rt);
637         mMqBrokerResource.onDefaultRequestReceived(mMockDevice,
638                 requestToDiscover);
639     }
640
641     private void ReadTopic(String topicName) throws Exception {
642         System.out.println("-----ReadTopic : " + topicName);
643         CoapRequest readRequest = null;
644         readRequest = ReadTopicRequest(topicName);
645         mMqBrokerResource.onDefaultRequestReceived(mMockDevice, readRequest);
646     }
647
648     private boolean hashmapCheck(IResponse response, String propertyName) {
649         Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
650         HashMap<String, Object> payloadData = mCbor.parsePayloadFromCbor(
651                 response.getPayload(), HashMap.class);
652         if (payloadData.get(propertyName) != null)
653             return true;
654         else
655             return false;
656     }
657
658     private boolean methodCheck(IResponse response,
659             ResponseStatus responseStatus) {
660         if (responseStatus == response.getStatus())
661             return true;
662         else
663             return false;
664     }
665 }