service/resource-encapsulation/src/common/primitiveResource/unittests/PrimitiveResourceTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "UnitTestHelper.h"
  22
  23 #include "PrimitiveResourceImpl.h"
  24 #include "AssertUtils.h"
  25
  26 #include "OCResource.h"
  27 #include "OCPlatform.h"
  28
  29 using namespace OIC::Service;
  30
  31 const std::string KEY{ "key" };
  32
  33 class FakeOCResource
  34 {
  35 public:
  36     virtual ~FakeOCResource() {};
  37
  38     virtual OCStackResult get(const std::string&, const std::string&,
  39             const OC::QueryParamsMap&, OC::GetCallback) = 0;
  40
  41     virtual OCStackResult put(
  42             const OC::OCRepresentation&, const OC::QueryParamsMap&, OC::PutCallback) = 0;
  43
  44     virtual OCStackResult post(const std::string&, const std::string&,
  45             const OC::OCRepresentation&, const OC::QueryParamsMap&, OC::PostCallback) = 0;
  46
  47     virtual OCStackResult observe(
  48             OC::ObserveType, const OC::QueryParamsMap&, OC::ObserveCallback) = 0;
  49
  50     virtual OCStackResult cancelObserve() = 0;
  51
  52     virtual std::string sid() const = 0;
  53     virtual std::string uri() const = 0;
  54     virtual std::string host() const = 0;
  55     virtual std::vector<std::string> getResourceTypes() const = 0;
  56     virtual std::vector<std::string> getResourceInterfaces() const = 0;
  57
  58     virtual bool isObservable() const = 0;
  59 };
  60
  61 class PrimitiveResourceTest: public TestWithMock
  62 {
  63 public:
  64     PrimitiveResource::Ptr resource;
  65     FakeOCResource* fakeResource;
  66
  67 protected:
  68     void SetUp() {
  69         TestWithMock::SetUp();
  70
  71         fakeResource = mocks.Mock< FakeOCResource >();
  72
  73         resource.reset(new PrimitiveResourceImpl< FakeOCResource >{
  74             std::shared_ptr< FakeOCResource >(fakeResource, [](FakeOCResource*) {}) });
  75     }
  76 };
  77
  78 TEST_F(PrimitiveResourceTest, RequestGetInvokesOCResourceGet)
  79 {
  80     mocks.ExpectCall(fakeResource, FakeOCResource::get).Return(OC_STACK_OK);
  81
  82     resource->requestGet(PrimitiveResource::GetCallback());
  83 }
  84
  85 TEST_F(PrimitiveResourceTest, RequestGetThrowsOCResourceGetReturnsNotOK)
  86 {
  87     mocks.OnCall(fakeResource, FakeOCResource::get).Return(OC_STACK_ERROR);
  88
  89     ASSERT_THROW(resource->requestGet(PrimitiveResource::GetCallback()), RCSPlatformException);
  90 }
  91
  92 TEST_F(PrimitiveResourceTest, RequestSetInvokesOCResourcePost)
  93 {
  94     mocks.ExpectCall(fakeResource, FakeOCResource::post).Return(OC_STACK_OK);
  95
  96     resource->requestSet(RCSResourceAttributes{ }, PrimitiveResource::SetCallback());
  97 }
  98
  99 TEST_F(PrimitiveResourceTest, RequestSetThrowsOCResourcePostReturnsNotOK)
 100 {
 101     mocks.OnCall(fakeResource, FakeOCResource::post).Return(OC_STACK_ERROR);
 102
 103     ASSERT_THROW(resource->requestSet(RCSResourceAttributes{ }, PrimitiveResource::SetCallback()),
 104             RCSPlatformException);
 105 }
 106
 107 TEST_F(PrimitiveResourceTest, RequestSetPassResourceAttributesToOCResourcePost)
 108 {
 109     constexpr int value{ -200 };
 110
 111     RCSResourceAttributes attrs;
 112
 113     mocks.ExpectCall(fakeResource, FakeOCResource::post).Match(
 114             [](const std::string&, const std::string&, const OC::OCRepresentation& ocRep,
 115                     const OC::QueryParamsMap&, OC::PutCallback)
 116             {
 117                 return ocRep.getValue<int>(KEY) == value;
 118             }
 119         ).Return(OC_STACK_OK);
 120
 121     attrs[KEY] = value;
 122
 123     resource->requestSet(attrs, PrimitiveResource::SetCallback());
 124 }
 125
 126 TEST_F(PrimitiveResourceTest, RequestObserveInvokesOCResourceObserve)
 127 {
 128     mocks.ExpectCall(fakeResource, FakeOCResource::observe).Return(OC_STACK_OK);
 129
 130     resource->requestObserve(PrimitiveResource::ObserveCallback());
 131 }
 132
 133 TEST_F(PrimitiveResourceTest, RequestObserveThrowsOCResourceObserveReturnsNotOK)
 134 {
 135     mocks.OnCall(fakeResource, FakeOCResource::observe).Return(OC_STACK_ERROR);
 136
 137     ASSERT_THROW(resource->requestObserve(PrimitiveResource::ObserveCallback()), RCSPlatformException);
 138 }
 139
 140 TEST_F(PrimitiveResourceTest, DelegteGettersToOCResource)
 141 {
 142     const std::string host{ "host_test_" };
 143     const std::string uri{ "uri/test/" };
 144
 145     mocks.OnCall(fakeResource, FakeOCResource::isObservable).Return(false);
 146     mocks.OnCall(fakeResource, FakeOCResource::host).Return(host);
 147     mocks.OnCall(fakeResource, FakeOCResource::uri).Return(uri);
 148
 149     ASSERT_FALSE(resource->isObservable());
 150     ASSERT_EQ(host, resource->getHost());
 151     ASSERT_EQ(uri, resource->getUri());
 152 }
 153
 154
 155 TEST_F(PrimitiveResourceTest, ResponseStatementHasSameValuesWithOCRepresentationReceived)
 156 {
 157     constexpr int errorCode{ 202 };
 158     constexpr int value{ 1999 };
 159
 160     mocks.OnCall(fakeResource, FakeOCResource::get).Do(
 161             [](const std::string&, const std::string&, const OC::QueryParamsMap&, OC::GetCallback cb)
 162             {
 163                 OC::OCRepresentation ocRep;
 164                 ocRep[KEY] = value;
 165
 166                 cb(OC::HeaderOptions(), ocRep, errorCode);
 167                 return OC_STACK_OK;
 168             }
 169         ).Return(OC_STACK_OK);
 170
 171     resource->requestGet(
 172             [&](const HeaderOptions&, const ResponseStatement& response, int e)
 173             {
 174                 ASSERT_EQ(e, errorCode);
 175                 ASSERT_EQ(response.getAttributes().at(KEY).get<int>(), value);
 176             }
 177         );
 178 }
 179
 180
 181 class DiscoverResourceTest: public TestWithMock
 182 {
 183 public:
 184     typedef OCStackResult (*FindResource)(const std::string&, const std::string&,
 185             OCConnectivityType, OC::FindCallback);
 186
 187 public:
 188     static void discovered(std::shared_ptr< PrimitiveResource >) {}
 189 };
 190
 191 TEST_F(DiscoverResourceTest, CallbackIsInvokedWhenResourceIsDiscovered)
 192 {
 193     mocks.ExpectCallFuncOverload(static_cast<FindResource>(OC::OCPlatform::findResource)).Do(
 194             [](const std::string&, const std::string&, OCConnectivityType,
 195                     OC::FindCallback callback) -> OCStackResult
 196             {
 197                 callback(nullptr);
 198                 return OC_STACK_OK;
 199             }
 200         ).Return(OC_STACK_OK);
 201
 202     mocks.ExpectCallFunc(discovered);
 203
 204     discoverResource("", "", OCConnectivityType{ }, discovered);
 205 }
 206
 207 TEST_F(DiscoverResourceTest, ThrowsdWhenOCPlatformFindResourceReturnsNotOK)
 208 {
 209     mocks.ExpectCallFuncOverload(static_cast<FindResource>(OC::OCPlatform::findResource)).
 210             Return(OC_STACK_ERROR);
 211
 212     EXPECT_THROW(discoverResource("", "", OCConnectivityType{ }, discovered), RCSPlatformException);
 213 }
 214