redismodule/tst/mock/src/redismoduleNewStub.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 #include "ut_helpers.hpp"
  37
  38 RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...)
  39 {
  40     (void)ctx;
  41     (void)fmt;
  42     return (RedisModuleCallReply *)mock().actualCall("RedisModule_Call")
  43                                          .withParameter("cmdname", cmdname)
  44                                          .returnPointerValueOrDefault(malloc(UT_DUMMY_BUFFER_SIZE));
  45 }
  46
  47 int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str)
  48 {
  49     (void)ctx;
  50     (void)str;
  51     return mock()
  52         .actualCall("RedisModule_ReplyWithString")
  53         .returnIntValueOrDefault(REDISMODULE_OK);
  54 }
  55
  56 RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply)
  57 {
  58     (void)reply;
  59     return (RedisModuleString *)mock().actualCall("RedisModule_CreateStringFromCallReply")
  60         .returnPointerValue();
  61 }
  62
  63 void RedisModule_CloseKey(RedisModuleKey *kp)
  64 {
  65     (void)kp;
  66     mock().actualCall("RedisModule_CloseKey");
  67 }
  68
  69 size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply)
  70 {
  71     (void)reply;
  72     return (size_t)mock().actualCall("RedisModule_CallReplyLength")
  73                          .returnIntValue();
  74 }
  75
  76 int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len)
  77 {
  78     (void)ctx;
  79     return (int)mock().actualCall("RedisModule_ReplyWithArray")
  80                       .withParameter("len", len)
  81                       .returnIntValueOrDefault(REDISMODULE_OK);
  82 }
  83
  84 void RedisModule_ReplySetArrayLength(RedisModuleCtx *ctx, long len)
  85 {
  86     (void)ctx;
  87     mock().actualCall("RedisModule_ReplySetArrayLength")
  88                       .withParameter("len", len);
  89 }
  90
  91 RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len)
  92 {
  93     (void)ctx;
  94     (void)ptr;
  95     (void)len;
  96     void* buf = malloc(UT_DUMMY_BUFFER_SIZE);
  97     return (RedisModuleString *) mock()
  98         .actualCall("RedisModule_CreateString")
  99         .returnPointerValueOrDefault(buf);
 100 }
 101
 102 RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll)
 103 {
 104     (void)ctx;
 105     (void)ll;
 106     void* buf = malloc(UT_DUMMY_BUFFER_SIZE);
 107     return (RedisModuleString *)mock()
 108         .actualCall("RedisModule_CreateStringFromLongLong")
 109         .returnPointerValueOrDefault(buf);
 110 }
 111
 112 void RedisModule_AutoMemory(RedisModuleCtx *ctx)
 113 {
 114     (void)ctx;
 115     mock().actualCall("RedisModule_AutoMemory");
 116 }
 117
 118 void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str)
 119 {
 120     (void)ctx;
 121     free(str);
 122     mock().actualCall("RedisModule_FreeString");
 123 }
 124
 125 int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll)
 126 {
 127     (void)str;
 128     return (int)mock().actualCall("RedisModule_StringToLongLong")
 129                       .withOutputParameter("ll", ll)
 130                       .returnIntValueOrDefault(REDISMODULE_OK);
 131 }
 132
 133 void RedisModule_FreeCallReply(RedisModuleCallReply *reply)
 134 {
 135     free(reply);
 136     mock().actualCall("RedisModule_FreeCallReply");
 137 }
 138
 139 RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx)
 140 {
 141     (void)reply;
 142     (void)idx;
 143     return (RedisModuleCallReply *)mock()
 144         .actualCall("RedisModule_CallReplyArrayElement")
 145         .returnPointerValueOrDefault(NULL);
 146 }
 147
 148 int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll)
 149 {
 150     (void)ctx;
 151     return (int)mock()
 152         .actualCall("RedisModule_ReplyWithLongLong")
 153         .withParameter("ll", (int)ll)
 154         .returnIntValueOrDefault(REDISMODULE_OK);
 155 }
 156
 157 long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply)
 158 {
 159     (void)reply;
 160     return (long long)mock()
 161         .actualCall("RedisModule_CallReplyInteger")
 162         .returnIntValue();
 163 }
 164
 165 int RedisModule_CallReplyType(RedisModuleCallReply *reply)
 166 {
 167     (void)reply;
 168     return (int)mock()
 169         .actualCall("RedisModule_CallReplyType")
 170         .returnIntValue();
 171 }
 172
 173 int RedisModule_WrongArity(RedisModuleCtx *ctx)
 174 {
 175     (void)ctx;
 176     return (int)mock()
 177         .actualCall("RedisModule_WrongArity")
 178         .returnIntValueOrDefault(REDISMODULE_ERR);
 179 }
 180
 181 int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err)
 182 {
 183     (void)ctx;
 184     (void)err;
 185     return (int)mock()
 186         .actualCall("RedisModule_ReplyWithError")
 187         .returnIntValueOrDefault(REDISMODULE_OK);
 188 }
 189
 190 int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply)
 191 {
 192     (void)ctx;
 193     (void)reply;
 194     return (int)mock()
 195         .actualCall("RedisModule_ReplyWithCallReply")
 196         .returnIntValueOrDefault(REDISMODULE_OK);
 197 }
 198
 199 void *RedisModule_OpenKey(RedisModuleCtx *ctx, RedisModuleString *keyname, int mode)
 200 {
 201     (void)ctx;
 202     (void)keyname;
 203     (void)mode;
 204     return (void *)mock()
 205         .actualCall("RedisModule_OpenKey")
 206         .returnPointerValue();
 207 }
 208
 209 int RedisModule_KeyType(RedisModuleKey *kp)
 210 {
 211     (void)kp;
 212     return (int)mock()
 213         .actualCall("RedisModule_KeyType")
 214         .returnIntValue();
 215 }
 216
 217 const char *RedisModule_StringPtrLen(const RedisModuleString *str, size_t *len)
 218 {
 219     (void)str;
 220     if (len != NULL) {
 221         return (const char *)mock()
 222             .actualCall("RedisModule_StringPtrLen")
 223             .withOutputParameter("len", len)
 224             .returnPointerValue();
 225     } else {
 226         return (const char *)mock()
 227             .actualCall("RedisModule_StringPtrLen")
 228             .returnPointerValue();
 229     }
 230 }
 231
 232 RedisModuleBlockedClient *RedisModule_BlockClient(RedisModuleCtx *ctx, RedisModuleCmdFunc reply_callback,
 233                                                   RedisModuleCmdFunc timeout_callback,
 234                                                   void (*free_privdata)(RedisModuleCtx*,void*),
 235                                                   long long timeout_ms)
 236 {
 237     (void)ctx;
 238     (void)reply_callback;
 239     (void)timeout_callback;
 240     (void)free_privdata;
 241     (void)timeout_ms;
 242
 243     void *buf = malloc(UT_DUMMY_BUFFER_SIZE);
 244     return (RedisModuleBlockedClient *)mock()
 245         .actualCall("RedisModule_BlockClient")
 246         .returnPointerValueOrDefault(buf);
 247 }
 248
 249 int RedisModule_UnblockClient(RedisModuleBlockedClient *bc, void *privdata)
 250 {
 251     (void)privdata;
 252
 253     free(bc);
 254     return (int)mock()
 255         .actualCall("RedisModule_UnblockClient")
 256         .returnIntValueOrDefault(REDISMODULE_OK);
 257 }
 258
 259 const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len)
 260 {
 261     (void)reply;
 262     (void)len;
 263
 264     static char cursor_zero_literal[] = "0";
 265     return (const char *)mock()
 266         .actualCall("RedisModule_CallReplyStringPtr")
 267         .returnPointerValueOrDefault(cursor_zero_literal);
 268 }
 269
 270 int RedisModule_AbortBlock(RedisModuleBlockedClient *bc)
 271 {
 272     free(bc);
 273     return mock()
 274         .actualCall("RedisModule_AbortBlock")
 275         .returnIntValueOrDefault(REDISMODULE_OK);
 276 }
 277
 278 int RedisModule_ReplyWithNull(RedisModuleCtx *ctx)
 279 {
 280     (void)ctx;
 281     return mock()
 282         .actualCall("RedisModule_ReplyWithNull")
 283         .returnIntValueOrDefault(REDISMODULE_OK);
 284 }
 285
 286 void RedisModule_ThreadSafeContextUnlock(RedisModuleCtx *ctx)
 287 {
 288     (void)ctx;
 289     int tmp = mock().getData("TimesThreadSafeContextWasUnlocked").getIntValue();
 290     mock().setData("TimesThreadSafeContextWasUnlocked", tmp + 1);
 291     mock()
 292         .actualCall("RedisModule_ThreadSafeContextUnlock");
 293 }
 294
 295 void RedisModule_ThreadSafeContextLock(RedisModuleCtx *ctx)
 296 {
 297     (void)ctx;
 298     int tmp = mock().getData("TimesThreadSafeContextWasLocked").getIntValue();
 299     mock().setData("TimesThreadSafeContextWasLocked", tmp + 1);
 300     mock()
 301         .actualCall("RedisModule_ThreadSafeContextLock");
 302 }
 303
 304 RedisModuleCtx *RedisModule_GetThreadSafeContext(RedisModuleBlockedClient *bc)
 305 {
 306     (void)bc;
 307     return (RedisModuleCtx *)mock()
 308         .actualCall("RedisModule_GetThreadSafeContext")
 309         .returnPointerValueOrDefault(0);
 310 }
 311
 312 void RedisModule_FreeThreadSafeContext(RedisModuleCtx *ctx)
 313 {
 314     (void)ctx;
 315     mock()
 316         .actualCall("RedisModule_FreeThreadSafeContext");
 317 }
 318
 319 /* This is included inline inside each Redis module. */
 320 int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int apiver)
 321 {
 322     (void)ctx;
 323     (void)name;
 324     (void)ver;
 325     (void)apiver;
 326
 327     return mock()
 328         .actualCall("RedisModule_Init")
 329         .returnIntValueOrDefault(REDISMODULE_OK);
 330 }
 331
 332 int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep)
 333 {
 334     (void)ctx;
 335     (void)name;
 336     (void)cmdfunc;
 337     (void)strflags;
 338     (void)firstkey;
 339     (void)lastkey;
 340     (void)keystep;
 341
 342     return mock()
 343         .actualCall("RedisModule_CreateCommand")
 344         .returnIntValueOrDefault(REDISMODULE_OK);
 345 }
 346
 347 void *RedisModule_Alloc(size_t bytes)
 348 {
 349     void *buf = malloc(bytes);
 350     return mock()
 351         .actualCall("RedisModule_Alloc")
 352         .returnPointerValueOrDefault(buf);
 353 }
 354
 355 void RedisModule_Free(void *ptr)
 356 {
 357     free(ptr);
 358     mock()
 359         .actualCall("RedisModule_Free");
 360 }