unittest/restriction.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd 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 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20 #include <gmock/gmock.h>
  21 #include <gtest/gtest.h>
  22
  23 #include "restriction.h"
  24
  25 static GMainLoop *g_pMainLoop = NULL;
  26 static guint g_nTimeoutId = 0;
  27
  28 static gboolean CallbackTimeut(gpointer data)
  29 {
  30         if (g_pMainLoop)
  31                 g_main_loop_quit(g_pMainLoop);
  32
  33         return false;
  34 }
  35
  36 static void RunMainLoop(void)
  37 {
  38         g_pMainLoop = g_main_loop_new(NULL, false);
  39         g_nTimeoutId = g_timeout_add(GMAINTIMEOUT, CallbackTimeut, g_pMainLoop);
  40         g_main_loop_run(g_pMainLoop);
  41
  42         g_source_remove(g_nTimeoutId);
  43         g_pMainLoop = NULL;
  44 }
  45
  46 static void QuitMainLoop(void)
  47 {
  48         if (g_pMainLoop)
  49                 g_main_loop_quit(g_pMainLoop);
  50 }
  51
  52 static void AsyncReadyCallback(GObject *source_object,
  53         GAsyncResult *res, gpointer user_data)
  54 {
  55         GLOGD("Succeeded to response async callback");
  56         QuitMainLoop();
  57 }
  58
  59 RRule::RRule()
  60 {
  61         this->m_AppID[0] = '\0';
  62         this->m_IfaceName[0] = '\0';
  63         this->m_IfaceType = IFACE_ALL;
  64         this->m_DataLimit = 0;
  65         this->m_DataWarnLimit = 0;
  66         this->m_RoamingType = ROAMING_DISABLED;
  67         this->m_SubscriberID[0] = '\0';
  68 }
  69
  70 RRule::~RRule()
  71 {
  72 }
  73
  74 Restriction::Restriction()
  75 {
  76         Create();
  77 }
  78
  79 Restriction::~Restriction()
  80 {
  81         Destroy();
  82 }
  83
  84 error_e Restriction::SetRule(const char *app_id, const char *iface_name,
  85                 const char *subscriber_id, iface_type_e iface_type,
  86                 int64_t data_limit, int64_t data_warn_limit,
  87                 roaming_type_e roaming_type)
  88 {
  89         if (app_id == NULL || strlen(app_id) == 0)
  90                 this->m_Rule.m_AppID[0] = '\0';
  91         else
  92                 g_strlcpy(this->m_Rule.m_AppID, app_id, APP_ID_LEN);
  93
  94         if (iface_name == NULL || strlen(iface_name) == 0)
  95                 this->m_Rule.m_IfaceName[0] = '\0';
  96         else
  97                 g_strlcpy(this->m_Rule.m_IfaceName, iface_name, IFNAME_LEN);
  98
  99         if (subscriber_id == NULL || strlen(subscriber_id) == 0)
 100                 this->m_Rule.m_SubscriberID[0] = '\0';
 101         else
 102                 g_strlcpy(this->m_Rule.m_SubscriberID, subscriber_id, SUBSCRIBER_ID_LEN);
 103
 104         switch(iface_type) {
 105         case IFACE_UNKNOWN:
 106         case IFACE_DATACALL:
 107         case IFACE_WIFI:
 108         case IFACE_WIRED:
 109         case IFACE_BLUETOOTH:
 110         case IFACE_ALL:
 111                 this->m_Rule.m_IfaceType = iface_type;
 112                 break;
 113         default:
 114                 return ERROR_INVALID_PARAMETER;
 115         }
 116
 117         switch(roaming_type) {
 118         case ROAMING_UNKNOWN:
 119         case ROAMING_ENABLED:
 120         case ROAMING_DISABLED:
 121                 this->m_Rule.m_RoamingType = roaming_type;
 122                 break;
 123         default:
 124                 return ERROR_INVALID_PARAMETER;
 125         }
 126
 127         this->m_Rule.m_DataLimit = data_limit;
 128         this->m_Rule.m_DataWarnLimit = data_warn_limit;
 129
 130         return ERROR_NONE;
 131 }
 132
 133 void Restriction::MakeRuleParams(GVariant **params)
 134 {
 135         GVariantBuilder *builder;
 136
 137         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 138
 139         g_variant_builder_add(builder, "{sv}",
 140                 RESTRICTION_RULE_APP_ID,
 141                 g_variant_new_string(this->m_Rule.m_AppID));
 142
 143         g_variant_builder_add(builder, "{sv}",
 144                 RESTRICTION_RULE_IFNAME,
 145                 g_variant_new_string(this->m_Rule.m_IfaceName));
 146
 147         g_variant_builder_add(builder, "{sv}",
 148                 RESTRICTION_RULE_IFTYPE,
 149                 g_variant_new_uint16(this->m_Rule.m_IfaceType));
 150
 151         g_variant_builder_add(builder, "{sv}",
 152                 RESTRICTION_RULE_ROAMING,
 153                 g_variant_new_uint16(this->m_Rule.m_RoamingType));
 154
 155         g_variant_builder_add(builder, "{sv}",
 156                 RESTRICTION_RULE_SUBSCRIBER_ID,
 157                 g_variant_new_string(this->m_Rule.m_SubscriberID));
 158
 159         g_variant_builder_add(builder, "{sv}",
 160                 RESTRICTION_RULE_DATA_LIMIT,
 161                 g_variant_new_int64(this->m_Rule.m_DataLimit));
 162
 163         g_variant_builder_add(builder, "{sv}",
 164                 RESTRICTION_RULE_DATA_WARN_LIMIT,
 165                 g_variant_new_int64(this->m_Rule.m_DataWarnLimit));
 166
 167         *params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 168         g_variant_builder_unref(builder);
 169 }
 170
 171 void Restriction::MakeGetParams(GVariant **params)
 172 {
 173         *params = g_variant_new("(s)", this->m_Rule.m_AppID);
 174 }
 175
 176 void Restriction::MakeStatusParams(GVariant **params)
 177 {
 178         *params = g_variant_new("(si)",
 179                 this->m_Rule.m_AppID, this->m_Rule.m_IfaceType);
 180 }
 181
 182 error_e Restriction::SetRstriction(void)
 183 {
 184         GVariant *message = NULL;
 185         GVariant *params = NULL;
 186         error_e error = ERROR_NONE;
 187         int result = 0;
 188
 189         MakeRuleParams(&params);
 190
 191         message = InvokeMethod(STC_MGR_SERVICE,
 192                 STC_MGR_RESTRICTION_PATH,
 193                 STC_MGR_RESTRICTION_INTERFACE,
 194                 STC_MGR_METHOD_RESTRICTION_SET,
 195                 params,
 196                 &error);
 197
 198         if (message == NULL) {
 199                 GLOGD("Failed to invoke dbus method");
 200                 return error;
 201         }
 202
 203         g_variant_get(message, "(i)", &result);
 204         GLOGD("Succeeded to set restriction [%d]", result);
 205         g_variant_unref(message);
 206
 207         return ERROR_NONE;
 208 }
 209
 210 error_e Restriction::ExcludeRstriction(void)
 211 {
 212         GVariant *message = NULL;
 213         GVariant *params = NULL;
 214         error_e error = ERROR_NONE;
 215         int result = 0;
 216
 217         MakeRuleParams(&params);
 218
 219         message = InvokeMethod(STC_MGR_SERVICE,
 220                 STC_MGR_RESTRICTION_PATH,
 221                 STC_MGR_RESTRICTION_INTERFACE,
 222                 STC_MGR_METHOD_RESTRICTION_EXCLUDE,
 223                 params,
 224                 &error);
 225
 226         if (message == NULL) {
 227                 GLOGD("Failed to invoke dbus method");
 228                 return error;
 229         }
 230
 231         g_variant_get(message, "(i)", &result);
 232         GLOGD("Succeeded to exclude restriction [%d]", result);
 233         g_variant_unref(message);
 234
 235         return ERROR_NONE;
 236 }
 237
 238 error_e Restriction::UnsetRstriction(void)
 239 {
 240         GVariant *message = NULL;
 241         GVariant *params = NULL;
 242         error_e error = ERROR_NONE;
 243         int result = 0;
 244
 245         MakeRuleParams(&params);
 246
 247         message = InvokeMethod(STC_MGR_SERVICE,
 248                 STC_MGR_RESTRICTION_PATH,
 249                 STC_MGR_RESTRICTION_INTERFACE,
 250                 STC_MGR_METHOD_RESTRICTION_UNSET,
 251                 params,
 252                 &error);
 253
 254         if (message == NULL) {
 255                 GLOGD("Failed to invoke dbus method");
 256                 return error;
 257         }
 258
 259         g_variant_get(message, "(i)", &result);
 260         GLOGD("Succeeded to unset restriction [%d]", result);
 261         g_variant_unref(message);
 262
 263         return ERROR_NONE;
 264 }
 265
 266 error_e Restriction::GetRstrictionStatus(restriction_status_e *status)
 267 {
 268         GVariant *message = NULL;
 269         GVariant *params = NULL;
 270         error_e error = ERROR_NONE;
 271         int result = 0;
 272
 273         MakeStatusParams(&params);
 274
 275         message = InvokeMethod(STC_MGR_SERVICE,
 276                 STC_MGR_RESTRICTION_PATH,
 277                 STC_MGR_RESTRICTION_INTERFACE,
 278                 STC_MGR_METHOD_RESTRICTION_GET_STATUS,
 279                 params,
 280                 &error);
 281
 282         if (message == NULL) {
 283                 GLOGD("Failed to invoke dbus method");
 284                 return error;
 285         }
 286
 287         g_variant_get(message, "(ii)", &result, status);
 288         GLOGD("Succeeded to get restriction status [%d:%d]", result, *status);
 289         g_variant_unref(message);
 290
 291         return ERROR_NONE;
 292 }
 293
 294 error_e Restriction::GetRstriction(void)
 295 {
 296         GVariant *params = NULL;
 297         error_e error = ERROR_NONE;
 298
 299         MakeGetParams(&params);
 300
 301         error = InvokeMethodNonblock(STC_MGR_SERVICE,
 302                 STC_MGR_RESTRICTION_PATH,
 303                 STC_MGR_RESTRICTION_INTERFACE,
 304                 STC_MGR_METHOD_RESTRICTION_GET_PER_APP_ID,
 305                 params,
 306                 DBUS_REPLY_TIMEOUT,
 307                 AsyncReadyCallback,
 308                 NULL);
 309
 310         if (error != ERROR_NONE) {
 311                 GLOGD("Failed to invoke dbus method nonblock");
 312                 return error;
 313         }
 314
 315         GLOGD("Succeeded to get restriction per app ID");
 316
 317         RunMainLoop();
 318         return ERROR_NONE;
 319 }
 320
 321 error_e Restriction::GetAllRstriction(void)
 322 {
 323         error_e error = ERROR_NONE;
 324
 325         error = InvokeMethodNonblock(STC_MGR_SERVICE,
 326                 STC_MGR_RESTRICTION_PATH,
 327                 STC_MGR_RESTRICTION_INTERFACE,
 328                 STC_MGR_METHOD_RESTRICTION_GET_ALL,
 329                 NULL,
 330                 DBUS_REPLY_TIMEOUT,
 331                 AsyncReadyCallback,
 332                 NULL);
 333
 334         if (error != ERROR_NONE) {
 335                 GLOGD("Failed to invoke dbus method nonblock");
 336                 return error;
 337         }
 338
 339         GLOGD("Succeeded to get all restriction");
 340
 341         RunMainLoop();
 342         return ERROR_NONE;
 343 }