redismodule/tst/mock/src/redismoduleStub.cpp

   1 /*
   2  * Copyright (c) 2018-2020 Nokia.
   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 /*
  18  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19  * platform project (RICP).
  20  */
  21
  22
  23 #include <unistd.h>
  24 #include <string.h>
  25
  26 extern "C" {
  27 #include "redismodule.h"
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <ctype.h>
  31 }
  32
  33 #include <CppUTest/TestHarness.h>
  34 #include <CppUTestExt/MockSupport.h>
  35
  36
  37 int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep)
  38 {
  39     (void)ctx;
  40     (void)name;
  41     (void)cmdfunc;
  42     (void)strflags;
  43     (void)firstkey;
  44     (void)lastkey;
  45     (void)keystep;
  46     return REDISMODULE_OK;
  47
  48 }
  49
  50 int RedisModule_WrongArity(RedisModuleCtx *ctx)
  51 {
  52     (void)ctx;
  53     mock().setData("RedisModule_WrongArity", 1);
  54     return REDISMODULE_ERR;
  55 }
  56
  57 int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll)
  58 {
  59
  60     (void)ctx;
  61     mock().setData("RedisModule_ReplyWithLongLong", (int)ll);
  62     return REDISMODULE_OK;
  63 }
  64
  65 void *RedisModule_OpenKey(RedisModuleCtx *ctx, RedisModuleString *keyname, int mode)
  66 {
  67     (void)ctx;
  68     (void)keyname;
  69     (void)mode;
  70
  71     if (mock().hasData("RedisModule_OpenKey_no"))
  72     {
  73         return (void*)(0);
  74     }
  75
  76     if (mock().hasData("RedisModule_OpenKey_have"))
  77     {
  78         return (void*)(111111);
  79     }
  80
  81
  82     return (void*)(0);
  83 }
  84
  85 RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...)
  86 {
  87     (void)ctx;
  88     (void)cmdname;
  89     (void)fmt;
  90
  91     if (!strcmp(cmdname, "GET"))
  92         mock().setData("GET", 1);
  93     else if (!strcmp(cmdname, "SET"))
  94         mock().setData("SET", 1);
  95     else if (!strcmp(cmdname, "MSET"))
  96         mock().setData("MSET", 1);
  97     else if (!strcmp(cmdname, "DEL"))
  98         mock().setData("DEL", 1);
  99     else if (!strcmp(cmdname, "UNLINK"))
 100         mock().setData("UNLINK", 1);
 101     else if (!strcmp(cmdname, "PUBLISH"))
 102         mock().setData("PUBLISH", mock().getData("PUBLISH").getIntValue() + 1);
 103     else if (!strcmp(cmdname, "KEYS"))
 104         mock().setData("KEYS", 1);
 105     else if (!strcmp(cmdname, "MGET"))
 106         mock().setData("MGET", 1);
 107     else if (!strcmp(cmdname, "SCAN"))
 108         mock().setData("SCAN", 1);
 109
 110     if (mock().hasData("RedisModule_Call_Return_Null"))
 111         return NULL;
 112     else
 113         return (RedisModuleCallReply *)1;
 114 }
 115
 116 void RedisModule_FreeCallReply(RedisModuleCallReply *reply)
 117 {
 118     (void)reply;
 119     mock().setData("RedisModule_FreeCallReply", mock().getData("RedisModule_FreeCallReply").getIntValue()+1);
 120 }
 121
 122 int RedisModule_CallReplyType(RedisModuleCallReply *reply)
 123 {
 124
 125     (void)reply;
 126     if (mock().hasData("RedisModule_CallReplyType_null"))
 127     {
 128         return REDISMODULE_REPLY_NULL;
 129     }
 130
 131     if (mock().hasData("RedisModule_CallReplyType_inter"))
 132     {
 133         return REDISMODULE_REPLY_INTEGER;
 134     }
 135
 136     if (mock().hasData("RedisModule_CallReplyType_str"))
 137     {
 138         return REDISMODULE_REPLY_STRING;
 139     }
 140
 141     if (mock().hasData("RedisModule_CallReplyType_err"))
 142     {
 143         return REDISMODULE_REPLY_ERROR;
 144     }
 145
 146     return REDISMODULE_REPLY_NULL;;
 147
 148 }
 149
 150 long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply)
 151 {
 152
 153     (void)reply;
 154     return mock().getData("RedisModule_CallReplyInteger").getIntValue();
 155 }
 156
 157 const char *RedisModule_StringPtrLen(const RedisModuleString *str, size_t *len)
 158 {
 159
 160     (void)str;
 161     if (len) *len = 5;
 162     if (mock().hasData("RedisModule_String_same"))
 163     {
 164         return "11111";
 165     }
 166
 167     if (mock().hasData("RedisModule_String_nosame"))
 168     {
 169         return "22222";
 170     }
 171
 172     if (mock().hasData("RedisModule_String_count"))
 173     {
 174         return "COUNT";
 175     }
 176
 177     if (mock().hasData("RedisModule_String_count1"))
 178     {
 179         if (len) *len = 6;
 180         return "COUNT1";
 181     }
 182
 183     return "11111";
 184 }
 185
 186 int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err)
 187 {
 188     (void)ctx;
 189     (void)err;
 190     mock().setData("RedisModule_ReplyWithError", 1);
 191     return REDISMODULE_OK;
 192 }
 193
 194 int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str)
 195 {
 196     (void)ctx;
 197     (void)str;
 198     mock().setData("RedisModule_ReplyWithString", mock().getData("RedisModule_ReplyWithString").getIntValue()+1);
 199     return REDISMODULE_OK;
 200 }
 201
 202 int RedisModule_ReplyWithNull(RedisModuleCtx *ctx)
 203 {
 204
 205     (void)ctx;
 206     mock().setData("RedisModule_ReplyWithNull", 1);
 207     return REDISMODULE_OK;
 208 }
 209
 210 int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply)
 211 {
 212     (void)ctx;
 213     (void)reply;
 214     mock().setData("RedisModule_ReplyWithCallReply", 1);
 215     return REDISMODULE_OK;
 216 }
 217
 218 const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len)
 219 {
 220     (void)reply;
 221
 222     if (mock().hasData("RedisModule_String_same"))
 223     {
 224         if (len)
 225             *len = 5;
 226         return "11111";
 227     }
 228
 229     if (mock().hasData("RedisModule_String_nosame"))
 230     {
 231         if (len)
 232             *len = 6;
 233         return "333333";
 234     }
 235
 236     return "11111";
 237 }
 238
 239 RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply)
 240 {
 241     (void)reply;
 242     return (RedisModuleString *)1;
 243 }
 244
 245
 246 int RedisModule_KeyType(RedisModuleKey *kp)
 247 {
 248
 249
 250     (void)kp;
 251     if (mock().hasData("RedisModule_KeyType_empty"))
 252     {
 253         return REDISMODULE_KEYTYPE_EMPTY;
 254     }
 255
 256     if (mock().hasData("RedisModule_KeyType_str"))
 257     {
 258         return REDISMODULE_KEYTYPE_STRING;
 259     }
 260
 261     if (mock().hasData("RedisModule_KeyType_set"))
 262     {
 263
 264         return REDISMODULE_KEYTYPE_SET;
 265     }
 266
 267     return REDISMODULE_KEYTYPE_EMPTY;
 268
 269
 270 }
 271
 272 void RedisModule_CloseKey(RedisModuleKey *kp)
 273 {
 274     (void)kp;
 275     mock().actualCall("RedisModule_CloseKey");
 276 }
 277
 278 /* This is included inline inside each Redis module. */
 279 int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int apiver)
 280 {
 281     (void)ctx;
 282     (void)name;
 283     (void)ver;
 284     (void)apiver;
 285     return REDISMODULE_OK;
 286 }
 287
 288 size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply)
 289 {
 290     (void)reply;
 291     return mock().getData("RedisModule_CallReplyLength").getIntValue();
 292 }
 293
 294
 295 RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx)
 296 {
 297     (void)reply;
 298     (void)idx;
 299     return (RedisModuleCallReply *)1;
 300 }
 301
 302 int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len)
 303 {
 304     (void)ctx;
 305     mock().setData("RedisModule_ReplyWithArray", (int)len);
 306     return REDISMODULE_OK;
 307 }
 308
 309 void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str)
 310 {
 311     (void)ctx;
 312     (void)str;
 313     mock().setData("RedisModule_FreeString", mock().getData("RedisModule_FreeString").getIntValue()+1);
 314     return;
 315 }
 316
 317 RedisModuleBlockedClient *RedisModule_BlockClient(RedisModuleCtx *ctx, RedisModuleCmdFunc reply_callback, RedisModuleCmdFunc timeout_callback, void (*free_privdata)(RedisModuleCtx*,void*), long long timeout_ms)
 318 {
 319     (void)ctx;
 320     (void)reply_callback;
 321     (void)timeout_callback;
 322     (void)free_privdata;
 323     (void)timeout_ms;
 324     RedisModuleBlockedClient *bc = (RedisModuleBlockedClient*)malloc(sizeof(RedisModuleBlockedClient));
 325     mock().setData("RedisModule_BlockClient", 1);
 326     return bc;
 327 }
 328
 329 int RedisModule_UnblockClient(RedisModuleBlockedClient *bc, void *privdata)
 330 {
 331     (void)privdata;
 332     free(bc);
 333     mock().setData("RedisModule_UnblockClient", mock().getData("RedisModule_UnblockClient").getIntValue()+1);
 334     return REDISMODULE_OK;
 335 }
 336
 337 int RedisModule_AbortBlock(RedisModuleBlockedClient *bc)
 338 {
 339     free(bc);
 340     mock().setData("RedisModule_AbortBlock", 1);
 341     return REDISMODULE_OK;
 342 }
 343
 344 RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len)
 345 {
 346     (void)ctx;
 347     (void)ptr;
 348     (void)len;
 349     RedisModuleString *rms = (RedisModuleString*)malloc(sizeof(RedisModuleString));
 350     mock().setData("RedisModule_CreateString", mock().getData("RedisModule_CreateString").getIntValue()+1);
 351     return rms;
 352 }
 353
 354 void RedisModule_FreeThreadSafeContext(RedisModuleCtx *ctx)
 355 {
 356     (void)ctx;
 357     mock().setData("RedisModule_FreeThreadSafeContext", 1);
 358     return;
 359 }
 360
 361 int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll)
 362 {
 363     (void)str;
 364
 365     int call_no = mock().getData("RedisModule_StringToLongLongCallCount").getIntValue();
 366     switch(call_no) {
 367         case 0:
 368             *ll = mock().getData("RedisModule_StringToLongLongCall_1").getIntValue();
 369             break;
 370         case 1:
 371             *ll = mock().getData("RedisModule_StringToLongLongCall_2").getIntValue();
 372             break;
 373         default:
 374             *ll = mock().getData("RedisModule_StringToLongLongCallDefault").getIntValue();
 375     }
 376     mock().setData("RedisModule_StringToLongLongCallCount", call_no + 1);
 377     return REDISMODULE_OK;
 378 }
 379
 380 void RedisModule_ThreadSafeContextLock(RedisModuleCtx *ctx)
 381 {
 382     (void)ctx;
 383     mock().setData("RedisModule_ThreadSafeContextLock", 1);
 384     return;
 385 }
 386
 387 void RedisModule_ThreadSafeContextUnlock(RedisModuleCtx *ctx)
 388 {
 389     (void)ctx;
 390     mock().setData("RedisModule_ThreadSafeContextUnlock", 1);
 391     return;
 392 }
 393
 394 void RedisModule_ReplySetArrayLength(RedisModuleCtx *ctx, long len)
 395 {
 396     (void)ctx;
 397     mock().setData("RedisModule_ReplySetArrayLength", (int)len);
 398     return;
 399 }
 400
 401 RedisModuleCtx *RedisModule_GetThreadSafeContext(RedisModuleBlockedClient *bc)
 402 {
 403     (void) bc;
 404     mock().setData("RedisModule_GetThreadSafeContext", 1);
 405     return NULL;
 406 }
 407
 408 RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll)
 409 {
 410     (void)ctx;
 411     (void)ll;
 412     RedisModuleString *rms = (RedisModuleString*)malloc(sizeof(RedisModuleString));
 413     mock().setData("RedisModule_CreateStringFromLongLong", mock().getData("RedisModule_CreateStringFromLongLong").getIntValue()+1);
 414     return rms;
 415 }
 416
 417 void RedisModule_AutoMemory(RedisModuleCtx *ctx)
 418 {
 419     (void)ctx;
 420     int old = mock().getData("RedisModule_AutoMemory").getIntValue();
 421     mock().setData("RedisModule_AutoMemory", old + 1);
 422     return;
 423 }
 424
 425 void *RedisModule_Alloc(size_t bytes)
 426 {
 427     mock()
 428         .actualCall("RedisModule_Alloc");
 429     return malloc(bytes);
 430 }
 431
 432 void RedisModule_Free(void *ptr)
 433 {
 434     mock()
 435         .actualCall("RedisModule_Free");
 436     free(ptr);
 437 }