2 * Copyright (c) 2018-2020 Nokia.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * This source code is part of the near-RT RIC (RAN Intelligent Controller)
19 * platform project (RICP).
27 #include "redismodule.h"
33 #include <CppUTest/TestHarness.h>
34 #include <CppUTestExt/MockSupport.h>
36 #include "ut_helpers.hpp"
38 RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...)
42 return (RedisModuleCallReply *)mock().actualCall("RedisModule_Call")
43 .withParameter("cmdname", cmdname)
44 .returnPointerValueOrDefault(malloc(UT_DUMMY_BUFFER_SIZE));
47 int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str)
52 .actualCall("RedisModule_ReplyWithString")
53 .returnIntValueOrDefault(REDISMODULE_OK);
56 RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply)
59 return (RedisModuleString *)mock().actualCall("RedisModule_CreateStringFromCallReply")
60 .returnPointerValue();
63 void RedisModule_CloseKey(RedisModuleKey *kp)
66 mock().actualCall("RedisModule_CloseKey");
69 size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply)
72 return (size_t)mock().actualCall("RedisModule_CallReplyLength")
76 int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len)
79 return (int)mock().actualCall("RedisModule_ReplyWithArray")
80 .withParameter("len", len)
81 .returnIntValueOrDefault(REDISMODULE_OK);
84 void RedisModule_ReplySetArrayLength(RedisModuleCtx *ctx, long len)
87 mock().actualCall("RedisModule_ReplySetArrayLength")
88 .withParameter("len", len);
91 RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len)
96 void* buf = malloc(UT_DUMMY_BUFFER_SIZE);
97 return (RedisModuleString *) mock()
98 .actualCall("RedisModule_CreateString")
99 .returnPointerValueOrDefault(buf);
102 RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll)
106 void* buf = malloc(UT_DUMMY_BUFFER_SIZE);
107 return (RedisModuleString *)mock()
108 .actualCall("RedisModule_CreateStringFromLongLong")
109 .returnPointerValueOrDefault(buf);
112 void RedisModule_AutoMemory(RedisModuleCtx *ctx)
115 mock().actualCall("RedisModule_AutoMemory");
118 void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str)
122 mock().actualCall("RedisModule_FreeString");
125 int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll)
128 return (int)mock().actualCall("RedisModule_StringToLongLong")
129 .withOutputParameter("ll", ll)
130 .returnIntValueOrDefault(REDISMODULE_OK);
133 void RedisModule_FreeCallReply(RedisModuleCallReply *reply)
136 mock().actualCall("RedisModule_FreeCallReply");
139 RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx)
143 return (RedisModuleCallReply *)mock()
144 .actualCall("RedisModule_CallReplyArrayElement")
145 .returnPointerValueOrDefault(NULL);
148 int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll)
152 .actualCall("RedisModule_ReplyWithLongLong")
153 .withParameter("ll", (int)ll)
154 .returnIntValueOrDefault(REDISMODULE_OK);
157 long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply)
160 return (long long)mock()
161 .actualCall("RedisModule_CallReplyInteger")
165 int RedisModule_CallReplyType(RedisModuleCallReply *reply)
169 .actualCall("RedisModule_CallReplyType")
173 int RedisModule_WrongArity(RedisModuleCtx *ctx)
177 .actualCall("RedisModule_WrongArity")
178 .returnIntValueOrDefault(REDISMODULE_ERR);
181 int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err)
186 .actualCall("RedisModule_ReplyWithError")
187 .returnIntValueOrDefault(REDISMODULE_OK);
190 int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply)
195 .actualCall("RedisModule_ReplyWithCallReply")
196 .returnIntValueOrDefault(REDISMODULE_OK);
199 void *RedisModule_OpenKey(RedisModuleCtx *ctx, RedisModuleString *keyname, int mode)
204 return (void *)mock()
205 .actualCall("RedisModule_OpenKey")
206 .returnPointerValue();
209 int RedisModule_KeyType(RedisModuleKey *kp)
213 .actualCall("RedisModule_KeyType")
217 const char *RedisModule_StringPtrLen(const RedisModuleString *str, size_t *len)
221 return (const char *)mock()
222 .actualCall("RedisModule_StringPtrLen")
223 .withOutputParameter("len", len)
224 .returnPointerValue();
226 return (const char *)mock()
227 .actualCall("RedisModule_StringPtrLen")
228 .returnPointerValue();
232 RedisModuleBlockedClient *RedisModule_BlockClient(RedisModuleCtx *ctx, RedisModuleCmdFunc reply_callback,
233 RedisModuleCmdFunc timeout_callback,
234 void (*free_privdata)(RedisModuleCtx*,void*),
235 long long timeout_ms)
238 (void)reply_callback;
239 (void)timeout_callback;
243 void *buf = malloc(UT_DUMMY_BUFFER_SIZE);
244 return (RedisModuleBlockedClient *)mock()
245 .actualCall("RedisModule_BlockClient")
246 .returnPointerValueOrDefault(buf);
249 int RedisModule_UnblockClient(RedisModuleBlockedClient *bc, void *privdata)
255 .actualCall("RedisModule_UnblockClient")
256 .returnIntValueOrDefault(REDISMODULE_OK);
259 const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len)
264 static char cursor_zero_literal[] = "0";
265 return (const char *)mock()
266 .actualCall("RedisModule_CallReplyStringPtr")
267 .returnPointerValueOrDefault(cursor_zero_literal);
270 int RedisModule_AbortBlock(RedisModuleBlockedClient *bc)
274 .actualCall("RedisModule_AbortBlock")
275 .returnIntValueOrDefault(REDISMODULE_OK);
278 int RedisModule_ReplyWithNull(RedisModuleCtx *ctx)
282 .actualCall("RedisModule_ReplyWithNull")
283 .returnIntValueOrDefault(REDISMODULE_OK);
286 void RedisModule_ThreadSafeContextUnlock(RedisModuleCtx *ctx)
289 int tmp = mock().getData("TimesThreadSafeContextWasUnlocked").getIntValue();
290 mock().setData("TimesThreadSafeContextWasUnlocked", tmp + 1);
292 .actualCall("RedisModule_ThreadSafeContextUnlock");
295 void RedisModule_ThreadSafeContextLock(RedisModuleCtx *ctx)
298 int tmp = mock().getData("TimesThreadSafeContextWasLocked").getIntValue();
299 mock().setData("TimesThreadSafeContextWasLocked", tmp + 1);
301 .actualCall("RedisModule_ThreadSafeContextLock");
304 RedisModuleCtx *RedisModule_GetThreadSafeContext(RedisModuleBlockedClient *bc)
307 return (RedisModuleCtx *)mock()
308 .actualCall("RedisModule_GetThreadSafeContext")
309 .returnPointerValueOrDefault(0);
312 void RedisModule_FreeThreadSafeContext(RedisModuleCtx *ctx)
316 .actualCall("RedisModule_FreeThreadSafeContext");
319 /* This is included inline inside each Redis module. */
320 int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int apiver)
328 .actualCall("RedisModule_Init")
329 .returnIntValueOrDefault(REDISMODULE_OK);
332 int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep)
343 .actualCall("RedisModule_CreateCommand")
344 .returnIntValueOrDefault(REDISMODULE_OK);
347 void *RedisModule_Alloc(size_t bytes)
349 void *buf = malloc(bytes);
351 .actualCall("RedisModule_Alloc")
352 .returnPointerValueOrDefault(buf);
355 void RedisModule_Free(void *ptr)
359 .actualCall("RedisModule_Free");