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