redismodule/tst/mock/src/redismoduleStub.cpp

   1 /*
   2  * Copyright (c) 2018-2019 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 <CppUTest/TestHarness.h>
  24 #include <CppUTestExt/MockSupport.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27
  28
  29
  30
  31 extern "C" {
  32 #include "redismodule.h"
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <ctype.h>
  36 }
  37
  38
  39 int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep)
  40 {
  41     (void)ctx;
  42     (void)name;
  43     (void)cmdfunc;
  44     (void)strflags;
  45     (void)firstkey;
  46     (void)lastkey;
  47     (void)keystep;
  48     return REDISMODULE_OK;
  49
  50 }
  51
  52 int RedisModule_WrongArity(RedisModuleCtx *ctx)
  53 {
  54     (void)ctx;
  55     return REDISMODULE_ERR;
  56 }
  57
  58 int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll)
  59 {
  60
  61     (void)ctx;
  62     mock().setData("RedisModule_ReplyWithLongLong", (int)ll);
  63     return REDISMODULE_OK;
  64 }
  65
  66 void *RedisModule_OpenKey(RedisModuleCtx *ctx, RedisModuleString *keyname, int mode)
  67 {
  68     (void)ctx;
  69     (void)keyname;
  70     (void)mode;
  71
  72     if (mock().hasData("RedisModule_OpenKey_no"))
  73     {
  74         return (void*)(0);
  75     }
  76
  77     if (mock().hasData("RedisModule_OpenKey_have"))
  78     {
  79         return (void*)(111111);
  80     }
  81
  82
  83     return (void*)(0);
  84 }
  85
  86 RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...)
  87 {
  88     (void)ctx;
  89     (void)cmdname;
  90     (void)fmt;
  91
  92     if (!strcmp(cmdname, "GET"))
  93         mock().setData("GET", 1);
  94     else if (!strcmp(cmdname, "SET"))
  95         mock().setData("SET", 1);
  96     else if (!strcmp(cmdname, "MSET"))
  97         mock().setData("MSET", 1);
  98     else if (!strcmp(cmdname, "DEL"))
  99         mock().setData("DEL", 1);
 100     else if (!strcmp(cmdname, "UNLINK"))
 101         mock().setData("UNLINK", 1);
 102     else if (!strcmp(cmdname, "PUBLISH"))
 103         mock().setData("PUBLISH", mock().getData("PUBLISH").getIntValue() + 1);
 104     else if (!strcmp(cmdname, "KEYS"))
 105         mock().setData("KEYS", 1);
 106     else if (!strcmp(cmdname, "MGET"))
 107         mock().setData("MGET", 1);
 108
 109     if (mock().hasData("RedisModule_Call_Return_Null"))
 110         return NULL;
 111     else
 112         return (RedisModuleCallReply *)1;
 113 }
 114
 115 void RedisModule_FreeCallReply(RedisModuleCallReply *reply)
 116 {
 117     (void)reply;
 118     mock().setData("RedisModule_FreeCallReply", mock().getData("RedisModule_FreeCallReply").getIntValue()+1);
 119 }
 120
 121 int RedisModule_CallReplyType(RedisModuleCallReply *reply)
 122 {
 123
 124     (void)reply;
 125     if (mock().hasData("RedisModule_CallReplyType_null"))
 126     {
 127         return REDISMODULE_REPLY_NULL;
 128     }
 129
 130     if (mock().hasData("RedisModule_CallReplyType_inter"))
 131     {
 132         return REDISMODULE_REPLY_INTEGER;
 133     }
 134
 135     if (mock().hasData("RedisModule_CallReplyType_str"))
 136     {
 137         return REDISMODULE_REPLY_STRING;
 138     }
 139
 140     if (mock().hasData("RedisModule_CallReplyType_err"))
 141     {
 142         return REDISMODULE_REPLY_ERROR;
 143     }
 144
 145     return REDISMODULE_REPLY_NULL;;
 146
 147 }
 148
 149 long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply)
 150 {
 151
 152     (void)reply;
 153     return mock().getData("RedisModule_CallReplyInteger").getIntValue();
 154 }
 155
 156 const char *RedisModule_StringPtrLen(const RedisModuleString *str, size_t *len)
 157 {
 158
 159     (void)str;
 160     *len = 5;
 161     if (mock().hasData("RedisModule_String_same"))
 162     {
 163         return "11111";
 164     }
 165
 166     if (mock().hasData("RedisModule_String_nosame"))
 167     {
 168         return "22222";
 169     }
 170
 171     return "11111";
 172 }
 173
 174 int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err)
 175 {
 176     (void)ctx;
 177     (void)err;
 178     mock().setData("RedisModule_ReplyWithError", 1);
 179     return REDISMODULE_OK;
 180 }
 181
 182 int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str)
 183 {
 184     (void)ctx;
 185     (void)str;
 186     mock().setData("RedisModule_ReplyWithString", mock().getData("RedisModule_ReplyWithString").getIntValue()+1);
 187     return REDISMODULE_OK;
 188 }
 189
 190 int RedisModule_ReplyWithNull(RedisModuleCtx *ctx)
 191 {
 192
 193     (void)ctx;
 194     mock().setData("RedisModule_ReplyWithNull", 1);
 195     return REDISMODULE_OK;
 196 }
 197
 198 int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply)
 199 {
 200     (void)ctx;
 201     (void)reply;
 202     mock().setData("RedisModule_ReplyWithCallReply", 1);
 203     return REDISMODULE_OK;
 204 }
 205
 206 const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len)
 207 {
 208     (void)reply;
 209
 210     *len = 5;
 211
 212     if (mock().hasData("RedisModule_String_same"))
 213     {
 214         return "11111";
 215     }
 216
 217
 218     if (mock().hasData("RedisModule_String_nosame"))
 219     {
 220         *len = 6;
 221         return "333333";
 222     }
 223
 224     return "11111";
 225 }
 226
 227 RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply)
 228 {
 229     (void)reply;
 230     return (RedisModuleString *)1;
 231 }
 232
 233
 234 int RedisModule_KeyType(RedisModuleKey *kp)
 235 {
 236
 237
 238     (void)kp;
 239     if (mock().hasData("RedisModule_KeyType_empty"))
 240     {
 241         return REDISMODULE_KEYTYPE_EMPTY;
 242     }
 243
 244     if (mock().hasData("RedisModule_KeyType_str"))
 245     {
 246         return REDISMODULE_KEYTYPE_STRING;
 247     }
 248
 249     if (mock().hasData("RedisModule_KeyType_set"))
 250     {
 251
 252         return REDISMODULE_KEYTYPE_SET;
 253     }
 254
 255     return REDISMODULE_KEYTYPE_EMPTY;
 256
 257
 258 }
 259
 260 void RedisModule_CloseKey(RedisModuleKey *kp)
 261 {
 262     (void)kp;
 263     mock().actualCall("RedisModule_CloseKey");
 264 }
 265
 266 /* This is included inline inside each Redis module. */
 267 int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int apiver)
 268 {
 269     (void)ctx;
 270     (void)name;
 271     (void)ver;
 272     (void)apiver;
 273     return REDISMODULE_OK;
 274 }
 275
 276 size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply)
 277 {
 278     (void)reply;
 279     return mock().getData("RedisModule_CallReplyLength").getIntValue();
 280 }
 281
 282
 283 RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx)
 284 {
 285     (void)reply;
 286     (void)idx;
 287     return (RedisModuleCallReply *)1;
 288 }
 289
 290 int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len)
 291 {
 292     (void)ctx;
 293     mock().setData("RedisModule_ReplyWithArray", (int)len);
 294     return REDISMODULE_OK;
 295 }
 296
 297 int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll)
 298 {
 299     (void) str;
 300     int call_no = mock().getData("RedisModule_StringToLongLongCallCount").getIntValue();
 301     switch(call_no) {
 302         case 0:
 303             *ll = mock().getData("RedisModule_StringToLongLongCall_1").getIntValue();
 304             break;
 305         case 1:
 306             *ll = mock().getData("RedisModule_StringToLongLongCall_2").getIntValue();
 307             break;
 308         default:
 309             *ll = mock().getData("RedisModule_StringToLongLongCallDefault").getIntValue();
 310     }
 311     mock().setData("RedisModule_StringToLongLongCallCount", call_no + 1);
 312     return REDISMODULE_OK;
 313 }