mirror of
https://github.com/oven-sh/bun
synced 2026-02-09 10:28:47 +00:00
90c0c72212
### What does this PR do? Adds a new test which mirrors the _callback errors don't crash the client_ test but doesn't rely on IPC. ### How did you verify your code works? Hopefully, CI
6904 lines
234 KiB
TypeScript
6904 lines
234 KiB
TypeScript
import { randomUUIDv7, RedisClient, spawn } from "bun";
|
|
import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
|
|
import { bunExe, bunRun } from "harness";
|
|
import { join } from "node:path";
|
|
import {
|
|
ctx as _ctx,
|
|
awaitableCounter,
|
|
ConnectionType,
|
|
createClient,
|
|
DEFAULT_REDIS_URL,
|
|
expectType,
|
|
isEnabled,
|
|
randomCoinFlip,
|
|
setupDockerContainer,
|
|
TLS_REDIS_OPTIONS,
|
|
TLS_REDIS_URL,
|
|
} from "./test-utils";
|
|
import type { RedisTestStartMessage } from "./valkey.failing-subscriber";
|
|
import type { Message } from "./valkey.failing-subscriber-no-ipc";
|
|
|
|
for (const connectionType of [ConnectionType.TLS, ConnectionType.TCP]) {
|
|
const ctx = { ..._ctx, redis: connectionType ? _ctx.redis : (_ctx.redisTLS as RedisClient) };
|
|
describe.skipIf(!isEnabled)(`Valkey Redis Client (${connectionType})`, () => {
|
|
beforeAll(async () => {
|
|
await setupDockerContainer();
|
|
if (!ctx.redis) {
|
|
ctx.redis = createClient(connectionType);
|
|
}
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
if (!ctx.redis) {
|
|
ctx.redis = createClient(connectionType);
|
|
}
|
|
|
|
await ctx.redis.connect();
|
|
await ctx.redis.send("FLUSHALL", ["SYNC"]);
|
|
});
|
|
|
|
describe("Basic Operations", () => {
|
|
test("should keep process alive when connecting", async () => {
|
|
const result = bunRun(join(import.meta.dir, "valkey.connecting.fixture.ts"), {
|
|
"BUN_VALKEY_URL": connectionType === ConnectionType.TLS ? TLS_REDIS_URL : DEFAULT_REDIS_URL,
|
|
"BUN_VALKEY_TLS": connectionType === ConnectionType.TLS ? JSON.stringify(TLS_REDIS_OPTIONS.tlsPaths) : "",
|
|
});
|
|
expect(result.stdout).toContain(`connected`);
|
|
});
|
|
|
|
test("should set and get strings", async () => {
|
|
const redis = ctx.redis;
|
|
const testKey = "greeting";
|
|
const testValue = "Hello from Bun Redis!";
|
|
|
|
const setResult = await redis.set(testKey, testValue);
|
|
expect(setResult).toMatchInlineSnapshot(`"OK"`);
|
|
|
|
const setResult2 = await redis.set(testKey, testValue, "GET");
|
|
expect(setResult2).toMatchInlineSnapshot(`"${testValue}"`);
|
|
|
|
const getValue = await redis.get(testKey);
|
|
expect(getValue).toMatchInlineSnapshot(`"${testValue}"`);
|
|
});
|
|
|
|
test("should test key existence", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("greeting", "test existence");
|
|
|
|
const exists = await redis.exists("greeting");
|
|
expect(exists).toBeDefined();
|
|
|
|
expect(exists).toBe(true);
|
|
|
|
const randomKey = "nonexistent-key-" + randomUUIDv7();
|
|
const notExists = await redis.exists(randomKey);
|
|
expect(notExists).toBeDefined();
|
|
|
|
expect(notExists).toBe(false);
|
|
});
|
|
|
|
test("should increment and decrement counters", async () => {
|
|
const redis = ctx.redis;
|
|
const counterKey = "counter";
|
|
|
|
await redis.set(counterKey, "10");
|
|
|
|
const incrementedValue = await redis.incr(counterKey);
|
|
expect(incrementedValue).toBeDefined();
|
|
expect(typeof incrementedValue).toBe("number");
|
|
expect(incrementedValue).toBe(11);
|
|
|
|
const decrementedValue = await redis.decr(counterKey);
|
|
expect(decrementedValue).toBeDefined();
|
|
expect(typeof decrementedValue).toBe("number");
|
|
expect(decrementedValue).toBe(10);
|
|
});
|
|
|
|
test("should increment by specified amount with INCRBY", async () => {
|
|
const redis = ctx.redis;
|
|
const counterKey = "incrby-counter";
|
|
await redis.set(counterKey, "5");
|
|
|
|
const result1 = await redis.incrby(counterKey, 10);
|
|
expect(result1).toBe(15);
|
|
|
|
const result2 = await redis.incrby(counterKey, -3);
|
|
expect(result2).toBe(12);
|
|
|
|
const result3 = await redis.incrby("new-incrby-key", 5);
|
|
expect(result3).toBe(5);
|
|
});
|
|
|
|
test("should increment by float amount with INCRBYFLOAT", async () => {
|
|
const redis = ctx.redis;
|
|
const floatKey = "float-counter";
|
|
await redis.set(floatKey, "10.5");
|
|
|
|
const result1 = await redis.incrbyfloat(floatKey, 2.3);
|
|
expect(result1).toBe("12.8");
|
|
|
|
const result2 = await redis.incrbyfloat(floatKey, -0.8);
|
|
expect(result2).toBe("12");
|
|
|
|
const result3 = await redis.incrbyfloat("new-float-key", 3.14);
|
|
expect(result3).toBe("3.14");
|
|
});
|
|
|
|
test("should decrement by specified amount with DECRBY", async () => {
|
|
const redis = ctx.redis;
|
|
const counterKey = "decrby-counter";
|
|
await redis.set(counterKey, "20");
|
|
|
|
const result1 = await redis.decrby(counterKey, 5);
|
|
expect(result1).toBe(15);
|
|
|
|
const result2 = await redis.decrby(counterKey, 10);
|
|
expect(result2).toBe(5);
|
|
|
|
const result3 = await redis.decrby("new-decrby-key", 3);
|
|
expect(result3).toBe(-3);
|
|
});
|
|
|
|
test("should rename a key with RENAME", async () => {
|
|
const redis = ctx.redis;
|
|
const oldKey = "old-key";
|
|
const newKey = "new-key";
|
|
const value = "test-value";
|
|
|
|
await redis.set(oldKey, value);
|
|
|
|
const result = await redis.rename(oldKey, newKey);
|
|
expect(result).toBe("OK");
|
|
|
|
const newValue = await redis.get(newKey);
|
|
expect(newValue).toBe(value);
|
|
|
|
const oldValue = await redis.get(oldKey);
|
|
expect(oldValue).toBeNull();
|
|
});
|
|
|
|
test("should rename a key with RENAME overwriting existing key", async () => {
|
|
const redis = ctx.redis;
|
|
const oldKey = "old-key-overwrite";
|
|
const newKey = "new-key-overwrite";
|
|
|
|
await redis.set(oldKey, "old-value");
|
|
await redis.set(newKey, "existing-value");
|
|
|
|
const result = await redis.rename(oldKey, newKey);
|
|
expect(result).toBe("OK");
|
|
|
|
const newValue = await redis.get(newKey);
|
|
expect(newValue).toBe("old-value");
|
|
|
|
const oldValue = await redis.get(oldKey);
|
|
expect(oldValue).toBeNull();
|
|
});
|
|
|
|
test("should rename a key only if new key does not exist with RENAMENX", async () => {
|
|
const redis = ctx.redis;
|
|
const oldKey = "old-key-nx";
|
|
const newKey = "new-key-nx";
|
|
const value = "test-value";
|
|
|
|
await redis.set(oldKey, value);
|
|
|
|
const result1 = await redis.renamenx(oldKey, newKey);
|
|
expect(result1).toBe(1);
|
|
|
|
const newValue = await redis.get(newKey);
|
|
expect(newValue).toBe(value);
|
|
|
|
const oldValue = await redis.get(oldKey);
|
|
expect(oldValue).toBeNull();
|
|
});
|
|
|
|
test("should not rename if new key exists with RENAMENX", async () => {
|
|
const redis = ctx.redis;
|
|
const oldKey = "old-key-nx-fail";
|
|
const newKey = "new-key-nx-fail";
|
|
|
|
await redis.set(oldKey, "old-value");
|
|
await redis.set(newKey, "existing-value");
|
|
|
|
const result = await redis.renamenx(oldKey, newKey);
|
|
expect(result).toBe(0);
|
|
|
|
const oldValue = await redis.get(oldKey);
|
|
expect(oldValue).toBe("old-value");
|
|
|
|
const newValue = await redis.get(newKey);
|
|
expect(newValue).toBe("existing-value");
|
|
});
|
|
|
|
test("should set multiple keys with MSET", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.mset("mset-key1", "value1", "mset-key2", "value2", "mset-key3", "value3");
|
|
expect(result).toBe("OK");
|
|
|
|
const value1 = await redis.get("mset-key1");
|
|
expect(value1).toBe("value1");
|
|
const value2 = await redis.get("mset-key2");
|
|
expect(value2).toBe("value2");
|
|
const value3 = await redis.get("mset-key3");
|
|
expect(value3).toBe("value3");
|
|
});
|
|
|
|
test("should set multiple keys only if none exist with MSETNX", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result1 = await redis.msetnx("msetnx-key1", "value1", "msetnx-key2", "value2");
|
|
expect(result1).toBe(1);
|
|
|
|
const value1 = await redis.get("msetnx-key1");
|
|
expect(value1).toBe("value1");
|
|
const value2 = await redis.get("msetnx-key2");
|
|
expect(value2).toBe("value2");
|
|
|
|
const result2 = await redis.msetnx("msetnx-key1", "newvalue", "msetnx-key3", "value3");
|
|
expect(result2).toBe(0);
|
|
|
|
const unchangedValue = await redis.get("msetnx-key1");
|
|
expect(unchangedValue).toBe("value1");
|
|
|
|
const nonExistentKey = await redis.get("msetnx-key3");
|
|
expect(nonExistentKey).toBeNull();
|
|
});
|
|
|
|
test("should manage key expiration", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const tempKey = "temporary";
|
|
await redis.set(tempKey, "will expire");
|
|
|
|
const result = await redis.expire(tempKey, 60);
|
|
|
|
expect(result).toMatchInlineSnapshot(`1`);
|
|
|
|
const ttl = await redis.ttl(tempKey);
|
|
expectType<number>(ttl, "number");
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(60);
|
|
});
|
|
|
|
test("should set key with expiration using SETEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "setex-test-key";
|
|
const value = "test-value";
|
|
|
|
const result = await redis.setex(key, 10, value);
|
|
expect(result).toBe("OK");
|
|
|
|
const getValue = await redis.get(key);
|
|
expect(getValue).toBe(value);
|
|
|
|
const ttl = await redis.ttl(key);
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(10);
|
|
});
|
|
|
|
test("should set key with expiration using PSETEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "psetex-test-key";
|
|
const value = "test-value";
|
|
|
|
const result = await redis.psetex(key, 5000, value);
|
|
expect(result).toBe("OK");
|
|
|
|
const getValue = await redis.get(key);
|
|
expect(getValue).toBe(value);
|
|
|
|
const pttl = await redis.pttl(key);
|
|
expect(pttl).toBeGreaterThan(0);
|
|
expect(pttl).toBeLessThanOrEqual(5000);
|
|
});
|
|
|
|
test("should set expiration with EXPIREAT using Unix timestamp", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "expireat-test-key";
|
|
await redis.set(key, "test-value");
|
|
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 60;
|
|
const result = await redis.expireat(key, futureTimestamp);
|
|
expect(result).toBe(1);
|
|
|
|
const ttl = await redis.ttl(key);
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(60);
|
|
});
|
|
|
|
test("should return 0 for EXPIREAT on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 60;
|
|
const result = await redis.expireat("nonexistent-expireat-key", futureTimestamp);
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test("should set expiration with PEXPIRE in milliseconds", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "pexpire-test-key";
|
|
await redis.set(key, "test-value");
|
|
|
|
const result = await redis.pexpire(key, 5000);
|
|
expect(result).toBe(1);
|
|
|
|
const pttl = await redis.pttl(key);
|
|
expect(pttl).toBeGreaterThan(0);
|
|
expect(pttl).toBeLessThanOrEqual(5050);
|
|
});
|
|
|
|
test("should return 0 for PEXPIRE on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
const result = await redis.pexpire("nonexistent-pexpire-key", 5000);
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test("should set expiration with PEXPIREAT using Unix timestamp in milliseconds", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "pexpireat-test-key";
|
|
await redis.set(key, "test-value");
|
|
|
|
const futureTimestampMs = Date.now() + 5000;
|
|
const result = await redis.pexpireat(key, futureTimestampMs);
|
|
expect(result).toBe(1);
|
|
|
|
const pttl = await redis.pttl(key);
|
|
expect(pttl).toBeGreaterThan(0);
|
|
expect(pttl).toBeLessThanOrEqual(5050);
|
|
});
|
|
|
|
test("should return 0 for PEXPIREAT on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
const futureTimestampMs = Date.now() + 5000;
|
|
const result = await redis.pexpireat("nonexistent-pexpireat-key", futureTimestampMs);
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test("should determine the type of a key with TYPE", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("string-key", "value");
|
|
const stringType = await redis.type("string-key");
|
|
expect(stringType).toBe("string");
|
|
|
|
await redis.lpush("list-key", "value");
|
|
const listType = await redis.type("list-key");
|
|
expect(listType).toBe("list");
|
|
|
|
await redis.sadd("set-key", "value");
|
|
const setType = await redis.type("set-key");
|
|
expect(setType).toBe("set");
|
|
|
|
await redis.send("HSET", ["hash-key", "field", "value"]);
|
|
const hashType = await redis.type("hash-key");
|
|
expect(hashType).toBe("hash");
|
|
|
|
const noneType = await redis.type("nonexistent-key");
|
|
expect(noneType).toBe("none");
|
|
});
|
|
|
|
test("should update last access time with TOUCH", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("touch-key1", "value1");
|
|
await redis.set("touch-key2", "value2");
|
|
|
|
const touchedCount = await redis.touch("touch-key1", "touch-key2");
|
|
expect(touchedCount).toBe(2);
|
|
|
|
const mixedCount = await redis.touch("touch-key1", "nonexistent-key");
|
|
expect(mixedCount).toBe(1);
|
|
|
|
const noneCount = await redis.touch("nonexistent-key1", "nonexistent-key2");
|
|
expect(noneCount).toBe(0);
|
|
});
|
|
|
|
test("should get and set bits", async () => {
|
|
const redis = ctx.redis;
|
|
const bitKey = "mybitkey";
|
|
|
|
const oldValue = await redis.setbit(bitKey, 7, 1);
|
|
expect(oldValue).toBe(0);
|
|
|
|
const bitValue = await redis.getbit(bitKey, 7);
|
|
expect(bitValue).toBe(1);
|
|
|
|
const unsetBit = await redis.getbit(bitKey, 100);
|
|
expect(unsetBit).toBe(0);
|
|
|
|
const oldValue2 = await redis.setbit(bitKey, 7, 0);
|
|
expect(oldValue2).toBe(1);
|
|
|
|
const bitValue2 = await redis.getbit(bitKey, 7);
|
|
expect(bitValue2).toBe(0);
|
|
});
|
|
|
|
test("should handle multiple bit operations", async () => {
|
|
const redis = ctx.redis;
|
|
const bitKey = "multibit";
|
|
|
|
await redis.setbit(bitKey, 0, 1);
|
|
await redis.setbit(bitKey, 3, 1);
|
|
await redis.setbit(bitKey, 7, 1);
|
|
|
|
expect(await redis.getbit(bitKey, 0)).toBe(1);
|
|
expect(await redis.getbit(bitKey, 1)).toBe(0);
|
|
expect(await redis.getbit(bitKey, 2)).toBe(0);
|
|
expect(await redis.getbit(bitKey, 3)).toBe(1);
|
|
expect(await redis.getbit(bitKey, 4)).toBe(0);
|
|
expect(await redis.getbit(bitKey, 5)).toBe(0);
|
|
expect(await redis.getbit(bitKey, 6)).toBe(0);
|
|
expect(await redis.getbit(bitKey, 7)).toBe(1);
|
|
|
|
const count = await redis.bitcount(bitKey);
|
|
expect(count).toBe(3);
|
|
});
|
|
|
|
test("should get range of string", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "rangetest";
|
|
await redis.set(key, "Hello World");
|
|
|
|
const result1 = await redis.getrange(key, 0, 4);
|
|
expect(result1).toBe("Hello");
|
|
|
|
const result2 = await redis.getrange(key, 6, 10);
|
|
expect(result2).toBe("World");
|
|
|
|
const result3 = await redis.getrange(key, -5, -1);
|
|
expect(result3).toBe("World");
|
|
|
|
const result4 = await redis.getrange(key, 0, -1);
|
|
expect(result4).toBe("Hello World");
|
|
});
|
|
|
|
test("should set range of string", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "setrangetest";
|
|
await redis.set(key, "Hello World");
|
|
|
|
const newLength = await redis.setrange(key, 6, "Redis");
|
|
expect(newLength).toBe(11);
|
|
|
|
const result = await redis.get(key);
|
|
expect(result).toBe("Hello Redis");
|
|
|
|
const key2 = "newkey";
|
|
const newLength2 = await redis.setrange(key2, 5, "Redis");
|
|
expect(newLength2).toBeGreaterThanOrEqual(10);
|
|
});
|
|
|
|
test("should append to string with APPEND", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "append-test";
|
|
|
|
const len1 = await redis.append(key, "Hello");
|
|
expect(len1).toBe(5);
|
|
|
|
const len2 = await redis.append(key, " World");
|
|
expect(len2).toBe(11);
|
|
|
|
const value = await redis.get(key);
|
|
expect(value).toBe("Hello World");
|
|
});
|
|
|
|
test("should delete keys with DEL", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("del-key1", "value1");
|
|
await redis.set("del-key2", "value2");
|
|
await redis.set("del-key3", "value3");
|
|
|
|
const count1 = await redis.del("del-key1");
|
|
expect(count1).toBe(1);
|
|
|
|
const value1 = await redis.get("del-key1");
|
|
expect(value1).toBeNull();
|
|
|
|
const count2 = await redis.del("del-key2", "del-key3");
|
|
expect(count2).toBe(2);
|
|
|
|
const count3 = await redis.del("nonexistent");
|
|
expect(count3).toBe(0);
|
|
});
|
|
|
|
test("should serialize key with DUMP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "dump-test";
|
|
|
|
await redis.set(key, "test-value");
|
|
|
|
const serialized = await redis.dump(key);
|
|
expect(serialized).toBeDefined();
|
|
expect(serialized).not.toBeNull();
|
|
|
|
const empty = await redis.dump("nonexistent");
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should get value as Buffer with getBuffer", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getbuffer-test";
|
|
|
|
await redis.set(key, "test-value");
|
|
|
|
const buffer = await redis.getBuffer(key);
|
|
expect(buffer).toBeInstanceOf(Buffer);
|
|
expect(buffer?.toString()).toBe("test-value");
|
|
|
|
const empty = await redis.getBuffer("nonexistent");
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should get and delete with GETDEL", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getdel-test";
|
|
|
|
await redis.set(key, "test-value");
|
|
|
|
const value = await redis.getdel(key);
|
|
expect(value).toBe("test-value");
|
|
|
|
const deleted = await redis.get(key);
|
|
expect(deleted).toBeNull();
|
|
|
|
const empty = await redis.getdel("nonexistent");
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should get and set expiration with GETEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getex-test";
|
|
|
|
await redis.set(key, "test-value");
|
|
|
|
const value1 = await redis.getex(key, "EX", 60);
|
|
expect(value1).toBe("test-value");
|
|
const ttl1 = await redis.ttl(key);
|
|
expect(ttl1).toBeGreaterThan(0);
|
|
expect(ttl1).toBeLessThanOrEqual(60);
|
|
|
|
const value2 = await redis.getex(key, "PX", 5000);
|
|
expect(value2).toBe("test-value");
|
|
const pttl = await redis.pttl(key);
|
|
expect(pttl).toBeGreaterThan(0);
|
|
expect(pttl).toBeLessThanOrEqual(5000);
|
|
|
|
const empty = await redis.getex("nonexistent", "EX", 60);
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should get old value and set new with GETSET", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getset-test";
|
|
|
|
const old1 = await redis.getset(key, "value1");
|
|
expect(old1).toBeNull();
|
|
|
|
const old2 = await redis.getset(key, "value2");
|
|
expect(old2).toBe("value1");
|
|
|
|
const current = await redis.get(key);
|
|
expect(current).toBe("value2");
|
|
});
|
|
|
|
test("should get string length with STRLEN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "strlen-test";
|
|
|
|
const len1 = await redis.strlen(key);
|
|
expect(len1).toBe(0);
|
|
|
|
await redis.set(key, "Hello");
|
|
const len2 = await redis.strlen(key);
|
|
expect(len2).toBe(5);
|
|
|
|
await redis.set(key, "Hello World");
|
|
const len3 = await redis.strlen(key);
|
|
expect(len3).toBe(11);
|
|
});
|
|
|
|
test("should get substring with SUBSTR", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "substr-test";
|
|
|
|
await redis.set(key, "Hello World");
|
|
|
|
const result = await redis.substr(key, 0, 4);
|
|
expect(result).toBe("Hello");
|
|
});
|
|
|
|
test("should get expiration time with EXPIRETIME", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "expiretime-test";
|
|
|
|
await redis.set(key, "value");
|
|
|
|
const futureTs = Math.floor(Date.now() / 1000) + 60;
|
|
await redis.expireat(key, futureTs);
|
|
|
|
const expireTime = await redis.expiretime(key);
|
|
expect(expireTime).toBeGreaterThan(0);
|
|
expect(expireTime).toBeLessThanOrEqual(futureTs);
|
|
|
|
const key2 = "no-expire";
|
|
await redis.set(key2, "value");
|
|
const noExpire = await redis.expiretime(key2);
|
|
expect(noExpire).toBe(-1);
|
|
|
|
const nonExist = await redis.expiretime("nonexistent");
|
|
expect(nonExist).toBe(-2);
|
|
});
|
|
|
|
test("should get expiration time in ms with PEXPIRETIME", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "pexpiretime-test";
|
|
|
|
await redis.set(key, "value");
|
|
|
|
const futureTs = Date.now() + 5000;
|
|
await redis.pexpireat(key, futureTs);
|
|
|
|
const pexpireTime = await redis.pexpiretime(key);
|
|
expect(pexpireTime).toBeGreaterThan(0);
|
|
expect(pexpireTime).toBeLessThanOrEqual(futureTs);
|
|
|
|
const key2 = "no-expire";
|
|
await redis.set(key2, "value");
|
|
const noExpire = await redis.pexpiretime(key2);
|
|
expect(noExpire).toBe(-1);
|
|
|
|
const nonExist = await redis.pexpiretime("nonexistent");
|
|
expect(nonExist).toBe(-2);
|
|
});
|
|
|
|
test("should remove expiration with PERSIST", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "persist-test";
|
|
|
|
await redis.set(key, "value");
|
|
await redis.expire(key, 60);
|
|
|
|
const ttlBefore = await redis.ttl(key);
|
|
expect(ttlBefore).toBeGreaterThan(0);
|
|
|
|
const result = await redis.persist(key);
|
|
expect(result).toBe(1);
|
|
|
|
const ttlAfter = await redis.ttl(key);
|
|
expect(ttlAfter).toBe(-1);
|
|
|
|
const result2 = await redis.persist(key);
|
|
expect(result2).toBe(0);
|
|
|
|
const result3 = await redis.persist("nonexistent");
|
|
expect(result3).toBe(0);
|
|
});
|
|
|
|
test("should get multiple values with MGET", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("mget-key1", "value1");
|
|
await redis.set("mget-key2", "value2");
|
|
await redis.set("mget-key3", "value3");
|
|
|
|
const values = await redis.mget("mget-key1", "mget-key2", "mget-key3");
|
|
expect(values).toEqual(["value1", "value2", "value3"]);
|
|
|
|
const mixed = await redis.mget("mget-key1", "nonexistent", "mget-key2");
|
|
expect(mixed).toEqual(["value1", null, "value2"]);
|
|
|
|
const allNull = await redis.mget("none1", "none2", "none3");
|
|
expect(allNull).toEqual([null, null, null]);
|
|
});
|
|
|
|
test("should set only if not exists with SETNX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "setnx-test";
|
|
|
|
const result1 = await redis.setnx(key, "value1");
|
|
expect(result1).toBe(1);
|
|
|
|
const value1 = await redis.get(key);
|
|
expect(value1).toBe("value1");
|
|
|
|
const result2 = await redis.setnx(key, "value2");
|
|
expect(result2).toBe(0);
|
|
|
|
const value2 = await redis.get(key);
|
|
expect(value2).toBe("value1");
|
|
});
|
|
|
|
test("should add to HyperLogLog with PFADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "pfadd-test";
|
|
|
|
const result1 = await redis.pfadd(key, "element1");
|
|
expect(result1).toBe(1);
|
|
|
|
const result2 = await redis.pfadd(key, "element2");
|
|
expect(result2).toBe(1);
|
|
|
|
const result3 = await redis.pfadd(key, "element1");
|
|
expect(result3).toBe(0);
|
|
});
|
|
|
|
test("should implement TTL command correctly for different cases", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const tempKey = "ttl-test-key";
|
|
await redis.set(tempKey, "ttl test value");
|
|
await redis.expire(tempKey, 60);
|
|
|
|
const ttl = await redis.ttl(tempKey);
|
|
expectType<number>(ttl, "number");
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(60);
|
|
|
|
const permanentKey = "permanent-key";
|
|
await redis.set(permanentKey, "no expiry");
|
|
const noExpiry = await redis.ttl(permanentKey);
|
|
expect(noExpiry).toMatchInlineSnapshot(`-1`);
|
|
|
|
const nonExistentKey = "non-existent-" + randomUUIDv7();
|
|
const noKey = await redis.ttl(nonExistentKey);
|
|
expect(noKey).toMatchInlineSnapshot(`-2`);
|
|
});
|
|
|
|
test("should copy a key to a new key with COPY", async () => {
|
|
const redis = ctx.redis;
|
|
const sourceKey = "copy-source";
|
|
const destKey = "copy-dest";
|
|
|
|
await redis.set(sourceKey, "Hello World");
|
|
|
|
const result = await redis.copy(sourceKey, destKey);
|
|
expect(result).toBe(1);
|
|
|
|
const sourceValue = await redis.get(sourceKey);
|
|
const destValue = await redis.get(destKey);
|
|
expect(sourceValue).toBe("Hello World");
|
|
expect(destValue).toBe("Hello World");
|
|
|
|
const result2 = await redis.copy(sourceKey, destKey);
|
|
expect(result2).toBe(0);
|
|
});
|
|
|
|
test("should copy a key with REPLACE option", async () => {
|
|
const redis = ctx.redis;
|
|
const sourceKey = "copy-replace-source";
|
|
const destKey = "copy-replace-dest";
|
|
|
|
await redis.set(sourceKey, "New Value");
|
|
await redis.set(destKey, "Old Value");
|
|
|
|
const result = await redis.copy(sourceKey, destKey, "REPLACE");
|
|
expect(result).toBe(1);
|
|
|
|
const destValue = await redis.get(destKey);
|
|
expect(destValue).toBe("New Value");
|
|
});
|
|
|
|
test("should unlink one or more keys asynchronously with UNLINK", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("unlink-key1", "value1");
|
|
await redis.set("unlink-key2", "value2");
|
|
await redis.set("unlink-key3", "value3");
|
|
|
|
const result = await redis.unlink("unlink-key1", "unlink-key2", "unlink-key3");
|
|
expect(result).toBe(3);
|
|
|
|
expect(await redis.get("unlink-key1")).toBeNull();
|
|
expect(await redis.get("unlink-key2")).toBeNull();
|
|
expect(await redis.get("unlink-key3")).toBeNull();
|
|
});
|
|
|
|
test("should unlink with non-existent keys", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("unlink-exists", "value");
|
|
|
|
const result = await redis.unlink("unlink-exists", "unlink-nonexist1", "unlink-nonexist2");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.get("unlink-exists")).toBeNull();
|
|
});
|
|
|
|
test("should return a random key with RANDOMKEY", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const emptyResult = await redis.randomkey();
|
|
expect(emptyResult).toBeNull();
|
|
|
|
await redis.set("random-key1", "value1");
|
|
await redis.set("random-key2", "value2");
|
|
await redis.set("random-key3", "value3");
|
|
|
|
const randomKey = await redis.randomkey();
|
|
expect(randomKey).toBeDefined();
|
|
expect(randomKey).not.toBeNull();
|
|
expect(["random-key1", "random-key2", "random-key3"]).toContain<string | null>(randomKey);
|
|
|
|
const value = await redis.get(randomKey!);
|
|
expect(value).toBeDefined();
|
|
});
|
|
|
|
test("should iterate keys with SCAN", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const testKeys = ["scan-test:1", "scan-test:2", "scan-test:3", "scan-test:4", "scan-test:5"];
|
|
for (const key of testKeys) {
|
|
await redis.set(key, "value");
|
|
}
|
|
|
|
let cursor = "0";
|
|
const foundKeys: string[] = [];
|
|
do {
|
|
const [nextCursor, keys] = await redis.scan(cursor);
|
|
foundKeys.push(...keys);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
for (const testKey of testKeys) {
|
|
expect(foundKeys).toContain(testKey);
|
|
}
|
|
});
|
|
|
|
test("should iterate keys with SCAN and MATCH pattern", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("user:1", "alice");
|
|
await redis.set("user:2", "bob");
|
|
await redis.set("post:1", "hello");
|
|
await redis.set("post:2", "world");
|
|
|
|
let cursor = "0";
|
|
const userKeys: string[] = [];
|
|
do {
|
|
const [nextCursor, keys] = await redis.scan(cursor, "MATCH", "user:*");
|
|
userKeys.push(...keys);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
expect(userKeys).toContain("user:1");
|
|
expect(userKeys).toContain("user:2");
|
|
expect(userKeys).not.toContain("post:1");
|
|
expect(userKeys).not.toContain("post:2");
|
|
});
|
|
|
|
test("should reject invalid object argument in SCAN", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.scan({} as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'scan'."`);
|
|
});
|
|
|
|
test("should reject invalid array argument in SCAN", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.scan([] as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'scan'."`);
|
|
});
|
|
|
|
test("should reject invalid null argument in SCAN", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.scan(null as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'scan'."`);
|
|
});
|
|
|
|
test("should reject invalid source key in COPY", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.copy({} as any, "dest");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'copy'."`);
|
|
});
|
|
|
|
test("should reject invalid destination key in COPY", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.copy("source", [] as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'copy'."`);
|
|
});
|
|
|
|
test("should reject invalid option in COPY", async () => {
|
|
const redis = ctx.redis;
|
|
await redis.set("copy-invalid-opt-source", "value");
|
|
expect(async () => {
|
|
await redis.copy("copy-invalid-opt-source", "copy-invalid-opt-dest", "NOTVALID" as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR syntax error"`);
|
|
});
|
|
|
|
test("should reject invalid old key in RENAME", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.rename({} as any, "newkey");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'rename'."`);
|
|
});
|
|
|
|
test("should reject invalid new key in RENAME", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.rename("oldkey", null as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected newkey to be a string or buffer for 'rename'."`);
|
|
});
|
|
|
|
test("should reject invalid key in GETRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.getrange({} as any, 0, 5);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'getrange'."`);
|
|
});
|
|
|
|
test("should reject invalid key in SETRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.setrange(undefined as any, 0, "value");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'setrange'."`);
|
|
});
|
|
|
|
test("should reject invalid key in INCRBY", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.incrby([] as any, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'incrby'."`);
|
|
});
|
|
|
|
test("should reject invalid value in MSET", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.mset("key", {} as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'mset'."`);
|
|
});
|
|
|
|
test("should reject invalid value in MSETNX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.msetnx("key1", "value1", "key2", [] as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'msetnx'."`);
|
|
});
|
|
|
|
test("should reject invalid key in SETBIT", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.setbit({} as any, 0, 1);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'setbit'."`);
|
|
});
|
|
|
|
test("should reject invalid key in SETEX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.setex(null as any, 10, "value");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'setex'."`);
|
|
});
|
|
|
|
test("should reject invalid key in PSETEX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.psetex([] as any, 1000, "value");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'psetex'."`);
|
|
});
|
|
|
|
test("should reject invalid key in UNLINK", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.unlink({} as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'unlink'."`);
|
|
});
|
|
|
|
test("should reject invalid additional key in UNLINK", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.unlink("valid-key", [] as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'unlink'."`);
|
|
});
|
|
|
|
test("should reject invalid key in TOUCH", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.touch(null as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"The "key" argument must be specified"`);
|
|
});
|
|
|
|
test("should reject invalid additional key in TOUCH", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.touch("valid-key", {} as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'touch'."`);
|
|
});
|
|
|
|
test("should reject invalid key in EXPIREAT", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.expireat({} as any, 1234567890);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'expireat'."`);
|
|
});
|
|
|
|
test("should reject invalid key in PEXPIRE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.pexpire([] as any, 5000);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'pexpire'."`);
|
|
});
|
|
|
|
test("should reject invalid key in PEXPIREAT", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.pexpireat(null as any, 1234567890000);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'pexpireat'."`);
|
|
});
|
|
});
|
|
|
|
describe("String commands", () => {
|
|
test("should append value to key with APPEND", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "append-test";
|
|
|
|
const length1 = await redis.append(key, "Hello");
|
|
expect(length1).toBe(5);
|
|
|
|
const value1 = await redis.get(key);
|
|
expect(value1).toBe("Hello");
|
|
|
|
const length2 = await redis.append(key, " World");
|
|
expect(length2).toBe(11);
|
|
|
|
const value2 = await redis.get(key);
|
|
expect(value2).toBe("Hello World");
|
|
});
|
|
|
|
test("should delete one or more keys with DEL", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.set("del-test-1", "value1");
|
|
await redis.set("del-test-2", "value2");
|
|
await redis.set("del-test-3", "value3");
|
|
|
|
const result1 = await redis.del("del-test-1");
|
|
expect(result1).toBe(1);
|
|
|
|
expect(await redis.get("del-test-1")).toBeNull();
|
|
|
|
const result2 = await redis.del("del-test-2", "del-test-3");
|
|
expect(result2).toBe(2);
|
|
|
|
expect(await redis.get("del-test-2")).toBeNull();
|
|
expect(await redis.get("del-test-3")).toBeNull();
|
|
|
|
const result3 = await redis.del("del-test-nonexistent");
|
|
expect(result3).toBe(0);
|
|
});
|
|
|
|
test("should serialize key with DUMP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "dump-test";
|
|
|
|
await redis.set(key, "Hello World");
|
|
|
|
const serialized = await redis.dump(key);
|
|
expect(serialized).toBeDefined();
|
|
expect(serialized).not.toBeNull();
|
|
|
|
expect(typeof serialized === "string" || Buffer.isBuffer(serialized)).toBe(true);
|
|
|
|
const nonExistent = await redis.dump("dump-test-nonexistent");
|
|
expect(nonExistent).toBeNull();
|
|
});
|
|
|
|
test("should get value as Buffer with getBuffer", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getbuffer-test";
|
|
|
|
await redis.set(key, "Hello Buffer");
|
|
|
|
const buffer = await redis.getBuffer(key);
|
|
expect(buffer).toBeDefined();
|
|
expect(buffer).not.toBeNull();
|
|
expect(Buffer.isBuffer(buffer)).toBe(true);
|
|
expect(buffer!.toString()).toBe("Hello Buffer");
|
|
|
|
const nonExistent = await redis.getBuffer("getbuffer-nonexistent");
|
|
expect(nonExistent).toBeNull();
|
|
});
|
|
|
|
test("should get and delete key with GETDEL", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getdel-test";
|
|
|
|
await redis.set(key, "Delete me");
|
|
|
|
const value = await redis.getdel(key);
|
|
expect(value).toBe("Delete me");
|
|
|
|
const check = await redis.get(key);
|
|
expect(check).toBeNull();
|
|
|
|
const nonExistent = await redis.getdel("getdel-nonexistent");
|
|
expect(nonExistent).toBeNull();
|
|
});
|
|
|
|
test("should get key with expiration using GETEX with EX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getex-ex-test";
|
|
|
|
await redis.set(key, "Expire me");
|
|
|
|
const value = await redis.getex(key, "EX", 10);
|
|
expect(value).toBe("Expire me");
|
|
|
|
const check = await redis.get(key);
|
|
expect(check).toBe("Expire me");
|
|
|
|
const ttl = await redis.ttl(key);
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(10);
|
|
});
|
|
|
|
test("should get key with expiration using GETEX with PX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getex-px-test";
|
|
|
|
await redis.set(key, "Expire me");
|
|
|
|
const value = await redis.getex(key, "PX", 5000);
|
|
expect(value).toBe("Expire me");
|
|
|
|
const ttl = await redis.ttl(key);
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(5);
|
|
});
|
|
|
|
test("should get key with expiration using GETEX with EXAT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getex-exat-test";
|
|
|
|
await redis.set(key, "Expire at timestamp");
|
|
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 60;
|
|
const value = await redis.getex(key, "EXAT", futureTimestamp);
|
|
expect(value).toBe("Expire at timestamp");
|
|
|
|
const ttl = await redis.ttl(key);
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(60);
|
|
});
|
|
|
|
test("should get key with expiration using GETEX with PXAT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getex-pxat-test";
|
|
|
|
await redis.set(key, "Expire at timestamp");
|
|
|
|
const futureTimestamp = Date.now() + 60000;
|
|
const value = await redis.getex(key, "PXAT", futureTimestamp);
|
|
expect(value).toBe("Expire at timestamp");
|
|
|
|
const ttl = await redis.ttl(key);
|
|
expect(ttl).toBeGreaterThan(0);
|
|
expect(ttl).toBeLessThanOrEqual(60);
|
|
});
|
|
|
|
test("should persist key expiration using GETEX with PERSIST", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getex-persist-test";
|
|
|
|
await redis.set(key, "Remove expiration", "EX", 100);
|
|
|
|
const ttlBefore = await redis.ttl(key);
|
|
expect(ttlBefore).toBeGreaterThan(0);
|
|
|
|
const value = await redis.getex(key, "PERSIST");
|
|
expect(value).toBe("Remove expiration");
|
|
|
|
const ttlAfter = await redis.ttl(key);
|
|
expect(ttlAfter).toBe(-1);
|
|
});
|
|
|
|
test("should get non-existent key with GETEX", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const value = await redis.getex("getex-nonexistent", "EX", 10);
|
|
expect(value).toBeNull();
|
|
});
|
|
|
|
test("should get and set in one operation with GETSET", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "getset-test";
|
|
|
|
const oldValue1 = await redis.getset(key, "new value");
|
|
expect(oldValue1).toBeNull();
|
|
|
|
const check1 = await redis.get(key);
|
|
expect(check1).toBe("new value");
|
|
|
|
const oldValue2 = await redis.getset(key, "newer value");
|
|
expect(oldValue2).toBe("new value");
|
|
|
|
const check2 = await redis.get(key);
|
|
expect(check2).toBe("newer value");
|
|
});
|
|
|
|
test("should get string length with STRLEN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "strlen-test";
|
|
|
|
const length1 = await redis.strlen("strlen-nonexistent");
|
|
expect(length1).toBe(0);
|
|
|
|
await redis.set(key, "Hello World");
|
|
const length2 = await redis.strlen(key);
|
|
expect(length2).toBe(11);
|
|
|
|
await redis.set(key, "Hi");
|
|
const length3 = await redis.strlen(key);
|
|
expect(length3).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe("List Operations", () => {
|
|
test("should get list length with LLEN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "llen-test";
|
|
|
|
const len1 = await redis.llen(key);
|
|
expect(len1).toBe(0);
|
|
|
|
await redis.lpush(key, "one", "two", "three");
|
|
|
|
const len2 = await redis.llen(key);
|
|
expect(len2).toBe(3);
|
|
|
|
await redis.lpop(key);
|
|
const len3 = await redis.llen(key);
|
|
expect(len3).toBe(2);
|
|
});
|
|
|
|
test("should pop left with LPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpop-test";
|
|
|
|
await redis.lpush(key, "three", "two", "one");
|
|
|
|
const elem1 = await redis.lpop(key);
|
|
expect(elem1).toBe("one");
|
|
|
|
const elem2 = await redis.lpop(key, 2);
|
|
expect(elem2).toEqual(["two", "three"]);
|
|
|
|
const empty = await redis.lpop(key);
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should push to existing list with LPUSHX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpushx-test";
|
|
|
|
const len1 = await redis.lpushx(key, "value");
|
|
expect(len1).toBe(0);
|
|
|
|
await redis.lpush(key, "one");
|
|
|
|
const len2 = await redis.lpushx(key, "two");
|
|
expect(len2).toBe(2);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["two", "one"]);
|
|
});
|
|
|
|
test("should pop right with RPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "rpop-test";
|
|
|
|
await redis.rpush(key, "one", "two", "three");
|
|
|
|
const elem1 = await redis.rpop(key);
|
|
expect(elem1).toBe("three");
|
|
|
|
const elem2 = await redis.rpop(key, 2);
|
|
expect(elem2).toEqual(["two", "one"]);
|
|
|
|
const empty = await redis.rpop(key);
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should push to existing list with RPUSHX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "rpushx-test";
|
|
|
|
const len1 = await redis.rpushx(key, "value");
|
|
expect(len1).toBe(0);
|
|
|
|
await redis.rpush(key, "one");
|
|
|
|
const len2 = await redis.rpushx(key, "two");
|
|
expect(len2).toBe(2);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["one", "two"]);
|
|
});
|
|
|
|
test("should get range of elements with LRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lrange-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const fullList = await redis.lrange(key, 0, -1);
|
|
expect(fullList).toEqual(["one", "two", "three"]);
|
|
|
|
const firstTwo = await redis.lrange(key, 0, 1);
|
|
expect(firstTwo).toEqual(["one", "two"]);
|
|
|
|
const lastTwo = await redis.lrange(key, -2, -1);
|
|
expect(lastTwo).toEqual(["two", "three"]);
|
|
|
|
const middle = await redis.lrange(key, 1, 1);
|
|
expect(middle).toEqual(["two"]);
|
|
|
|
const outOfRange = await redis.lrange(key, 10, 20);
|
|
expect(outOfRange).toEqual([]);
|
|
|
|
const nonExistent = await redis.lrange("nonexistent-list", 0, -1);
|
|
expect(nonExistent).toEqual([]);
|
|
});
|
|
|
|
test("should get element at index with LINDEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lindex-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const first = await redis.lindex(key, 0);
|
|
expect(first).toBe("one");
|
|
|
|
const second = await redis.lindex(key, 1);
|
|
expect(second).toBe("two");
|
|
|
|
const third = await redis.lindex(key, 2);
|
|
expect(third).toBe("three");
|
|
|
|
const last = await redis.lindex(key, -1);
|
|
expect(last).toBe("three");
|
|
|
|
const secondLast = await redis.lindex(key, -2);
|
|
expect(secondLast).toBe("two");
|
|
|
|
const outOfRange = await redis.lindex(key, 10);
|
|
expect(outOfRange).toBeNull();
|
|
|
|
const outOfRangeNeg = await redis.lindex(key, -10);
|
|
expect(outOfRangeNeg).toBeNull();
|
|
|
|
const nonExistent = await redis.lindex("nonexistent-list", 0);
|
|
expect(nonExistent).toBeNull();
|
|
});
|
|
|
|
test("should set element at index with LSET", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lset-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const result1 = await redis.lset(key, 0, "zero");
|
|
expect(result1).toBe("OK");
|
|
|
|
const first = await redis.lindex(key, 0);
|
|
expect(first).toBe("zero");
|
|
|
|
const result2 = await redis.lset(key, -1, "last");
|
|
expect(result2).toBe("OK");
|
|
|
|
const last = await redis.lindex(key, -1);
|
|
expect(last).toBe("last");
|
|
|
|
const fullList = await redis.lrange(key, 0, -1);
|
|
expect(fullList).toEqual(["zero", "two", "last"]);
|
|
});
|
|
|
|
test("should handle LSET errors", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.lpush("lset-error-test", "value");
|
|
|
|
expect(async () => {
|
|
await redis.lset("lset-error-test", 10, "newvalue");
|
|
}).toThrow(/index out of range/i);
|
|
|
|
expect(async () => {
|
|
await redis.lset("nonexistent-list", 0, "value");
|
|
}).toThrow(/no such key/i);
|
|
|
|
await redis.set("string-key", "value");
|
|
expect(async () => {
|
|
await redis.lset("string-key", 0, "value");
|
|
}).toThrow(/wrong.*type|WRONGTYPE/i);
|
|
});
|
|
|
|
test("should handle LRANGE with various ranges", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lrange-advanced";
|
|
|
|
for (let i = 5; i >= 1; i--) {
|
|
await redis.lpush(key, String(i));
|
|
}
|
|
|
|
const fullList = await redis.lrange(key, 0, -1);
|
|
expect(fullList).toEqual(["1", "2", "3", "4", "5"]);
|
|
|
|
const invalid = await redis.lrange(key, 3, 1);
|
|
expect(invalid).toEqual([]);
|
|
|
|
const mixed = await redis.lrange(key, -3, 4);
|
|
expect(mixed).toEqual(["3", "4", "5"]);
|
|
|
|
const bothNeg = await redis.lrange(key, -4, -2);
|
|
expect(bothNeg).toEqual(["2", "3", "4"]);
|
|
});
|
|
|
|
test("should handle LINDEX and LSET with numbers", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "list-numbers";
|
|
|
|
await redis.lpush(key, "100");
|
|
await redis.lpush(key, "200");
|
|
await redis.lpush(key, "300");
|
|
|
|
const elem = await redis.lindex(key, 1);
|
|
expect(elem).toBe("200");
|
|
|
|
await redis.lset(key, 1, "250");
|
|
const updated = await redis.lindex(key, 1);
|
|
expect(updated).toBe("250");
|
|
});
|
|
|
|
test("should insert element before pivot with LINSERT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "linsert-before-test";
|
|
|
|
await redis.lpush(key, "World");
|
|
await redis.lpush(key, "Hello");
|
|
|
|
const result = await redis.linsert(key, "BEFORE", "World", "There");
|
|
expect(result).toBe(3);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["Hello", "There", "World"]);
|
|
});
|
|
|
|
test("should insert element after pivot with LINSERT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "linsert-after-test";
|
|
|
|
await redis.lpush(key, "World");
|
|
await redis.lpush(key, "Hello");
|
|
|
|
const result = await redis.linsert(key, "AFTER", "Hello", "Beautiful");
|
|
expect(result).toBe(3);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["Hello", "Beautiful", "World"]);
|
|
});
|
|
|
|
test("should handle LINSERT when pivot not found", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "linsert-notfound-test";
|
|
|
|
await redis.lpush(key, "value1");
|
|
await redis.lpush(key, "value2");
|
|
|
|
const result = await redis.linsert(key, "BEFORE", "nonexistent", "newvalue");
|
|
expect(result).toBe(-1);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["value2", "value1"]);
|
|
});
|
|
|
|
test("should handle LINSERT on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.linsert("nonexistent-list", "BEFORE", "pivot", "element");
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test("should remove elements from head with LREM", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lrem-positive-test";
|
|
|
|
await redis.rpush(key, "hello");
|
|
await redis.rpush(key, "hello");
|
|
await redis.rpush(key, "world");
|
|
await redis.rpush(key, "hello");
|
|
|
|
const result = await redis.lrem(key, 2, "hello");
|
|
expect(result).toBe(2);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["world", "hello"]);
|
|
});
|
|
|
|
test("should remove elements from tail with LREM", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lrem-negative-test";
|
|
|
|
await redis.rpush(key, "hello");
|
|
await redis.rpush(key, "world");
|
|
await redis.rpush(key, "hello");
|
|
await redis.rpush(key, "hello");
|
|
|
|
const result = await redis.lrem(key, -2, "hello");
|
|
expect(result).toBe(2);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["hello", "world"]);
|
|
});
|
|
|
|
test("should remove all occurrences with LREM count=0", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lrem-all-test";
|
|
|
|
await redis.rpush(key, "hello");
|
|
await redis.rpush(key, "world");
|
|
await redis.rpush(key, "hello");
|
|
await redis.rpush(key, "foo");
|
|
await redis.rpush(key, "hello");
|
|
|
|
const result = await redis.lrem(key, 0, "hello");
|
|
expect(result).toBe(3);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["world", "foo"]);
|
|
});
|
|
|
|
test("should handle LREM when element not found", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lrem-notfound-test";
|
|
|
|
await redis.rpush(key, "value1");
|
|
await redis.rpush(key, "value2");
|
|
|
|
const result = await redis.lrem(key, 1, "nonexistent");
|
|
expect(result).toBe(0);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["value1", "value2"]);
|
|
});
|
|
|
|
test("should trim list to range with LTRIM", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "ltrim-test";
|
|
|
|
await redis.rpush(key, "one");
|
|
await redis.rpush(key, "two");
|
|
await redis.rpush(key, "three");
|
|
await redis.rpush(key, "four");
|
|
|
|
const result = await redis.ltrim(key, 1, 2);
|
|
expect(result).toBe("OK");
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["two", "three"]);
|
|
});
|
|
|
|
test("should handle LTRIM with negative indexes", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "ltrim-negative-test";
|
|
|
|
await redis.rpush(key, "one");
|
|
await redis.rpush(key, "two");
|
|
await redis.rpush(key, "three");
|
|
await redis.rpush(key, "four");
|
|
await redis.rpush(key, "five");
|
|
|
|
const result = await redis.ltrim(key, -3, -1);
|
|
expect(result).toBe("OK");
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["three", "four", "five"]);
|
|
});
|
|
|
|
test("should handle LTRIM with out of range indexes", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "ltrim-outofrange-test";
|
|
|
|
await redis.rpush(key, "one");
|
|
await redis.rpush(key, "two");
|
|
await redis.rpush(key, "three");
|
|
|
|
const result = await redis.ltrim(key, 0, 100);
|
|
expect(result).toBe("OK");
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["one", "two", "three"]);
|
|
});
|
|
|
|
test("should empty list with LTRIM when stop < start", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "ltrim-empty-test";
|
|
|
|
await redis.rpush(key, "one");
|
|
await redis.rpush(key, "two");
|
|
await redis.rpush(key, "three");
|
|
|
|
const result = await redis.ltrim(key, 2, 0);
|
|
expect(result).toBe("OK");
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual([]);
|
|
});
|
|
|
|
test("should block and pop element with BLPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "blpop-test";
|
|
|
|
await redis.lpush(key, "value1");
|
|
|
|
const result = await redis.blpop(key, 0.1);
|
|
expect(result).toEqual([key, "value1"]);
|
|
|
|
const timeout = await redis.blpop(key, 0.1);
|
|
expect(timeout).toBeNull();
|
|
});
|
|
|
|
test("should block and pop element with BRPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "brpop-test";
|
|
|
|
await redis.lpush(key, "value2");
|
|
await redis.lpush(key, "value1");
|
|
|
|
const result = await redis.brpop(key, 0.1);
|
|
expect(result).toEqual([key, "value2"]);
|
|
|
|
await redis.brpop(key, 0.1);
|
|
const timeout = await redis.brpop(key, 0.1);
|
|
expect(timeout).toBeNull();
|
|
});
|
|
|
|
test("should pop from first non-empty list with BLPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "blpop-list1";
|
|
const key2 = "blpop-list2";
|
|
|
|
await redis.lpush(key2, "value2");
|
|
|
|
const result = await redis.blpop(key1, key2, 0.1);
|
|
expect(result).toEqual([key2, "value2"]);
|
|
});
|
|
|
|
test("should pop elements with LMPOP LEFT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lmpop-left-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const result = await redis.lmpop(1, key, "LEFT");
|
|
expect(result).toEqual([key, ["one"]]);
|
|
|
|
const remaining = await redis.lrange(key, 0, -1);
|
|
expect(remaining).toEqual(["two", "three"]);
|
|
});
|
|
|
|
test("should pop elements with LMPOP RIGHT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lmpop-right-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const result = await redis.lmpop(1, key, "RIGHT");
|
|
expect(result).toEqual([key, ["three"]]);
|
|
|
|
const remaining = await redis.lrange(key, 0, -1);
|
|
expect(remaining).toEqual(["one", "two"]);
|
|
});
|
|
|
|
test("should pop multiple elements with LMPOP COUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lmpop-count-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const result = await redis.lmpop(1, key, "LEFT", "COUNT", 2);
|
|
expect(result).toEqual([key, ["one", "two"]]);
|
|
|
|
const remaining = await redis.lrange(key, 0, -1);
|
|
expect(remaining).toEqual(["three"]);
|
|
});
|
|
|
|
test("should return null for LMPOP on empty list", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.lmpop(1, "nonexistent-list", "LEFT");
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should pop from first non-empty list with LMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "lmpop-empty";
|
|
const key2 = "lmpop-full";
|
|
|
|
await redis.lpush(key2, "value");
|
|
|
|
const result = await redis.lmpop(2, key1, key2, "LEFT");
|
|
expect(result).toEqual([key2, ["value"]]);
|
|
});
|
|
|
|
test("should find position of element with LPOS", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpos-test";
|
|
|
|
await redis.lpush(key, "d");
|
|
await redis.lpush(key, "b");
|
|
await redis.lpush(key, "c");
|
|
await redis.lpush(key, "b");
|
|
await redis.lpush(key, "a");
|
|
|
|
const pos1 = await redis.lpos(key, "b");
|
|
expect(pos1).toBe(1);
|
|
|
|
const pos2 = await redis.lpos(key, "a");
|
|
expect(pos2).toBe(0);
|
|
|
|
const pos3 = await redis.lpos(key, "d");
|
|
expect(pos3).toBe(4);
|
|
|
|
const pos4 = await redis.lpos(key, "x");
|
|
expect(pos4).toBeNull();
|
|
});
|
|
|
|
test("should find position with RANK option in LPOS", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpos-rank-test";
|
|
|
|
await redis.lpush(key, "b");
|
|
await redis.lpush(key, "a");
|
|
await redis.lpush(key, "b");
|
|
await redis.lpush(key, "a");
|
|
await redis.lpush(key, "b");
|
|
|
|
const first = await redis.lpos(key, "b");
|
|
expect(first).toBe(0);
|
|
|
|
const second = await redis.lpos(key, "b", "RANK", 2);
|
|
expect(second).toBe(2);
|
|
|
|
const third = await redis.lpos(key, "b", "RANK", 3);
|
|
expect(third).toBe(4);
|
|
|
|
const fourth = await redis.lpos(key, "b", "RANK", 4);
|
|
expect(fourth).toBeNull();
|
|
|
|
const fromEnd = await redis.lpos(key, "b", "RANK", -1);
|
|
expect(fromEnd).toBe(4);
|
|
|
|
const fromEnd2 = await redis.lpos(key, "b", "RANK", -2);
|
|
expect(fromEnd2).toBe(2);
|
|
});
|
|
|
|
test("should find multiple positions with COUNT option in LPOS", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpos-count-test";
|
|
|
|
await redis.lpush(key, "c");
|
|
await redis.lpush(key, "b");
|
|
await redis.lpush(key, "b");
|
|
await redis.lpush(key, "a");
|
|
await redis.lpush(key, "b");
|
|
|
|
const all = await redis.lpos(key, "b", "COUNT", 0);
|
|
expect(all).toEqual([0, 2, 3]);
|
|
|
|
const first2 = await redis.lpos(key, "b", "COUNT", 2);
|
|
expect(first2).toEqual([0, 2]);
|
|
|
|
const more = await redis.lpos(key, "b", "COUNT", 10);
|
|
expect(more).toEqual([0, 2, 3]);
|
|
|
|
const none = await redis.lpos(key, "x", "COUNT", 5);
|
|
expect(none).toEqual([]);
|
|
});
|
|
|
|
test("should find position with MAXLEN option in LPOS", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpos-maxlen-test";
|
|
|
|
for (let i = 5; i >= 1; i--) {
|
|
await redis.lpush(key, String(i));
|
|
}
|
|
await redis.lpush(key, "target");
|
|
|
|
const found = await redis.lpos(key, "target", "MAXLEN", 6);
|
|
expect(found).toBe(0);
|
|
|
|
const notFound = await redis.lpos(key, "5", "MAXLEN", 3);
|
|
expect(notFound).toBeNull();
|
|
|
|
const found3 = await redis.lpos(key, "3", "MAXLEN", 10);
|
|
expect(found3).toBe(3);
|
|
});
|
|
|
|
test("should move element from source to destination with LMOVE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "lmove-source";
|
|
const dest = "lmove-dest";
|
|
|
|
await redis.lpush(source, "three");
|
|
await redis.lpush(source, "two");
|
|
await redis.lpush(source, "one");
|
|
|
|
const result1 = await redis.lmove(source, dest, "LEFT", "RIGHT");
|
|
expect(result1).toBe("one");
|
|
|
|
const sourceList1 = await redis.lrange(source, 0, -1);
|
|
expect(sourceList1).toEqual(["two", "three"]);
|
|
|
|
const destList1 = await redis.lrange(dest, 0, -1);
|
|
expect(destList1).toEqual(["one"]);
|
|
|
|
const result2 = await redis.lmove(source, dest, "RIGHT", "LEFT");
|
|
expect(result2).toBe("three");
|
|
|
|
const sourceList2 = await redis.lrange(source, 0, -1);
|
|
expect(sourceList2).toEqual(["two"]);
|
|
|
|
const destList2 = await redis.lrange(dest, 0, -1);
|
|
expect(destList2).toEqual(["three", "one"]);
|
|
});
|
|
|
|
test("should handle all LMOVE direction combinations", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
await redis.lpush("src1", "b", "a");
|
|
const res1 = await redis.lmove("src1", "dst1", "LEFT", "LEFT");
|
|
expect(res1).toBe("a");
|
|
expect(await redis.lrange("dst1", 0, -1)).toEqual(["a"]);
|
|
|
|
await redis.lpush("src2", "b", "a");
|
|
const res2 = await redis.lmove("src2", "dst2", "LEFT", "RIGHT");
|
|
expect(res2).toBe("a");
|
|
expect(await redis.lrange("dst2", 0, -1)).toEqual(["a"]);
|
|
|
|
await redis.lpush("src3", "b", "a");
|
|
const res3 = await redis.lmove("src3", "dst3", "RIGHT", "LEFT");
|
|
expect(res3).toBe("b");
|
|
expect(await redis.lrange("dst3", 0, -1)).toEqual(["b"]);
|
|
|
|
await redis.lpush("src4", "b", "a");
|
|
const res4 = await redis.lmove("src4", "dst4", "RIGHT", "RIGHT");
|
|
expect(res4).toBe("b");
|
|
expect(await redis.lrange("dst4", 0, -1)).toEqual(["b"]);
|
|
});
|
|
|
|
test("should return null for LMOVE on empty source", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.lmove("empty-source", "some-dest", "LEFT", "RIGHT");
|
|
expect(result).toBeNull();
|
|
|
|
const destList = await redis.lrange("some-dest", 0, -1);
|
|
expect(destList).toEqual([]);
|
|
});
|
|
|
|
test("should handle LMOVE to same list", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "circular-list";
|
|
|
|
await redis.lpush(key, "c", "b", "a");
|
|
|
|
const result = await redis.lmove(key, key, "LEFT", "RIGHT");
|
|
expect(result).toBe("a");
|
|
expect(await redis.lrange(key, 0, -1)).toEqual(["b", "c", "a"]);
|
|
});
|
|
|
|
test("should pop from source and push to dest with RPOPLPUSH", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "rpoplpush-source";
|
|
const dest = "rpoplpush-dest";
|
|
|
|
await redis.lpush(source, "three");
|
|
await redis.lpush(source, "two");
|
|
await redis.lpush(source, "one");
|
|
|
|
const result = await redis.rpoplpush(source, dest);
|
|
expect(result).toBe("three");
|
|
|
|
const sourceList = await redis.lrange(source, 0, -1);
|
|
expect(sourceList).toEqual(["one", "two"]);
|
|
|
|
const destList = await redis.lrange(dest, 0, -1);
|
|
expect(destList).toEqual(["three"]);
|
|
|
|
const result2 = await redis.rpoplpush(source, dest);
|
|
expect(result2).toBe("two");
|
|
|
|
const sourceList2 = await redis.lrange(source, 0, -1);
|
|
expect(sourceList2).toEqual(["one"]);
|
|
|
|
const destList2 = await redis.lrange(dest, 0, -1);
|
|
expect(destList2).toEqual(["two", "three"]);
|
|
});
|
|
|
|
test("should return null for RPOPLPUSH on empty source", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.rpoplpush("empty-source", "some-dest");
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should handle RPOPLPUSH to same list (circular)", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "circular-rpoplpush";
|
|
|
|
await redis.lpush(key, "c", "b", "a");
|
|
|
|
const result = await redis.rpoplpush(key, key);
|
|
expect(result).toBe("c");
|
|
expect(await redis.lrange(key, 0, -1)).toEqual(["c", "a", "b"]);
|
|
});
|
|
|
|
test("should block and move element with BLMOVE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "blmove-source";
|
|
const dest = "blmove-dest";
|
|
|
|
await redis.lpush(source, "three");
|
|
await redis.lpush(source, "two");
|
|
await redis.lpush(source, "one");
|
|
|
|
const result = await redis.blmove(source, dest, "RIGHT", "LEFT", 0.1);
|
|
expect(result).toBe("three");
|
|
|
|
const sourceRemaining = await redis.lrange(source, 0, -1);
|
|
expect(sourceRemaining).toEqual(["one", "two"]);
|
|
|
|
const destElements = await redis.lrange(dest, 0, -1);
|
|
expect(destElements).toEqual(["three"]);
|
|
|
|
const result2 = await redis.blmove(source, dest, "LEFT", "RIGHT", 0.1);
|
|
expect(result2).toBe("one");
|
|
|
|
const finalSource = await redis.lrange(source, 0, -1);
|
|
expect(finalSource).toEqual(["two"]);
|
|
|
|
const finalDest = await redis.lrange(dest, 0, -1);
|
|
expect(finalDest).toEqual(["three", "one"]);
|
|
});
|
|
|
|
test("should timeout and return null with BLMOVE on empty list", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.blmove("empty-source", "dest", "LEFT", "RIGHT", 0.1);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should block and pop multiple elements with BLMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "blmpop-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const result = await redis.blmpop(0.1, 1, key, "LEFT");
|
|
expect(result).toEqual([key, ["one"]]);
|
|
|
|
const result2 = await redis.blmpop(0.1, 1, key, "RIGHT", "COUNT", 2);
|
|
expect(result2).toEqual([key, ["three", "two"]]);
|
|
|
|
const remaining = await redis.lrange(key, 0, -1);
|
|
expect(remaining).toEqual([]);
|
|
});
|
|
|
|
test("should pop from first non-empty list with BLMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "blmpop-empty";
|
|
const key2 = "blmpop-full";
|
|
|
|
await redis.lpush(key2, "value");
|
|
|
|
const result = await redis.blmpop(0.1, 2, key1, key2, "LEFT");
|
|
expect(result).toEqual([key2, ["value"]]);
|
|
});
|
|
|
|
test("should timeout and return null with BLMPOP on empty lists", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.blmpop(0.1, 2, "empty-list1", "empty-list2", "LEFT");
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should block and move element with BRPOPLPUSH", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "brpoplpush-source";
|
|
const dest = "brpoplpush-dest";
|
|
|
|
await redis.lpush(source, "value2");
|
|
await redis.lpush(source, "value1");
|
|
|
|
const result = await redis.brpoplpush(source, dest, 0.1);
|
|
expect(result).toBe("value2");
|
|
|
|
const sourceRemaining = await redis.lrange(source, 0, -1);
|
|
expect(sourceRemaining).toEqual(["value1"]);
|
|
|
|
const destElements = await redis.lrange(dest, 0, -1);
|
|
expect(destElements).toEqual(["value2"]);
|
|
|
|
const result2 = await redis.brpoplpush(source, dest, 0.1);
|
|
expect(result2).toBe("value1");
|
|
|
|
const finalSource = await redis.lrange(source, 0, -1);
|
|
expect(finalSource).toEqual([]);
|
|
|
|
const finalDest = await redis.lrange(dest, 0, -1);
|
|
expect(finalDest).toEqual(["value1", "value2"]);
|
|
});
|
|
|
|
test("should timeout and return null with BRPOPLPUSH on empty list", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.brpoplpush("empty-source", "dest", 0.1);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should get list length with LLEN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "llen-test";
|
|
|
|
const empty = await redis.llen(key);
|
|
expect(empty).toBe(0);
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const length = await redis.llen(key);
|
|
expect(length).toBe(3);
|
|
|
|
const nonExistent = await redis.llen("nonexistent-list");
|
|
expect(nonExistent).toBe(0);
|
|
});
|
|
|
|
test("should pop element from head with LPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpop-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const first = await redis.lpop(key);
|
|
expect(first).toBe("one");
|
|
|
|
const second = await redis.lpop(key);
|
|
expect(second).toBe("two");
|
|
|
|
const remaining = await redis.lrange(key, 0, -1);
|
|
expect(remaining).toEqual(["three"]);
|
|
|
|
const last = await redis.lpop(key);
|
|
expect(last).toBe("three");
|
|
|
|
const empty = await redis.lpop(key);
|
|
expect(empty).toBeNull();
|
|
|
|
const nonExistent = await redis.lpop("nonexistent-list");
|
|
expect(nonExistent).toBeNull();
|
|
});
|
|
|
|
test("should pop element from tail with RPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "rpop-test";
|
|
|
|
await redis.lpush(key, "three");
|
|
await redis.lpush(key, "two");
|
|
await redis.lpush(key, "one");
|
|
|
|
const first = await redis.rpop(key);
|
|
expect(first).toBe("three");
|
|
|
|
const second = await redis.rpop(key);
|
|
expect(second).toBe("two");
|
|
|
|
const remaining = await redis.lrange(key, 0, -1);
|
|
expect(remaining).toEqual(["one"]);
|
|
|
|
const last = await redis.rpop(key);
|
|
expect(last).toBe("one");
|
|
|
|
const empty = await redis.rpop(key);
|
|
expect(empty).toBeNull();
|
|
|
|
const nonExistent = await redis.rpop("nonexistent-list");
|
|
expect(nonExistent).toBeNull();
|
|
});
|
|
|
|
test("should push element to head only if key exists with LPUSHX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "lpushx-test";
|
|
|
|
const nonExistent = await redis.lpushx(key, "value");
|
|
expect(nonExistent).toBe(0);
|
|
|
|
const exists = await redis.exists(key);
|
|
expect(exists).toBe(false);
|
|
|
|
await redis.lpush(key, "initial");
|
|
|
|
const result = await redis.lpushx(key, "new");
|
|
expect(result).toBe(2);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["new", "initial"]);
|
|
|
|
const result2 = await redis.lpushx(key, "newer");
|
|
expect(result2).toBe(3);
|
|
|
|
const finalList = await redis.lrange(key, 0, -1);
|
|
expect(finalList).toEqual(["newer", "new", "initial"]);
|
|
});
|
|
|
|
test("should push element to tail only if key exists with RPUSHX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "rpushx-test";
|
|
|
|
const nonExistent = await redis.rpushx(key, "value");
|
|
expect(nonExistent).toBe(0);
|
|
|
|
const exists = await redis.exists(key);
|
|
expect(exists).toBe(false);
|
|
|
|
await redis.lpush(key, "initial");
|
|
|
|
const result = await redis.rpushx(key, "new");
|
|
expect(result).toBe(2);
|
|
|
|
const list = await redis.lrange(key, 0, -1);
|
|
expect(list).toEqual(["initial", "new"]);
|
|
|
|
const result2 = await redis.rpushx(key, "newer");
|
|
expect(result2).toBe(3);
|
|
|
|
const finalList = await redis.lrange(key, 0, -1);
|
|
expect(finalList).toEqual(["initial", "new", "newer"]);
|
|
});
|
|
});
|
|
|
|
describe("Set Operations", () => {
|
|
test("should get set cardinality with SCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "scard-test";
|
|
|
|
const count1 = await redis.scard(key);
|
|
expect(count1).toBe(0);
|
|
|
|
await redis.sadd(key, "one", "two", "three");
|
|
const count2 = await redis.scard(key);
|
|
expect(count2).toBe(3);
|
|
|
|
await redis.sadd(key, "two");
|
|
const count3 = await redis.scard(key);
|
|
expect(count3).toBe(3);
|
|
});
|
|
|
|
test("should get set difference with SDIFF", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "sdiff-test1";
|
|
const key2 = "sdiff-test2";
|
|
|
|
await redis.sadd(key1, "a", "b", "c", "d");
|
|
await redis.sadd(key2, "c", "d", "e");
|
|
|
|
const diff = await redis.sdiff(key1, key2);
|
|
expect(diff.sort()).toEqual(["a", "b"]);
|
|
|
|
const diff2 = await redis.sdiff(key1, "nonexistent");
|
|
expect(diff2.sort()).toEqual(["a", "b", "c", "d"]);
|
|
});
|
|
|
|
test("should check set membership with SISMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "sismember-test";
|
|
|
|
await redis.sadd(key, "one", "two", "three");
|
|
|
|
const result1 = await redis.sismember(key, "one");
|
|
expect(result1).toBe(true);
|
|
|
|
const result2 = await redis.sismember(key, "nonexistent");
|
|
expect(result2).toBe(false);
|
|
|
|
const result3 = await redis.sismember("nonexistent", "member");
|
|
expect(result3).toBe(false);
|
|
});
|
|
|
|
test("should move member between sets with SMOVE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "smove-source";
|
|
const dest = "smove-dest";
|
|
|
|
await redis.sadd(source, "one", "two", "three");
|
|
await redis.sadd(dest, "four");
|
|
|
|
const result1 = await redis.smove(source, dest, "one");
|
|
expect(result1).toBe(true);
|
|
|
|
const sourceMembers = await redis.smembers(source);
|
|
expect(sourceMembers.sort()).toEqual(["three", "two"]);
|
|
|
|
const destMembers = await redis.smembers(dest);
|
|
expect(destMembers.sort()).toEqual(["four", "one"]);
|
|
|
|
const result2 = await redis.smove(source, dest, "nonexistent");
|
|
expect(result2).toBe(false);
|
|
});
|
|
|
|
test("should pop random member with SPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "spop-test";
|
|
|
|
await redis.sadd(key, "one", "two", "three", "four");
|
|
|
|
const popped1 = await redis.spop(key);
|
|
expect(["one", "two", "three", "four"]).toContain<string | null>(popped1);
|
|
|
|
const remaining1 = await redis.scard(key);
|
|
expect(remaining1).toBe(3);
|
|
|
|
const popped2 = await redis.spop(key, 2);
|
|
expect(Array.isArray(popped2)).toBe(true);
|
|
expect(popped2).toBeDefined();
|
|
expect(popped2!.length).toBe(2);
|
|
|
|
const remaining2 = await redis.scard(key);
|
|
expect(remaining2).toBe(1);
|
|
|
|
await redis.spop(key);
|
|
const empty = await redis.spop(key);
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should publish to sharded channel with SPUBLISH", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const result = await redis.spublish("test-channel", "test-message");
|
|
expect(typeof result).toBe("number");
|
|
expect(result).toBeGreaterThanOrEqual(0);
|
|
});
|
|
|
|
test("should get random member with SRANDMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "srandmember-test";
|
|
|
|
await redis.sadd(key, "one", "two", "three");
|
|
|
|
const member1 = await redis.srandmember(key);
|
|
expect(["one", "two", "three"]).toContain<string | null>(member1);
|
|
|
|
const members = await redis.srandmember(key, 2);
|
|
expect(Array.isArray(members)).toBe(true);
|
|
expect(members!.length).toBeLessThanOrEqual(2);
|
|
|
|
const count = await redis.scard(key);
|
|
expect(count).toBe(3);
|
|
|
|
const empty = await redis.srandmember("nonexistent");
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should remove members with SREM", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "srem-test";
|
|
|
|
await redis.sadd(key, "one", "two", "three", "four");
|
|
|
|
const count1 = await redis.srem(key, "one");
|
|
expect(count1).toBe(1);
|
|
|
|
const count2 = await redis.srem(key, "two", "three");
|
|
expect(count2).toBe(2);
|
|
|
|
const remaining = await redis.smembers(key);
|
|
expect(remaining).toEqual(["four"]);
|
|
|
|
const count3 = await redis.srem(key, "nonexistent");
|
|
expect(count3).toBe(0);
|
|
});
|
|
|
|
test("should get set union with SUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "sunion-test1";
|
|
const key2 = "sunion-test2";
|
|
|
|
await redis.sadd(key1, "a", "b", "c");
|
|
await redis.sadd(key2, "c", "d", "e");
|
|
|
|
const union = await redis.sunion(key1, key2);
|
|
expect(union.sort()).toEqual(["a", "b", "c", "d", "e"]);
|
|
|
|
const union2 = await redis.sunion(key1, "nonexistent");
|
|
expect(union2.sort()).toEqual(["a", "b", "c"]);
|
|
});
|
|
|
|
test("should store set union with SUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "sunionstore-test1";
|
|
const key2 = "sunionstore-test2";
|
|
const dest = "sunionstore-dest";
|
|
|
|
await redis.sadd(key1, "a", "b", "c");
|
|
await redis.sadd(key2, "c", "d", "e");
|
|
|
|
const count = await redis.sunionstore(dest, key1, key2);
|
|
expect(count).toBe(5);
|
|
|
|
const stored = await redis.smembers(dest);
|
|
expect(stored.sort()).toEqual(["a", "b", "c", "d", "e"]);
|
|
|
|
await redis.sadd(dest, "z");
|
|
const count2 = await redis.sunionstore(dest, key1, key2);
|
|
expect(count2).toBe(5);
|
|
|
|
const stored2 = await redis.smembers(dest);
|
|
expect(stored2.sort()).toEqual(["a", "b", "c", "d", "e"]);
|
|
expect(stored2).not.toContain("z");
|
|
});
|
|
|
|
test("should return intersection of two sets with SINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
|
|
const result = await redis.sinter(key1, key2);
|
|
expect(result.sort()).toEqual(["b", "c"]);
|
|
});
|
|
|
|
test("should return intersection of multiple sets with SINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
const key3 = "set3";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
await redis.sadd(key3, "c");
|
|
await redis.sadd(key3, "d");
|
|
await redis.sadd(key3, "e");
|
|
|
|
const result = await redis.sinter(key1, key2, key3);
|
|
expect(result).toEqual(["c"]);
|
|
});
|
|
|
|
test("should return empty array when sets have no intersection with SINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
|
|
const result = await redis.sinter(key1, key2);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should return empty array when one set does not exist with SINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "nonexistent";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
|
|
const result = await redis.sinter(key1, key2);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should store intersection in destination with SINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
const dest = "dest-set";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
|
|
const count = await redis.sinterstore(dest, key1, key2);
|
|
expect(count).toBe(2);
|
|
|
|
const members = await redis.smembers(dest);
|
|
expect(members.sort()).toEqual(["b", "c"]);
|
|
});
|
|
|
|
test("should overwrite existing destination with SINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
const dest = "dest-set";
|
|
|
|
await redis.sadd(dest, "old");
|
|
await redis.sadd(dest, "data");
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
|
|
const count = await redis.sinterstore(dest, key1, key2);
|
|
expect(count).toBe(1);
|
|
|
|
const members = await redis.smembers(dest);
|
|
expect(members).toEqual(["b"]);
|
|
});
|
|
|
|
test("should return 0 when storing empty intersection with SINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
const dest = "dest-set";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key2, "b");
|
|
|
|
const count = await redis.sinterstore(dest, key1, key2);
|
|
expect(count).toBe(0);
|
|
|
|
const members = await redis.smembers(dest);
|
|
expect(members).toEqual([]);
|
|
});
|
|
|
|
test("should return cardinality of intersection with SINTERCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
|
|
const count = await redis.sintercard(2, key1, key2);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should return 0 for empty intersection with SINTERCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key2, "b");
|
|
|
|
const count = await redis.sintercard(2, key1, key2);
|
|
expect(count).toBe(0);
|
|
});
|
|
|
|
test("should support LIMIT option with SINTERCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key1, "d");
|
|
await redis.sadd(key2, "a");
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
|
|
const count = await redis.sintercard(2, key1, key2, "LIMIT", 2);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should throw error when SINTER receives no keys", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(async () => {
|
|
// @ts-expect-error
|
|
await redis.sinter();
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR wrong number of arguments for 'sinter' command"`);
|
|
});
|
|
|
|
test("should throw error when SINTERSTORE receives no keys", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(async () => {
|
|
// @ts-expect-error
|
|
await redis.sinterstore();
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR wrong number of arguments for 'sinterstore' command"`);
|
|
});
|
|
|
|
test("should throw error when SINTERCARD receives no keys", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(async () => {
|
|
// @ts-expect-error
|
|
await redis.sintercard();
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR wrong number of arguments for 'sintercard' command"`);
|
|
});
|
|
|
|
test("should store set difference with SDIFFSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "set1";
|
|
const key2 = "set2";
|
|
const key3 = "set3";
|
|
const dest = "diff-result";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key1, "d");
|
|
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
|
|
await redis.sadd(key3, "d");
|
|
|
|
const count1 = await redis.sdiffstore(dest, key1, key2);
|
|
expect(count1).toBe(2);
|
|
|
|
const members1 = await redis.smembers(dest);
|
|
expect(members1.sort()).toEqual(["a", "d"]);
|
|
|
|
const count2 = await redis.sdiffstore(dest, key1, key2, key3);
|
|
expect(count2).toBe(1);
|
|
|
|
const members2 = await redis.smembers(dest);
|
|
expect(members2).toEqual(["a"]);
|
|
});
|
|
|
|
test("should throw error with SDIFFSTORE on invalid arguments", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(async () => {
|
|
await (redis as any).sdiffstore();
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR wrong number of arguments for 'sdiffstore' command"`);
|
|
});
|
|
|
|
test("should check multiple members with SMISMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "test-set";
|
|
|
|
await redis.sadd(key, "a");
|
|
await redis.sadd(key, "b");
|
|
await redis.sadd(key, "c");
|
|
|
|
const result = await redis.smismember(key, "a", "b", "d", "e");
|
|
expect(result).toEqual([1, 1, 0, 0]);
|
|
|
|
const result2 = await redis.smismember(key, "c");
|
|
expect(result2).toEqual([1]);
|
|
|
|
const result3 = await redis.smismember("nonexistent", "a", "b");
|
|
expect(result3).toEqual([0, 0]);
|
|
});
|
|
|
|
test("should throw error with SMISMEMBER on invalid arguments", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(async () => {
|
|
await (redis as any).smismember();
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR wrong number of arguments for 'smismember' command"`);
|
|
});
|
|
|
|
test("should scan set members with SSCAN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "scan-set";
|
|
|
|
for (let i = 0; i < 20; i++) {
|
|
await redis.sadd(key, `member${i}`);
|
|
}
|
|
|
|
let cursor = "0";
|
|
const allMembers: string[] = [];
|
|
|
|
do {
|
|
const [nextCursor, members] = await redis.sscan(key, cursor);
|
|
allMembers.push(...members);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
expect(allMembers.length).toBe(20);
|
|
expect(new Set(allMembers).size).toBe(20);
|
|
|
|
for (let i = 0; i < 20; i++) {
|
|
expect(allMembers).toContain(`member${i}`);
|
|
}
|
|
});
|
|
|
|
test("should scan set with MATCH pattern using SSCAN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "scan-pattern-set";
|
|
|
|
await redis.sadd(key, "user:1");
|
|
await redis.sadd(key, "user:2");
|
|
await redis.sadd(key, "user:3");
|
|
await redis.sadd(key, "admin:1");
|
|
await redis.sadd(key, "admin:2");
|
|
|
|
const [cursor, members] = await redis.sscan(key, "0", "MATCH", "user:*");
|
|
|
|
let allUserMembers: string[] = [...members];
|
|
let scanCursor = cursor;
|
|
|
|
while (scanCursor !== "0") {
|
|
const [nextCursor, nextMembers] = await redis.sscan(key, scanCursor, "MATCH", "user:*");
|
|
allUserMembers.push(...nextMembers);
|
|
scanCursor = nextCursor;
|
|
}
|
|
|
|
const userMembers = allUserMembers.filter(m => m.startsWith("user:"));
|
|
expect(userMembers.length).toBeGreaterThanOrEqual(0);
|
|
});
|
|
|
|
test("should scan empty set with SSCAN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "empty-scan-set";
|
|
|
|
const [cursor, members] = await redis.sscan(key, "0");
|
|
expect(cursor).toBe("0");
|
|
expect(members).toEqual([]);
|
|
});
|
|
|
|
test("should throw error with SSCAN on invalid arguments", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(async () => {
|
|
await (redis as any).sscan();
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR wrong number of arguments for 'sscan' command"`);
|
|
});
|
|
|
|
test("should get cardinality of set with SCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "scard-test";
|
|
|
|
const emptyCount = await redis.scard(key);
|
|
expect(emptyCount).toBe(0);
|
|
|
|
await redis.sadd(key, "a");
|
|
await redis.sadd(key, "b");
|
|
await redis.sadd(key, "c");
|
|
|
|
const count = await redis.scard(key);
|
|
expect(count).toBe(3);
|
|
|
|
await redis.sadd(key, "a");
|
|
const sameCount = await redis.scard(key);
|
|
expect(sameCount).toBe(3);
|
|
});
|
|
|
|
test("should get difference of sets with SDIFF", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "sdiff-test1";
|
|
const key2 = "sdiff-test2";
|
|
const key3 = "sdiff-test3";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
await redis.sadd(key1, "d");
|
|
|
|
await redis.sadd(key2, "b");
|
|
await redis.sadd(key2, "c");
|
|
|
|
await redis.sadd(key3, "d");
|
|
|
|
const diff1 = await redis.sdiff(key1, key2);
|
|
expect(diff1.sort()).toEqual(["a", "d"]);
|
|
|
|
const diff2 = await redis.sdiff(key1, key2, key3);
|
|
expect(diff2.sort()).toEqual(["a"]);
|
|
|
|
const diff3 = await redis.sdiff(key1, "nonexistent");
|
|
expect(diff3.sort()).toEqual(["a", "b", "c", "d"]);
|
|
|
|
const diff4 = await redis.sdiff(key2, key1);
|
|
expect(diff4).toEqual([]);
|
|
});
|
|
|
|
test("should check if member exists in set with SISMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "sismember-test";
|
|
|
|
await redis.sadd(key, "a");
|
|
await redis.sadd(key, "b");
|
|
await redis.sadd(key, "c");
|
|
|
|
const exists1 = await redis.sismember(key, "a");
|
|
expect(exists1).toBe(true);
|
|
|
|
const exists2 = await redis.sismember(key, "b");
|
|
expect(exists2).toBe(true);
|
|
|
|
const notExists = await redis.sismember(key, "z");
|
|
expect(notExists).toBe(false);
|
|
|
|
const notExistsSet = await redis.sismember("nonexistent", "a");
|
|
expect(notExistsSet).toBe(false);
|
|
});
|
|
|
|
test("should move member between sets with SMOVE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "smove-source";
|
|
const dest = "smove-dest";
|
|
|
|
await redis.sadd(source, "a");
|
|
await redis.sadd(source, "b");
|
|
await redis.sadd(source, "c");
|
|
|
|
await redis.sadd(dest, "x");
|
|
await redis.sadd(dest, "y");
|
|
|
|
const moved = await redis.smove(source, dest, "b");
|
|
expect(moved).toBe(true);
|
|
|
|
const sourceMembers = await redis.smembers(source);
|
|
expect(sourceMembers.sort()).toEqual(["a", "c"]);
|
|
|
|
const destMembers = await redis.smembers(dest);
|
|
expect(destMembers.sort()).toEqual(["b", "x", "y"]);
|
|
|
|
const notMoved = await redis.smove(source, dest, "z");
|
|
expect(notMoved).toBe(false);
|
|
|
|
const notMoved2 = await redis.smove("nonexistent", dest, "a");
|
|
expect(notMoved2).toBe(false);
|
|
});
|
|
|
|
test("should remove and return random member with SPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "spop-test";
|
|
|
|
await redis.sadd(key, "a");
|
|
await redis.sadd(key, "b");
|
|
await redis.sadd(key, "c");
|
|
await redis.sadd(key, "d");
|
|
await redis.sadd(key, "e");
|
|
|
|
const popped = await redis.spop(key);
|
|
expect(popped).toBeDefined();
|
|
expect(["a", "b", "c", "d", "e"]).toContain<string | null>(popped);
|
|
|
|
const remaining = await redis.scard(key);
|
|
expect(remaining).toBe(4);
|
|
|
|
const poppedMultiple = await redis.spop(key, 2);
|
|
expect(Array.isArray(poppedMultiple)).toBe(true);
|
|
expect(poppedMultiple!.length).toBe(2);
|
|
poppedMultiple!.forEach(member => {
|
|
expect(["a", "b", "c", "d", "e"]).toContain(member);
|
|
});
|
|
|
|
const remainingAfter = await redis.scard(key);
|
|
expect(remainingAfter).toBe(2);
|
|
|
|
await redis.spop(key, 10);
|
|
const emptyPop = await redis.spop(key);
|
|
expect(emptyPop).toBeNull();
|
|
});
|
|
|
|
test("should publish to sharded channel with SPUBLISH", async () => {
|
|
const redis = ctx.redis;
|
|
const channel = "spublish-channel";
|
|
|
|
const count = await redis.spublish(channel, "test message");
|
|
expect(typeof count).toBe("number");
|
|
expect(count).toBe(0);
|
|
});
|
|
|
|
test("should get random member without removing with SRANDMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "srandmember-test";
|
|
|
|
await redis.sadd(key, "a");
|
|
await redis.sadd(key, "b");
|
|
await redis.sadd(key, "c");
|
|
await redis.sadd(key, "d");
|
|
await redis.sadd(key, "e");
|
|
|
|
const random = await redis.srandmember(key);
|
|
expect(random).toBeDefined();
|
|
expect(["a", "b", "c", "d", "e"]).toContain<string | null>(random);
|
|
|
|
const count = await redis.scard(key);
|
|
expect(count).toBe(5);
|
|
|
|
const randomMultiple = await redis.srandmember(key, 3);
|
|
expect(Array.isArray(randomMultiple)).toBe(true);
|
|
expect(randomMultiple!.length).toBe(3);
|
|
randomMultiple!.forEach(member => {
|
|
expect(["a", "b", "c", "d", "e"]).toContain(member);
|
|
});
|
|
|
|
const countAfter = await redis.scard(key);
|
|
expect(countAfter).toBe(5);
|
|
|
|
const tooMany = await redis.srandmember(key, 10);
|
|
expect(Array.isArray(tooMany)).toBe(true);
|
|
expect(tooMany!.length).toBe(5);
|
|
|
|
const withDuplicates = await redis.srandmember(key, -10);
|
|
expect(withDuplicates!.length).toBe(10);
|
|
withDuplicates!.forEach(member => {
|
|
expect(["a", "b", "c", "d", "e"]).toContain(member);
|
|
});
|
|
|
|
const emptyRandom = await redis.srandmember("nonexistent");
|
|
expect(emptyRandom).toBeNull();
|
|
});
|
|
|
|
test("should remove members from set with SREM", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "srem-test";
|
|
|
|
await redis.sadd(key, "a");
|
|
await redis.sadd(key, "b");
|
|
await redis.sadd(key, "c");
|
|
await redis.sadd(key, "d");
|
|
await redis.sadd(key, "e");
|
|
|
|
const removed1 = await redis.srem(key, "a");
|
|
expect(removed1).toBe(1);
|
|
|
|
const members1 = await redis.smembers(key);
|
|
expect(members1.sort()).toEqual(["b", "c", "d", "e"]);
|
|
|
|
const removed2 = await redis.srem(key, "b", "c", "z");
|
|
expect(removed2).toBe(2);
|
|
|
|
const members2 = await redis.smembers(key);
|
|
expect(members2.sort()).toEqual(["d", "e"]);
|
|
|
|
const removed3 = await redis.srem(key, "nonexistent");
|
|
expect(removed3).toBe(0);
|
|
|
|
const removed4 = await redis.srem("nonexistent", "a");
|
|
expect(removed4).toBe(0);
|
|
});
|
|
|
|
test("should get union of sets with SUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "sunion-test1";
|
|
const key2 = "sunion-test2";
|
|
const key3 = "sunion-test3";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
await redis.sadd(key2, "e");
|
|
|
|
await redis.sadd(key3, "e");
|
|
await redis.sadd(key3, "f");
|
|
await redis.sadd(key3, "g");
|
|
|
|
const union1 = await redis.sunion(key1, key2);
|
|
expect(union1.sort()).toEqual(["a", "b", "c", "d", "e"]);
|
|
|
|
const union2 = await redis.sunion(key1, key2, key3);
|
|
expect(union2.sort()).toEqual(["a", "b", "c", "d", "e", "f", "g"]);
|
|
|
|
const union3 = await redis.sunion(key1, "nonexistent");
|
|
expect(union3.sort()).toEqual(["a", "b", "c"]);
|
|
|
|
const union4 = await redis.sunion("nonexistent1", "nonexistent2");
|
|
expect(union4).toEqual([]);
|
|
});
|
|
|
|
test("should store union of sets with SUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "sunionstore-test1";
|
|
const key2 = "sunionstore-test2";
|
|
const key3 = "sunionstore-test3";
|
|
const dest = "sunionstore-dest";
|
|
|
|
await redis.sadd(key1, "a");
|
|
await redis.sadd(key1, "b");
|
|
await redis.sadd(key1, "c");
|
|
|
|
await redis.sadd(key2, "c");
|
|
await redis.sadd(key2, "d");
|
|
await redis.sadd(key2, "e");
|
|
|
|
await redis.sadd(key3, "e");
|
|
await redis.sadd(key3, "f");
|
|
|
|
const count1 = await redis.sunionstore(dest, key1, key2);
|
|
expect(count1).toBe(5);
|
|
|
|
const members1 = await redis.smembers(dest);
|
|
expect(members1.sort()).toEqual(["a", "b", "c", "d", "e"]);
|
|
|
|
const count2 = await redis.sunionstore(dest, key1, key2, key3);
|
|
expect(count2).toBe(6);
|
|
|
|
const members2 = await redis.smembers(dest);
|
|
expect(members2.sort()).toEqual(["a", "b", "c", "d", "e", "f"]);
|
|
|
|
const count3 = await redis.sunionstore(dest, key1, "nonexistent");
|
|
expect(count3).toBe(3);
|
|
|
|
const members3 = await redis.smembers(dest);
|
|
expect(members3.sort()).toEqual(["a", "b", "c"]);
|
|
|
|
const count4 = await redis.sunionstore(dest, "nonexistent1", "nonexistent2");
|
|
expect(count4).toBe(0);
|
|
|
|
const members4 = await redis.smembers(dest);
|
|
expect(members4).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("Sorted Set Operations", () => {
|
|
test("should get cardinality with ZCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zcard-test";
|
|
|
|
const count1 = await redis.zcard(key);
|
|
expect(count1).toBe(0);
|
|
|
|
await redis.zadd(key, 1, "one", 2, "two", 3, "three");
|
|
|
|
const count2 = await redis.zcard(key);
|
|
expect(count2).toBe(3);
|
|
|
|
await redis.zadd(key, 4, "one");
|
|
const count3 = await redis.zcard(key);
|
|
expect(count3).toBe(3);
|
|
});
|
|
|
|
test("should pop max with ZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmax-test";
|
|
|
|
await redis.zadd(key, 1, "one", 2, "two", 3, "three", 4, "four");
|
|
|
|
const result1 = await redis.zpopmax(key);
|
|
expect(result1).toEqual(["four", 4]);
|
|
|
|
const result2 = await redis.zpopmax(key, 2);
|
|
expect(result2).toEqual([
|
|
["three", 3],
|
|
["two", 2],
|
|
]);
|
|
|
|
const remaining = await redis.zcard(key);
|
|
expect(remaining).toBe(1);
|
|
|
|
await redis.zpopmax(key);
|
|
const empty = await redis.zpopmax(key);
|
|
expect(empty).toEqual([]);
|
|
});
|
|
|
|
test("should pop min with ZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmin-test";
|
|
|
|
await redis.zadd(key, 1, "one", 2, "two", 3, "three", 4, "four");
|
|
|
|
const result1 = await redis.zpopmin(key);
|
|
expect(result1).toEqual(["one", 1]);
|
|
|
|
const result2 = await redis.zpopmin(key, 2);
|
|
expect(result2).toEqual([
|
|
["two", 2],
|
|
["three", 3],
|
|
]);
|
|
|
|
const remaining = await redis.zcard(key);
|
|
expect(remaining).toBe(1);
|
|
|
|
await redis.zpopmin(key);
|
|
const empty = await redis.zpopmin(key);
|
|
expect(empty).toEqual([]);
|
|
});
|
|
|
|
test("should get random member with ZRANDMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrandmember-test";
|
|
|
|
await redis.zadd(key, 1, "one", 2, "two", 3, "three");
|
|
|
|
const result1 = await redis.zrandmember(key);
|
|
expect(result1).toBeDefined();
|
|
expect(["one", "two", "three"]).toContain<string | null>(result1);
|
|
|
|
const result2 = await redis.zrandmember(key, 2);
|
|
expect(Array.isArray(result2)).toBe(true);
|
|
expect(result2!.length).toBeLessThanOrEqual(2);
|
|
|
|
result2!.forEach((member: string) => {
|
|
expect(["one", "two", "three"]).toContain(member);
|
|
});
|
|
|
|
const result3 = await redis.zrandmember(key, 1, "WITHSCORES");
|
|
|
|
expect<([string, number][] | null)[]>([[["one", 1]], [["two", 2]], [["three", 3]]]).toContainEqual(result3);
|
|
|
|
const emptyKey = "zrandmember-empty-" + randomUUIDv7();
|
|
const empty = await redis.zrandmember(emptyKey);
|
|
expect(empty).toBeNull();
|
|
});
|
|
|
|
test("should get rank with ZRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrank-test";
|
|
|
|
await redis.zadd(key, 1, "one", 2, "two", 3, "three");
|
|
|
|
const rank1 = await redis.zrank(key, "one");
|
|
expect(rank1).toBe(0);
|
|
|
|
const rank2 = await redis.zrank(key, "two");
|
|
expect(rank2).toBe(1);
|
|
|
|
const rank3 = await redis.zrank(key, "three");
|
|
expect(rank3).toBe(2);
|
|
|
|
const rank4 = await redis.zrank(key, "nonexistent");
|
|
expect(rank4).toBeNull();
|
|
});
|
|
|
|
test("should get reverse rank with ZREVRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrank-test";
|
|
|
|
await redis.zadd(key, 1, "one", 2, "two", 3, "three");
|
|
|
|
const rank1 = await redis.zrevrank(key, "three");
|
|
expect(rank1).toBe(0);
|
|
|
|
const rank2 = await redis.zrevrank(key, "two");
|
|
expect(rank2).toBe(1);
|
|
|
|
const rank3 = await redis.zrevrank(key, "one");
|
|
expect(rank3).toBe(2);
|
|
|
|
const rank4 = await redis.zrevrank(key, "nonexistent");
|
|
expect(rank4).toBeNull();
|
|
});
|
|
|
|
test("should increment score with ZINCRBY", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zincrby-test";
|
|
|
|
await redis.send("ZADD", [key, "1.0", "member1", "2.0", "member2"]);
|
|
|
|
const newScore1 = await redis.zincrby(key, 2.5, "member1");
|
|
expect(newScore1).toBe(3.5);
|
|
|
|
const newScore2 = await redis.zincrby(key, -1.5, "member2");
|
|
expect(newScore2).toBe(0.5);
|
|
|
|
const newScore3 = await redis.zincrby(key, 5, "member3");
|
|
expect(newScore3).toBe(5);
|
|
});
|
|
|
|
test("should count members in score range with ZCOUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zcount-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const count1 = await redis.zcount(key, "-inf", "+inf");
|
|
expect(count1).toBe(5);
|
|
|
|
const count2 = await redis.zcount(key, 2, 4);
|
|
expect(count2).toBe(3);
|
|
|
|
const count3 = await redis.zcount(key, 1, 3);
|
|
expect(count3).toBe(3);
|
|
|
|
const count4 = await redis.zcount(key, 10, 20);
|
|
expect(count4).toBe(0);
|
|
});
|
|
|
|
test("should count members in lexicographical range with ZLEXCOUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zlexcount-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "apple", "0", "banana", "0", "cherry", "0", "date", "0", "elderberry"]);
|
|
|
|
const count1 = await redis.zlexcount(key, "-", "+");
|
|
expect(count1).toBe(5);
|
|
|
|
const count2 = await redis.zlexcount(key, "[banana", "[date");
|
|
expect(count2).toBe(3);
|
|
|
|
const count3 = await redis.zlexcount(key, "(banana", "(date");
|
|
expect(count3).toBe(1);
|
|
|
|
const count4 = await redis.zlexcount(key, "[zebra", "[zoo");
|
|
expect(count4).toBe(0);
|
|
});
|
|
|
|
test("should compute difference between sorted sets with ZDIFF", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zdiff-test1";
|
|
const key2 = "zdiff-test2";
|
|
const key3 = "zdiff-test3";
|
|
|
|
await redis.send("ZADD", [key1, "1", "one", "2", "two", "3", "three", "4", "four"]);
|
|
await redis.send("ZADD", [key2, "1", "one", "2", "two"]);
|
|
await redis.send("ZADD", [key3, "3", "three"]);
|
|
|
|
const diff1 = await redis.zdiff(2, key1, key2);
|
|
expect(diff1).toEqual(["three", "four"]);
|
|
|
|
const diff2 = await redis.zdiff(3, key1, key2, key3);
|
|
expect(diff2).toEqual(["four"]);
|
|
|
|
const diff3 = await redis.zdiff(2, key1, key2, "WITHSCORES");
|
|
expect(diff3).toEqual([
|
|
["three", 3],
|
|
["four", 4],
|
|
]);
|
|
|
|
const diff4 = await redis.zdiff(2, key1, "nonexistent");
|
|
expect(diff4.length).toBe(4);
|
|
expect(diff4).toEqual(["one", "two", "three", "four"]);
|
|
|
|
const diff5 = await redis.zdiff(2, key2, key1);
|
|
expect(diff5).toEqual([]);
|
|
});
|
|
|
|
test("should store difference between sorted sets with ZDIFFSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zdiffstore-test1";
|
|
const key2 = "zdiffstore-test2";
|
|
const dest = "zdiffstore-dest";
|
|
|
|
await redis.send("ZADD", [key1, "1", "one", "2", "two", "3", "three"]);
|
|
await redis.send("ZADD", [key2, "1", "one"]);
|
|
|
|
const count = await redis.zdiffstore(dest, 2, key1, key2);
|
|
expect(count).toBe(2);
|
|
|
|
const members = await redis.send("ZRANGE", [dest, "0", "-1"]);
|
|
expect(members).toEqual(["two", "three"]);
|
|
|
|
const membersWithScores = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(membersWithScores).toEqual([
|
|
["two", 2],
|
|
["three", 3],
|
|
]);
|
|
|
|
const count2 = await redis.zdiffstore(dest, 2, key2, key1);
|
|
expect(count2).toBe(0);
|
|
|
|
const finalCount = await redis.send("ZCARD", [dest]);
|
|
expect(finalCount).toBe(0);
|
|
});
|
|
|
|
test("should count intersection with ZINTERCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zintercard-test1";
|
|
const key2 = "zintercard-test2";
|
|
const key3 = "zintercard-test3";
|
|
|
|
await redis.send("ZADD", [key1, "1", "one", "2", "two", "3", "three"]);
|
|
await redis.send("ZADD", [key2, "1", "one", "2", "two", "4", "four"]);
|
|
await redis.send("ZADD", [key3, "1", "one", "5", "five"]);
|
|
|
|
const count1 = await redis.zintercard(2, key1, key2);
|
|
expect(count1).toBe(2);
|
|
|
|
const count2 = await redis.zintercard(3, key1, key2, key3);
|
|
expect(count2).toBe(1);
|
|
|
|
const count3 = await redis.zintercard(2, key1, key2, "LIMIT", 1);
|
|
expect(count3).toBe(1);
|
|
|
|
const count4 = await redis.zintercard(2, key1, key3);
|
|
expect(count4).toBe(1);
|
|
|
|
const count5 = await redis.zintercard(2, key1, "nonexistent");
|
|
expect(count5).toBe(0);
|
|
});
|
|
|
|
test("should reject invalid arguments in ZDIFF", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zdiff({} as any, "key1");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zdiff'."`);
|
|
});
|
|
|
|
test("should reject invalid arguments in ZDIFFSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zdiffstore("dest", {} as any, "key1");
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zdiffstore'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid arguments in ZINTERCARD", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zintercard({} as any, "key1");
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zintercard'."`,
|
|
);
|
|
});
|
|
|
|
test("should remove members by rank with ZREMRANGEBYRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zremrangebyrank-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const removed1 = await redis.zremrangebyrank(key, 0, 1);
|
|
expect(removed1).toBe(2);
|
|
|
|
const remaining = await redis.send("ZCARD", [key]);
|
|
expect(remaining).toBe(3);
|
|
|
|
const removed2 = await redis.zremrangebyrank(key, -1, -1);
|
|
expect(removed2).toBe(1);
|
|
|
|
const final = await redis.send("ZCARD", [key]);
|
|
expect(final).toBe(2);
|
|
});
|
|
|
|
test("should remove members by score range with ZREMRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zremrangebyscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const removed1 = await redis.zremrangebyscore(key, 2, 4);
|
|
expect(removed1).toBe(3);
|
|
|
|
const remaining = await redis.send("ZCARD", [key]);
|
|
expect(remaining).toBe(2);
|
|
|
|
const removed2 = await redis.zremrangebyscore(key, "-inf", "+inf");
|
|
expect(removed2).toBe(2);
|
|
});
|
|
|
|
test("should remove members by lexicographical range with ZREMRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zremrangebylex-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "apple", "0", "banana", "0", "cherry", "0", "date", "0", "elderberry"]);
|
|
|
|
const removed1 = await redis.zremrangebylex(key, "[banana", "[date");
|
|
expect(removed1).toBe(3);
|
|
|
|
const remaining = await redis.send("ZCARD", [key]);
|
|
expect(remaining).toBe(2);
|
|
|
|
const removed2 = await redis.zremrangebylex(key, "-", "+");
|
|
expect(removed2).toBe(2);
|
|
});
|
|
|
|
test("should reject invalid key in ZINCRBY", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zincrby({} as any, 1, "member");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'zincrby'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZCOUNT", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zcount([] as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'zcount'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZLEXCOUNT", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zlexcount(null as any, "[a", "[z");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'zlexcount'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZREMRANGEBYRANK", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zremrangebyrank({} as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'zremrangebyrank'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZREMRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zremrangebyscore([] as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'zremrangebyscore'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZREMRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zremrangebylex(null as any, "[a", "[z");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected key to be a string or buffer for 'zremrangebylex'."`);
|
|
});
|
|
|
|
test("should remove one or more members with ZREM", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrem-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four"]);
|
|
|
|
const removed1 = await redis.zrem(key, "two");
|
|
expect(removed1).toBe(1);
|
|
|
|
const removed2 = await redis.zrem(key, "one", "three");
|
|
expect(removed2).toBe(2);
|
|
|
|
const removed3 = await redis.zrem(key, "nonexistent");
|
|
expect(removed3).toBe(0);
|
|
|
|
const removed4 = await redis.zrem(key, "four", "nothere");
|
|
expect(removed4).toBe(1);
|
|
});
|
|
|
|
test("should get scores with ZMSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zmscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2.7", "two", "3.9", "three"]);
|
|
|
|
const scores1 = await redis.zmscore(key, "two");
|
|
expect(scores1).toEqual([2.7]);
|
|
|
|
const scores2 = await redis.zmscore(key, "one", "three");
|
|
expect(scores2).toEqual([1.5, 3.9]);
|
|
|
|
const scores3 = await redis.zmscore(key, "one", "nonexistent", "three");
|
|
expect(scores3).toEqual([1.5, null, 3.9]);
|
|
|
|
const scores4 = await redis.zmscore(key, "nothere", "alsonothere");
|
|
expect(scores4).toEqual([null, null]);
|
|
});
|
|
|
|
test("should reject invalid key in ZREM", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrem({} as any, "member");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zrem'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZMSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zmscore([] as any, "member");
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zmscore'."`,
|
|
);
|
|
});
|
|
|
|
test("should add members to sorted set with ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-basic-test";
|
|
|
|
const added1 = await redis.zadd(key, "1", "one");
|
|
expect(added1).toBe(1);
|
|
|
|
const added2 = await redis.zadd(key, "2", "two", "3", "three");
|
|
expect(added2).toBe(2);
|
|
|
|
const added3 = await redis.zadd(key, "1.5", "one");
|
|
expect(added3).toBe(0);
|
|
|
|
const score = await redis.zscore(key, "one");
|
|
expect(score).toBe(1.5);
|
|
});
|
|
|
|
test("should add members with NX option in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-nx-test";
|
|
|
|
await redis.zadd(key, "1", "one");
|
|
|
|
const added1 = await redis.zadd(key, "NX", "2", "one");
|
|
expect(added1).toBe(0);
|
|
|
|
const score1 = await redis.zscore(key, "one");
|
|
expect(score1).toBe(1);
|
|
|
|
const added2 = await redis.zadd(key, "NX", "2", "two");
|
|
expect(added2).toBe(1);
|
|
|
|
const score2 = await redis.zscore(key, "two");
|
|
expect(score2).toBe(2);
|
|
});
|
|
|
|
test("should update members with XX option in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-xx-test";
|
|
|
|
await redis.zadd(key, "1", "one");
|
|
|
|
const updated1 = await redis.zadd(key, "XX", "2", "one");
|
|
expect(updated1).toBe(0);
|
|
|
|
const score1 = await redis.zscore(key, "one");
|
|
expect(score1).toBe(2);
|
|
|
|
const added = await redis.zadd(key, "XX", "3", "three");
|
|
expect(added).toBe(0);
|
|
|
|
const score2 = await redis.zscore(key, "three");
|
|
expect(score2).toBeNull();
|
|
});
|
|
|
|
test("should return changed count with CH option in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-ch-test";
|
|
|
|
await redis.zadd(key, "1", "one", "2", "two");
|
|
|
|
const changed = await redis.zadd(key, "CH", "1.5", "one", "3", "three");
|
|
expect(changed).toBe(2);
|
|
});
|
|
|
|
test("should increment score with INCR option in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-incr-test";
|
|
|
|
await redis.zadd(key, "1", "one");
|
|
|
|
const newScore = await redis.zadd(key, "INCR", "2.5", "one");
|
|
expect(newScore).toBe(3.5);
|
|
|
|
const score = await redis.zscore(key, "one");
|
|
expect(score).toBe(3.5);
|
|
});
|
|
|
|
test("should handle GT option in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-gt-test";
|
|
|
|
await redis.zadd(key, "5", "one");
|
|
|
|
const updated1 = await redis.zadd(key, "GT", "3", "one");
|
|
expect(updated1).toBe(0);
|
|
|
|
const score1 = await redis.zscore(key, "one");
|
|
expect(score1).toBe(5);
|
|
|
|
const updated2 = await redis.zadd(key, "GT", "7", "one");
|
|
expect(updated2).toBe(0);
|
|
|
|
const score2 = await redis.zscore(key, "one");
|
|
expect(score2).toBe(7);
|
|
});
|
|
|
|
test("should handle LT option in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zadd-lt-test";
|
|
|
|
await redis.zadd(key, "5", "one");
|
|
|
|
const updated1 = await redis.zadd(key, "LT", "7", "one");
|
|
expect(updated1).toBe(0);
|
|
|
|
const score1 = await redis.zscore(key, "one");
|
|
expect(score1).toBe(5);
|
|
|
|
const updated2 = await redis.zadd(key, "LT", "3", "one");
|
|
expect(updated2).toBe(0);
|
|
|
|
const score2 = await redis.zscore(key, "one");
|
|
expect(score2).toBe(3);
|
|
});
|
|
|
|
test("should iterate sorted set with ZSCAN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zscan-test";
|
|
|
|
await redis.zadd(key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five");
|
|
|
|
let cursor = "0";
|
|
const allElements: string[] = [];
|
|
do {
|
|
const [nextCursor, elements] = await redis.zscan(key, cursor);
|
|
allElements.push(...elements);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
expect(allElements.length).toBe(10);
|
|
|
|
const members = allElements.filter((_, index) => index % 2 === 0);
|
|
expect(members).toContain("one");
|
|
expect(members).toContain("two");
|
|
expect(members).toContain("three");
|
|
expect(members).toContain("four");
|
|
expect(members).toContain("five");
|
|
});
|
|
|
|
test("should iterate sorted set with ZSCAN and MATCH", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zscan-match-test";
|
|
|
|
await redis.zadd(key, "1", "user:1", "2", "user:2", "3", "post:1", "4", "post:2");
|
|
|
|
let cursor = "0";
|
|
const userElements: string[] = [];
|
|
do {
|
|
const [nextCursor, elements] = await redis.zscan(key, cursor, "MATCH", "user:*");
|
|
userElements.push(...elements);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
const members = userElements.filter((_, index) => index % 2 === 0);
|
|
|
|
expect(members).toContain("user:1");
|
|
expect(members).toContain("user:2");
|
|
expect(members).not.toContain("post:1");
|
|
expect(members).not.toContain("post:2");
|
|
});
|
|
|
|
test("should iterate sorted set with ZSCAN and COUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zscan-count-test";
|
|
|
|
const promises: Promise<number>[] = [];
|
|
for (let i = 0; i < 100; i++) {
|
|
promises.push(redis.zadd(key, String(i), `member:${i}`));
|
|
}
|
|
await Promise.all(promises);
|
|
|
|
let cursor = "0";
|
|
const allElements: string[] = [];
|
|
do {
|
|
const [nextCursor, elements] = await redis.zscan(key, cursor, "COUNT", "10");
|
|
allElements.push(...elements);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
expect(allElements.length).toBe(200);
|
|
|
|
const members = allElements.filter((_, index) => index % 2 === 0);
|
|
expect(members.length).toBe(100);
|
|
for (let i = 0; i < 100; i++) {
|
|
expect(members).toContain(`member:${i}`);
|
|
}
|
|
|
|
cursor = 0 as any;
|
|
const allElements2: string[] = [];
|
|
do {
|
|
const [nextCursor, elements] = await redis.zscan(key, cursor, "COUNT", "10");
|
|
allElements2.push(...elements);
|
|
cursor = nextCursor;
|
|
} while (cursor !== "0");
|
|
|
|
expect(allElements2.length).toBe(200);
|
|
});
|
|
|
|
test("should reject invalid key in ZADD", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zadd({} as any, "1", "member");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zadd'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZSCAN", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zscan([] as any, 0);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zscan'."`);
|
|
});
|
|
|
|
test("should return range of members with ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-basic-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const all = await redis.zrange(key, 0, -1);
|
|
expect(all).toEqual(["one", "two", "three", "four", "five"]);
|
|
|
|
const first3 = await redis.zrange(key, 0, 2);
|
|
expect(first3).toEqual(["one", "two", "three"]);
|
|
|
|
const last2 = await redis.zrange(key, -2, -1);
|
|
expect(last2).toEqual(["four", "five"]);
|
|
});
|
|
|
|
test("should return members with scores using WITHSCORES option in ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-withscores-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2.5", "two", "3", "three"]);
|
|
|
|
const result = await redis.zrange(key, 0, -1, "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["one", 1],
|
|
["two", 2.5],
|
|
["three", 3],
|
|
]);
|
|
});
|
|
|
|
test("should return members by score range with BYSCORE option in ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-byscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const range1 = await redis.zrange(key, "2", "4", "BYSCORE");
|
|
expect(range1).toEqual(["two", "three", "four"]);
|
|
|
|
const range2 = await redis.zrange(key, "(2", "4", "BYSCORE");
|
|
expect(range2).toEqual(["three", "four"]);
|
|
|
|
const all = await redis.zrange(key, "-inf", "+inf", "BYSCORE");
|
|
expect(all).toEqual(["one", "two", "three", "four", "five"]);
|
|
});
|
|
|
|
test("should return members in reverse order with REV option in ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-rev-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three"]);
|
|
|
|
const reversed = await redis.zrange(key, 0, -1, "REV");
|
|
expect(reversed).toEqual(["three", "two", "one"]);
|
|
|
|
const top2 = await redis.zrange(key, 0, 1, "REV");
|
|
expect(top2).toEqual(["three", "two"]);
|
|
});
|
|
|
|
test("should support LIMIT option with BYSCORE in ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-limit-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result = await redis.zrange(key, "1", "5", "BYSCORE", "LIMIT", "1", "2");
|
|
expect(result).toEqual(["two", "three"]);
|
|
});
|
|
|
|
test("should return members by lexicographical range with BYLEX option in ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-bylex-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "apple", "0", "banana", "0", "cherry", "0", "date"]);
|
|
|
|
const range1 = await redis.zrange(key, "[banana", "[cherry", "BYLEX");
|
|
expect(range1).toEqual(["banana", "cherry"]);
|
|
|
|
const range2 = await redis.zrange(key, "(banana", "(date", "BYLEX");
|
|
expect(range2).toEqual(["cherry"]);
|
|
});
|
|
|
|
test("should return members in reverse order with ZREVRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrange-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const all = await redis.zrevrange(key, 0, -1);
|
|
expect(all).toEqual(["five", "four", "three", "two", "one"]);
|
|
|
|
const top3 = await redis.zrevrange(key, 0, 2);
|
|
expect(top3).toEqual(["five", "four", "three"]);
|
|
|
|
const last2 = await redis.zrevrange(key, -2, -1);
|
|
expect(last2).toEqual(["two", "one"]);
|
|
});
|
|
|
|
test("should return members with scores using WITHSCORES option in ZREVRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrange-withscores-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2", "two", "3.7", "three"]);
|
|
|
|
const result = await redis.zrevrange(key, 0, -1, "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["three", 3.7],
|
|
["two", 2],
|
|
["one", 1.5],
|
|
]);
|
|
});
|
|
|
|
test("should handle empty sorted set with ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrange-empty-test";
|
|
|
|
const result = await redis.zrange(key, 0, -1);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should handle empty sorted set with ZREVRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrange-empty-test";
|
|
|
|
const result = await redis.zrevrange(key, 0, -1);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should reject invalid key in ZRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrange({} as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zrange'."`);
|
|
});
|
|
|
|
test("should reject invalid key in ZREVRANGE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrevrange([] as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zrevrange'."`,
|
|
);
|
|
});
|
|
test("should return members by score range with ZRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebyscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const all = await redis.zrangebyscore(key, "-inf", "+inf");
|
|
expect(all).toEqual(["one", "two", "three", "four", "five"]);
|
|
|
|
const range1 = await redis.zrangebyscore(key, 2, 4);
|
|
expect(range1).toEqual(["two", "three", "four"]);
|
|
|
|
const range2 = await redis.zrangebyscore(key, "(2", 4);
|
|
expect(range2).toEqual(["three", "four"]);
|
|
|
|
const range3 = await redis.zrangebyscore(key, 2, "(4");
|
|
expect(range3).toEqual(["two", "three"]);
|
|
|
|
const range4 = await redis.zrangebyscore(key, "(2", "(4");
|
|
expect(range4).toEqual(["three"]);
|
|
});
|
|
|
|
test("should support WITHSCORES option with ZRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebyscore-withscores-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2.7", "two", "3.9", "three"]);
|
|
|
|
const result = await redis.zrangebyscore(key, 1, 3, "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["one", 1.5],
|
|
["two", 2.7],
|
|
]);
|
|
});
|
|
|
|
test("should support LIMIT option with ZRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebyscore-limit-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const limited1 = await redis.zrangebyscore(key, "-inf", "+inf", "LIMIT", 0, 2);
|
|
expect(limited1).toEqual(["one", "two"]);
|
|
|
|
const limited2 = await redis.zrangebyscore(key, "-inf", "+inf", "LIMIT", 1, 2);
|
|
expect(limited2).toEqual(["two", "three"]);
|
|
|
|
const limited3 = await redis.zrangebyscore(key, 2, 5, "LIMIT", 1, 2);
|
|
expect(limited3).toEqual(["three", "four"]);
|
|
});
|
|
|
|
test("should support WITHSCORES with ZRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebyscore-withscores-only-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four"]);
|
|
|
|
const result = await redis.zrangebyscore(key, "-inf", "+inf", "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["one", 1],
|
|
["two", 2],
|
|
["three", 3],
|
|
["four", 4],
|
|
]);
|
|
});
|
|
|
|
test("should support LIMIT and WITHSCORES together with ZRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebyscore-combined-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four"]);
|
|
|
|
const result = await redis.zrangebyscore(key, "-inf", "+inf", "WITHSCORES", "LIMIT", 1, 2);
|
|
expect(result).toEqual([
|
|
["two", 2],
|
|
["three", 3],
|
|
]);
|
|
});
|
|
|
|
test("should return members by score range in reverse with ZREVRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrangebyscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const all = await redis.zrevrangebyscore(key, "+inf", "-inf");
|
|
expect(all).toEqual(["five", "four", "three", "two", "one"]);
|
|
|
|
const range1 = await redis.zrevrangebyscore(key, 4, 2);
|
|
expect(range1).toEqual(["four", "three", "two"]);
|
|
|
|
const range2 = await redis.zrevrangebyscore(key, "(4", "(2");
|
|
expect(range2).toEqual(["three"]);
|
|
|
|
const range3 = await redis.zrevrangebyscore(key, 4, "(2");
|
|
expect(range3).toEqual(["four", "three"]);
|
|
});
|
|
|
|
test("should support WITHSCORES option with ZREVRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrangebyscore-withscores-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2.7", "two", "3.9", "three"]);
|
|
|
|
const result = await redis.zrevrangebyscore(key, 3, 1, "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["two", 2.7],
|
|
["one", 1.5],
|
|
]);
|
|
});
|
|
|
|
test("should support LIMIT option with ZREVRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrangebyscore-limit-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const limited1 = await redis.zrevrangebyscore(key, "+inf", "-inf", "LIMIT", 0, 2);
|
|
expect(limited1).toEqual(["five", "four"]);
|
|
|
|
const limited2 = await redis.zrevrangebyscore(key, "+inf", "-inf", "LIMIT", 1, 2);
|
|
expect(limited2).toEqual(["four", "three"]);
|
|
});
|
|
|
|
test("should return members by lexicographical range with ZRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebylex-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "apple", "0", "banana", "0", "cherry", "0", "date", "0", "elderberry"]);
|
|
|
|
const all = await redis.zrangebylex(key, "-", "+");
|
|
expect(all).toEqual(["apple", "banana", "cherry", "date", "elderberry"]);
|
|
|
|
const range1 = await redis.zrangebylex(key, "[banana", "[date");
|
|
expect(range1).toEqual(["banana", "cherry", "date"]);
|
|
|
|
const range2 = await redis.zrangebylex(key, "(banana", "(date");
|
|
expect(range2).toEqual(["cherry"]);
|
|
|
|
const range3 = await redis.zrangebylex(key, "[banana", "(date");
|
|
expect(range3).toEqual(["banana", "cherry"]);
|
|
|
|
const range4 = await redis.zrangebylex(key, "-", "[cherry");
|
|
expect(range4).toEqual(["apple", "banana", "cherry"]);
|
|
|
|
const range5 = await redis.zrangebylex(key, "[cherry", "+");
|
|
expect(range5).toEqual(["cherry", "date", "elderberry"]);
|
|
});
|
|
|
|
test("should support LIMIT option with ZRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrangebylex-limit-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "a", "0", "b", "0", "c", "0", "d", "0", "e", "0", "f", "0", "g"]);
|
|
|
|
const limited1 = await redis.zrangebylex(key, "-", "+", "LIMIT", 0, 3);
|
|
expect(limited1).toEqual(["a", "b", "c"]);
|
|
|
|
const limited2 = await redis.zrangebylex(key, "-", "+", "LIMIT", 2, 3);
|
|
expect(limited2).toEqual(["c", "d", "e"]);
|
|
|
|
const limited3 = await redis.zrangebylex(key, "-", "+", "LIMIT", 5, 10);
|
|
expect(limited3).toEqual(["f", "g"]);
|
|
});
|
|
|
|
test("should get cardinality of sorted set with ZCARD", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zcard-test";
|
|
|
|
const count0 = await redis.zcard(key);
|
|
expect(count0).toBe(0);
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three"]);
|
|
|
|
const count1 = await redis.zcard(key);
|
|
expect(count1).toBe(3);
|
|
|
|
await redis.send("ZADD", [key, "4", "four", "5", "five"]);
|
|
|
|
const count2 = await redis.zcard(key);
|
|
expect(count2).toBe(5);
|
|
});
|
|
|
|
test("should pop member with lowest score using ZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmin-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result1 = await redis.zpopmin(key);
|
|
expect(result1).toEqual(["one", 1]);
|
|
|
|
const result2 = await redis.zpopmin(key);
|
|
expect(result2).toEqual(["two", 2]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(3);
|
|
});
|
|
|
|
test("should pop multiple members with ZPOPMIN using COUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmin-count-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result = await redis.zpopmin(key, 3);
|
|
expect(result).toEqual([
|
|
["one", 1],
|
|
["two", 2],
|
|
["three", 3],
|
|
]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should return empty array when ZPOPMIN on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const emptyKey = "zpopmin-empty-test";
|
|
|
|
const result = await redis.zpopmin(emptyKey);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should return empty array when ZPOPMIN on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
const nonExistentKey = "zpopmin-nonexistent-" + randomUUIDv7();
|
|
|
|
const result = await redis.zpopmin(nonExistentKey);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should handle ties in score with ZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmin-tie-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "a", "1", "b", "1", "c", "2", "d"]);
|
|
|
|
const result = await redis.zpopmin(key, 2);
|
|
expect(result).toEqual([
|
|
["a", 1],
|
|
["b", 1],
|
|
]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should pop member with highest score using ZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmax-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result1 = await redis.zpopmax(key);
|
|
expect(result1).toEqual(["five", 5]);
|
|
|
|
const result2 = await redis.zpopmax(key);
|
|
expect(result2).toEqual(["four", 4]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(3);
|
|
});
|
|
|
|
test("should pop multiple members with ZPOPMAX using COUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmax-count-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result = await redis.zpopmax(key, 3);
|
|
expect(result).toEqual([
|
|
["five", 5],
|
|
["four", 4],
|
|
["three", 3],
|
|
]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should return empty array when ZPOPMAX on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const emptyKey = "zpopmax-empty-test";
|
|
|
|
const result = await redis.zpopmax(emptyKey);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should return empty array when ZPOPMAX on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
const nonExistentKey = "zpopmax-nonexistent-" + randomUUIDv7();
|
|
const result = await redis.zpopmax(nonExistentKey);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should handle ties in score with ZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmax-tie-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "a", "2", "b", "2", "c", "2", "d"]);
|
|
|
|
const result = await redis.zpopmax(key, 2);
|
|
expect(result).toEqual([
|
|
["d", 2],
|
|
["c", 2],
|
|
]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should get random member with ZRANDMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrandmember-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result = await redis.zrandmember(key);
|
|
expect(result).toBeDefined();
|
|
expect(typeof result).toBe("string");
|
|
expect(["one", "two", "three", "four", "five"]).toContain<string | null>(result);
|
|
});
|
|
|
|
test("should return null when ZRANDMEMBER on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const emptyKey = "zrandmember-empty-test";
|
|
|
|
const result = await redis.zrandmember(emptyKey);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should get multiple random members with ZRANDMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrandmember-count-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three"]);
|
|
|
|
const result = await redis.zrandmember(key, 2);
|
|
expect(result).toBeDefined();
|
|
expect(Array.isArray(result)).toBe(true);
|
|
expect(result!.length).toBe(2);
|
|
|
|
for (const member of result!) {
|
|
expect(["one", "two", "three"]).toContain(member);
|
|
}
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(3);
|
|
});
|
|
|
|
test("should get random members with scores using WITHSCORES in ZRANDMEMBER", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrandmember-withscores-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2.7", "two", "3.9", "three"]);
|
|
|
|
const result = await redis.zrandmember(key, 2, "WITHSCORES");
|
|
expect(result).toBeDefined();
|
|
expect(Array.isArray(result)).toBe(true);
|
|
expect(result!.length).toBe(2);
|
|
|
|
for (const item of result!) {
|
|
expect(Array.isArray(item)).toBe(true);
|
|
expect(item.length).toBe(2);
|
|
expect(typeof item[0]).toBe("string");
|
|
expect(typeof item[1]).toBe("number");
|
|
expect(["one", "two", "three"]).toContain(item[0]);
|
|
}
|
|
});
|
|
|
|
test("should allow negative count for ZRANDMEMBER to allow duplicates", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrandmember-negative-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two"]);
|
|
|
|
const result = await redis.zrandmember(key, -5);
|
|
expect(result).toBeDefined();
|
|
expect(Array.isArray(result)).toBe(true);
|
|
expect(result!.length).toBe(5);
|
|
|
|
for (const member of result!) {
|
|
expect(["one", "two"]).toContain(member);
|
|
}
|
|
});
|
|
|
|
test("should get rank of member with ZRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrank-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const rank1 = await redis.zrank(key, "one");
|
|
expect(rank1).toBe(0);
|
|
|
|
const rank2 = await redis.zrank(key, "three");
|
|
expect(rank2).toBe(2);
|
|
|
|
const rank3 = await redis.zrank(key, "five");
|
|
expect(rank3).toBe(4);
|
|
|
|
const rank4 = await redis.zrank(key, "nonexistent");
|
|
expect(rank4).toBeNull();
|
|
});
|
|
|
|
test("should get rank with score using WITHSCORE in ZRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrank-withscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2.7", "two", "3.9", "three"]);
|
|
|
|
const result = await redis.zrank(key, "two", "WITHSCORE");
|
|
expect(result).toEqual([1, 2.7]);
|
|
|
|
const result2 = await redis.zrank(key, "one", "WITHSCORE");
|
|
expect(result2).toEqual([0, 1.5]);
|
|
|
|
const result3 = await redis.zrank(key, "nonexistent", "WITHSCORE");
|
|
expect(result3).toBeNull();
|
|
});
|
|
|
|
test("should handle ties in score with ZRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrank-tie-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "a", "1", "b", "1", "c", "2", "d"]);
|
|
|
|
const rankA = await redis.zrank(key, "a");
|
|
expect(rankA).toBe(0);
|
|
|
|
const rankB = await redis.zrank(key, "b");
|
|
expect(rankB).toBe(1);
|
|
|
|
const rankC = await redis.zrank(key, "c");
|
|
expect(rankC).toBe(2);
|
|
|
|
const rankD = await redis.zrank(key, "d");
|
|
expect(rankD).toBe(3);
|
|
});
|
|
|
|
test("should get reverse rank of member with ZREVRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrank-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const rank1 = await redis.zrevrank(key, "five");
|
|
expect(rank1).toBe(0);
|
|
|
|
const rank2 = await redis.zrevrank(key, "three");
|
|
expect(rank2).toBe(2);
|
|
|
|
const rank3 = await redis.zrevrank(key, "one");
|
|
expect(rank3).toBe(4);
|
|
|
|
const rank4 = await redis.zrevrank(key, "nonexistent");
|
|
expect(rank4).toBeNull();
|
|
});
|
|
|
|
test("should get reverse rank with score using WITHSCORE in ZREVRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrank-withscore-test";
|
|
|
|
await redis.send("ZADD", [key, "1.5", "one", "2.7", "two", "3.9", "three"]);
|
|
|
|
const result = await redis.zrevrank(key, "two", "WITHSCORE");
|
|
expect(result).toEqual([1, 2.7]);
|
|
|
|
const result2 = await redis.zrevrank(key, "three", "WITHSCORE");
|
|
expect(result2).toEqual([0, 3.9]);
|
|
|
|
const result3 = await redis.zrevrank(key, "nonexistent", "WITHSCORE");
|
|
expect(result3).toBeNull();
|
|
});
|
|
|
|
test("should handle ties in score with ZREVRANK", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrank-tie-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "a", "2", "b", "2", "c", "2", "d"]);
|
|
|
|
const rankD = await redis.zrevrank(key, "d");
|
|
expect(rankD).toBe(0);
|
|
|
|
const rankC = await redis.zrevrank(key, "c");
|
|
expect(rankC).toBe(1);
|
|
|
|
const rankB = await redis.zrevrank(key, "b");
|
|
expect(rankB).toBe(2);
|
|
|
|
const rankA = await redis.zrevrank(key, "a");
|
|
expect(rankA).toBe(3);
|
|
});
|
|
test("should reject invalid key in ZRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrangebyscore({} as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zrangebyscore'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid key in ZREVRANGEBYSCORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrevrangebyscore([] as any, 10, 0);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zrevrangebyscore'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid key in ZRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrangebylex(null as any, "-", "+");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"The "key" argument must be specified"`);
|
|
});
|
|
|
|
test("should return members in reverse lexicographical order with ZREVRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrangebylex-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "apple", "0", "banana", "0", "cherry", "0", "date", "0", "elderberry"]);
|
|
|
|
const all = await redis.zrevrangebylex(key, "+", "-");
|
|
expect(all).toEqual(["elderberry", "date", "cherry", "banana", "apple"]);
|
|
|
|
const range1 = await redis.zrevrangebylex(key, "[date", "[banana");
|
|
expect(range1).toEqual(["date", "cherry", "banana"]);
|
|
|
|
const range2 = await redis.zrevrangebylex(key, "(date", "(banana");
|
|
expect(range2).toEqual(["cherry"]);
|
|
|
|
const range3 = await redis.zrevrangebylex(key, "[elderberry", "(cherry");
|
|
expect(range3).toEqual(["elderberry", "date"]);
|
|
});
|
|
|
|
test("should support LIMIT option with ZREVRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zrevrangebylex-limit-test";
|
|
|
|
await redis.send("ZADD", [key, "0", "a", "0", "b", "0", "c", "0", "d", "0", "e", "0", "f", "0", "g"]);
|
|
|
|
const limited1 = await redis.zrevrangebylex(key, "+", "-", "LIMIT", "0", "3");
|
|
expect(limited1).toEqual(["g", "f", "e"]);
|
|
|
|
const limited2 = await redis.zrevrangebylex(key, "+", "-", "LIMIT", "2", "3");
|
|
expect(limited2).toEqual(["e", "d", "c"]);
|
|
|
|
const limited3 = await redis.zrevrangebylex(key, "+", "-", "LIMIT", "5", "10");
|
|
expect(limited3).toEqual(["b", "a"]);
|
|
});
|
|
|
|
test("should store range of members with ZRANGESTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "zrangestore-source";
|
|
const dest = "zrangestore-dest";
|
|
|
|
await redis.send("ZADD", [source, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const count1 = await redis.zrangestore(dest, source, 1, 3);
|
|
expect(count1).toBe(3);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1"]);
|
|
expect(stored).toEqual(["two", "three", "four"]);
|
|
});
|
|
|
|
test("should store range with BYSCORE option in ZRANGESTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "zrangestore-byscore-source";
|
|
const dest = "zrangestore-byscore-dest";
|
|
|
|
await redis.send("ZADD", [source, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const count = await redis.zrangestore(dest, source, "2", "4", "BYSCORE");
|
|
expect(count).toBe(3);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["two", 2],
|
|
["three", 3],
|
|
["four", 4],
|
|
]);
|
|
});
|
|
|
|
test("should store range in reverse order with REV option in ZRANGESTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "zrangestore-rev-source";
|
|
const dest = "zrangestore-rev-dest";
|
|
|
|
await redis.send("ZADD", [source, "1", "one", "2", "two", "3", "three"]);
|
|
|
|
const count = await redis.zrangestore(dest, source, "0", "-1", "REV");
|
|
expect(count).toBe(3);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1"]);
|
|
expect(stored).toEqual(["one", "two", "three"]);
|
|
});
|
|
|
|
test("should support LIMIT option with ZRANGESTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const source = "zrangestore-limit-source";
|
|
const dest = "zrangestore-limit-dest";
|
|
|
|
await redis.send("ZADD", [source, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const count = await redis.zrangestore(dest, source, "-inf", "+inf", "BYSCORE", "LIMIT", "1", "2");
|
|
expect(count).toBe(2);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1"]);
|
|
expect(stored).toEqual(["two", "three"]);
|
|
});
|
|
|
|
test("should reject invalid key in ZREVRANGEBYLEX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrevrangebylex({} as any, "+", "-");
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zrevrangebylex'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid destination in ZRANGESTORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrangestore([] as any, "source", 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zrangestore'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid source in ZRANGESTORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zrangestore("dest", null as any, 0, 10);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zrangestore'."`,
|
|
);
|
|
});
|
|
|
|
test("should compute intersection with ZINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinter-test-1";
|
|
const key2 = "zinter-test-2";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b", "3", "c");
|
|
await redis.zadd(key2, "1", "b", "2", "c", "3", "d");
|
|
|
|
const result1 = await redis.zinter(2, key1, key2);
|
|
expect(result1).toEqual(["b", "c"]);
|
|
|
|
const result2 = await redis.zinter(2, key1, key2, "WITHSCORES");
|
|
expect(result2).toEqual([
|
|
["b", 3],
|
|
["c", 5],
|
|
]);
|
|
});
|
|
|
|
test("should compute intersection with WEIGHTS in ZINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinter-weights-1";
|
|
const key2 = "zinter-weights-2";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b", "3", "c");
|
|
await redis.zadd(key2, "1", "b", "2", "c", "3", "d");
|
|
|
|
const result = await redis.zinter(2, key1, key2, "WEIGHTS", "2", "3", "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["b", 7],
|
|
["c", 12],
|
|
]);
|
|
});
|
|
|
|
test("should compute intersection with AGGREGATE in ZINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinter-agg-1";
|
|
const key2 = "zinter-agg-2";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b", "3", "c");
|
|
await redis.zadd(key2, "1", "b", "2", "c", "3", "d");
|
|
|
|
const result1 = await redis.zinter(2, key1, key2, "AGGREGATE", "MIN", "WITHSCORES");
|
|
expect(result1).toEqual([
|
|
["b", 1],
|
|
["c", 2],
|
|
]);
|
|
|
|
const result2 = await redis.zinter(2, key1, key2, "AGGREGATE", "MAX", "WITHSCORES");
|
|
expect(result2).toEqual([
|
|
["b", 2],
|
|
["c", 3],
|
|
]);
|
|
});
|
|
|
|
test("should handle empty intersection with ZINTER", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinter-empty-1";
|
|
const key2 = "zinter-empty-2";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b");
|
|
await redis.zadd(key2, "1", "c", "2", "d");
|
|
|
|
const result = await redis.zinter(2, key1, key2);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should store intersection with ZINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinterstore-test-1";
|
|
const key2 = "zinterstore-test-2";
|
|
const dest = "zinterstore-dest";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b", "3", "c");
|
|
await redis.zadd(key2, "1", "b", "2", "c", "3", "d");
|
|
|
|
const count = await redis.zinterstore(dest, 2, key1, key2);
|
|
expect(count).toBe(2);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["b", 3],
|
|
["c", 5],
|
|
]);
|
|
});
|
|
|
|
test("should store intersection with WEIGHTS in ZINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinterstore-weights-1";
|
|
const key2 = "zinterstore-weights-2";
|
|
const dest = "zinterstore-weights-dest";
|
|
|
|
await redis.zadd(key1, "1", "x", "2", "y");
|
|
await redis.zadd(key2, "2", "x", "3", "y");
|
|
|
|
const count = await redis.zinterstore(dest, 2, key1, key2, "WEIGHTS", "2", "3");
|
|
expect(count).toBe(2);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["x", 8],
|
|
["y", 13],
|
|
]);
|
|
});
|
|
|
|
test("should store intersection with AGGREGATE in ZINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinterstore-agg-1";
|
|
const key2 = "zinterstore-agg-2";
|
|
const destMin = "zinterstore-agg-min";
|
|
const destMax = "zinterstore-agg-max";
|
|
|
|
await redis.zadd(key1, "1", "m", "3", "n");
|
|
await redis.zadd(key2, "2", "m", "1", "n");
|
|
|
|
const count1 = await redis.zinterstore(destMin, 2, key1, key2, "AGGREGATE", "MIN");
|
|
expect(count1).toBe(2);
|
|
const storedMin = await redis.send("ZRANGE", [destMin, "0", "-1", "WITHSCORES"]);
|
|
expect(storedMin).toEqual([
|
|
["m", 1],
|
|
["n", 1],
|
|
]);
|
|
|
|
const count2 = await redis.zinterstore(destMax, 2, key1, key2, "AGGREGATE", "MAX");
|
|
expect(count2).toBe(2);
|
|
const storedMax = await redis.send("ZRANGE", [destMax, "0", "-1", "WITHSCORES"]);
|
|
expect(storedMax).toEqual([
|
|
["m", 2],
|
|
["n", 3],
|
|
]);
|
|
});
|
|
|
|
test("should handle empty result with ZINTERSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zinterstore-empty-1";
|
|
const key2 = "zinterstore-empty-2";
|
|
const dest = "zinterstore-empty-dest";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b");
|
|
await redis.zadd(key2, "1", "c", "2", "d");
|
|
|
|
const count = await redis.zinterstore(dest, 2, key1, key2);
|
|
expect(count).toBe(0);
|
|
|
|
const exists = await redis.exists(dest);
|
|
expect(exists).toBe(false);
|
|
});
|
|
|
|
test("should compute union with ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunion-test-1";
|
|
const key2 = "zunion-test-2";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b", "3", "c");
|
|
await redis.zadd(key2, "4", "b", "5", "c", "6", "d");
|
|
|
|
const result1 = await redis.zunion(2, key1, key2);
|
|
expect(result1).toEqual(["a", "b", "d", "c"]);
|
|
|
|
const result2 = await redis.zunion(2, key1, key2, "WITHSCORES");
|
|
expect(result2).toEqual([
|
|
["a", 1],
|
|
["b", 6],
|
|
["d", 6],
|
|
["c", 8],
|
|
]);
|
|
});
|
|
|
|
test("should compute union with WEIGHTS in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunion-weights-1";
|
|
const key2 = "zunion-weights-2";
|
|
|
|
await redis.zadd(key1, "1", "x", "2", "y", "3", "z");
|
|
await redis.zadd(key2, "2", "y", "3", "z", "4", "w");
|
|
|
|
const result = await redis.zunion(2, key1, key2, "WEIGHTS", "2", "3", "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["x", 2],
|
|
["y", 10],
|
|
["w", 12],
|
|
["z", 15],
|
|
]);
|
|
});
|
|
|
|
test("should compute union with AGGREGATE MIN in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunion-min-1";
|
|
const key2 = "zunion-min-2";
|
|
|
|
await redis.zadd(key1, "1", "p", "3", "q");
|
|
await redis.zadd(key2, "2", "p", "1", "q");
|
|
|
|
const result = await redis.zunion(2, key1, key2, "AGGREGATE", "MIN", "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["p", 1],
|
|
["q", 1],
|
|
]);
|
|
});
|
|
|
|
test("should compute union with AGGREGATE MAX in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunion-max-1";
|
|
const key2 = "zunion-max-2";
|
|
|
|
await redis.zadd(key1, "1", "r", "3", "s");
|
|
await redis.zadd(key2, "2", "r", "1", "s");
|
|
|
|
const result = await redis.zunion(2, key1, key2, "AGGREGATE", "MAX", "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["r", 2],
|
|
["s", 3],
|
|
]);
|
|
});
|
|
|
|
test("should compute union with single set in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zunion-single";
|
|
|
|
await redis.zadd(key, "1", "one", "2", "two", "3", "three");
|
|
|
|
const result = await redis.zunion(1, key);
|
|
expect(result).toEqual(["one", "two", "three"]);
|
|
});
|
|
|
|
test("should compute union with three sets in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunion-three-1";
|
|
const key2 = "zunion-three-2";
|
|
const key3 = "zunion-three-3";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b");
|
|
await redis.zadd(key2, "2", "b", "3", "c");
|
|
await redis.zadd(key3, "3", "c", "4", "d");
|
|
|
|
const result = await redis.zunion(3, key1, key2, key3, "WITHSCORES");
|
|
expect(result).toEqual([
|
|
["a", 1],
|
|
["b", 4],
|
|
["d", 4],
|
|
["c", 6],
|
|
]);
|
|
});
|
|
|
|
test("should handle empty set in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunion-empty-1";
|
|
const key2 = "zunion-empty-2";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b");
|
|
|
|
const result = await redis.zunion(2, key1, key2);
|
|
expect(result).toEqual(["a", "b"]);
|
|
});
|
|
|
|
test("should store union with ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunionstore-test-1";
|
|
const key2 = "zunionstore-test-2";
|
|
const dest = "zunionstore-dest";
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b", "3", "c");
|
|
await redis.zadd(key2, "4", "b", "5", "c", "6", "d");
|
|
|
|
const count = await redis.zunionstore(dest, 2, key1, key2);
|
|
expect(count).toBe(4);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["a", 1],
|
|
["b", 6],
|
|
["d", 6],
|
|
["c", 8],
|
|
]);
|
|
});
|
|
|
|
test("should store union with WEIGHTS in ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunionstore-weights-1";
|
|
const key2 = "zunionstore-weights-2";
|
|
const dest = "zunionstore-weights-dest";
|
|
|
|
await redis.zadd(key1, "1", "x", "2", "y");
|
|
await redis.zadd(key2, "2", "x", "3", "y");
|
|
|
|
const count = await redis.zunionstore(dest, 2, key1, key2, "WEIGHTS", "2", "3");
|
|
expect(count).toBe(2);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["x", 8],
|
|
["y", 13],
|
|
]);
|
|
});
|
|
|
|
test("should store union with AGGREGATE MIN in ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunionstore-agg-min-1";
|
|
const key2 = "zunionstore-agg-min-2";
|
|
const dest = "zunionstore-agg-min-dest";
|
|
|
|
await redis.zadd(key1, "1", "m", "3", "n");
|
|
await redis.zadd(key2, "2", "m", "1", "n");
|
|
|
|
const count = await redis.zunionstore(dest, 2, key1, key2, "AGGREGATE", "MIN");
|
|
expect(count).toBe(2);
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["m", 1],
|
|
["n", 1],
|
|
]);
|
|
});
|
|
|
|
test("should store union with AGGREGATE MAX in ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunionstore-agg-max-1";
|
|
const key2 = "zunionstore-agg-max-2";
|
|
const dest = "zunionstore-agg-max-dest";
|
|
|
|
await redis.zadd(key1, "1", "m", "3", "n");
|
|
await redis.zadd(key2, "2", "m", "1", "n");
|
|
|
|
const count = await redis.zunionstore(dest, 2, key1, key2, "AGGREGATE", "MAX");
|
|
expect(count).toBe(2);
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1", "WITHSCORES"]);
|
|
expect(stored).toEqual([
|
|
["m", 2],
|
|
["n", 3],
|
|
]);
|
|
});
|
|
|
|
test("should overwrite existing destination with ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunionstore-overwrite-1";
|
|
const key2 = "zunionstore-overwrite-2";
|
|
const dest = "zunionstore-overwrite-dest";
|
|
|
|
await redis.zadd(dest, "100", "old");
|
|
|
|
await redis.zadd(key1, "1", "a", "2", "b");
|
|
await redis.zadd(key2, "3", "c");
|
|
|
|
const count = await redis.zunionstore(dest, 2, key1, key2);
|
|
expect(count).toBe(3);
|
|
|
|
const stored = await redis.send("ZRANGE", [dest, "0", "-1"]);
|
|
expect(stored).toEqual(["a", "b", "c"]);
|
|
expect(stored).not.toContain("old");
|
|
});
|
|
|
|
test("should handle empty sets with ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zunionstore-empty-1";
|
|
const key2 = "zunionstore-empty-2";
|
|
const dest = "zunionstore-empty-dest";
|
|
|
|
const count = await redis.zunionstore(dest, 2, key1, key2);
|
|
expect(count).toBe(0);
|
|
|
|
const exists = await redis.exists(dest);
|
|
expect(exists).toBe(false);
|
|
});
|
|
|
|
test("should reject invalid numkeys in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zunion(-1, "key1");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"ERR at least 1 input key is needed for 'zunion' command"`);
|
|
});
|
|
|
|
test("should reject invalid key in ZUNION", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zunion(1, {} as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zunion'."`);
|
|
});
|
|
|
|
test("should reject invalid destination in ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zunionstore([] as any, 2, "key1", "key2");
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zunionstore'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid source key in ZUNIONSTORE", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zunionstore("dest", 2, "key1", null as any);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'zunionstore'."`,
|
|
);
|
|
});
|
|
|
|
test("should pop members with MIN option using ZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zmpop-min-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result1 = await redis.zmpop(1, key, "MIN");
|
|
expect(result1).toEqual([key, [["one", 1]]]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(4);
|
|
});
|
|
|
|
test("should pop members with MAX option using ZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zmpop-max-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result1 = await redis.zmpop(1, key, "MAX");
|
|
expect(result1).toEqual([key, [["five", 5]]]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(4);
|
|
});
|
|
|
|
test("should pop multiple members with COUNT option using ZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zmpop-count-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three", "4", "four", "5", "five"]);
|
|
|
|
const result = await redis.zmpop(1, key, "MIN", "COUNT", 3);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toBeNull();
|
|
expect(result![0]).toBe(key);
|
|
expect(result![1]).toEqual([
|
|
["one", 1],
|
|
["two", 2],
|
|
["three", 3],
|
|
]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should return null when ZMPOP on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const emptyKey = "zmpop-empty-test";
|
|
|
|
const result = await redis.zmpop(1, emptyKey, "MIN");
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should pop from first non-empty set with ZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "zmpop-multi-test1";
|
|
const key2 = "zmpop-multi-test2";
|
|
const key3 = "zmpop-multi-test3";
|
|
|
|
await redis.send("ZADD", [key2, "1", "one", "2", "two"]);
|
|
|
|
const result = await redis.zmpop(3, key1, key2, key3, "MIN");
|
|
expect(result).toEqual([key2, [["one", 1]]]);
|
|
});
|
|
|
|
test("should block and pop with BZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "bzmpop-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two"]);
|
|
|
|
const result = await redis.bzmpop(0.1, 1, key, "MIN");
|
|
expect(result).toEqual([key, [["one", 1]]]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(1);
|
|
});
|
|
|
|
test("should timeout with BZMPOP on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const emptyKey = "bzmpop-timeout-test";
|
|
|
|
const result = await redis.bzmpop(0.1, 1, emptyKey, "MIN");
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should block and pop multiple members with BZMPOP COUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "bzmpop-count-test";
|
|
|
|
await redis.send("ZADD", [key, "1", "one", "2", "two", "3", "three"]);
|
|
|
|
const result = await redis.bzmpop(0.5, 1, key, "MAX", "COUNT", 2);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toBeNull();
|
|
expect(result![0]).toBe(key);
|
|
expect(result![1]).toEqual([
|
|
["three", 3],
|
|
["two", 2],
|
|
]);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(1);
|
|
});
|
|
|
|
test("should reject invalid arguments in ZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.zmpop({} as any, "key1", "MIN");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'zmpop'."`);
|
|
});
|
|
|
|
test("should reject invalid arguments in BZMPOP", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.bzmpop(1, {} as any, "key1", "MIN");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"Expected additional arguments to be a string or buffer for 'bzmpop'."`);
|
|
});
|
|
|
|
test("should pop member with highest score using ZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmax-test";
|
|
|
|
await redis.zadd(key, 1.0, "one", 2.0, "two", 3.0, "three");
|
|
|
|
const result = await redis.zpopmax(key);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toBeNull();
|
|
expect(Array.isArray(result)).toBe(true);
|
|
expect(result).toHaveLength(2);
|
|
expect(result![0]).toBe("three");
|
|
expect(result![1]).toBe(3);
|
|
|
|
const count = await redis.zcard(key);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should pop member with lowest score using ZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmin-test";
|
|
|
|
await redis.zadd(key, 1.0, "one", 2.0, "two", 3.0, "three");
|
|
|
|
const result = await redis.zpopmin(key);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toBeNull();
|
|
expect(Array.isArray(result)).toBe(true);
|
|
expect(result).toHaveLength(2);
|
|
expect(result![0]).toBe("one");
|
|
expect(result![1]).toBe(1);
|
|
|
|
const count = await redis.zcard(key);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should return empty array for ZPOPMAX on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmax-empty-test";
|
|
|
|
const result = await redis.zpopmax(key);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should return empty array for ZPOPMIN on empty set", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "zpopmin-empty-test";
|
|
|
|
const result = await redis.zpopmin(key);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
test("should block and pop lowest score with BZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "bzpopmin-test";
|
|
|
|
await redis.send("ZADD", [key, "1.0", "one", "2.0", "two", "3.0", "three"]);
|
|
|
|
const result = await redis.bzpopmin(key, 0.1);
|
|
expect(result).toBeDefined();
|
|
expect(result).toHaveLength(3);
|
|
expect(result![0]).toBe(key);
|
|
expect(result![1]).toBe("one");
|
|
expect(result![2]).toBe(1);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should timeout with BZPOPMIN when no elements available", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "bzpopmin-empty-test";
|
|
|
|
const result = await redis.bzpopmin(key, 0.1);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should block and pop highest score with BZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "bzpopmax-test";
|
|
|
|
await redis.send("ZADD", [key, "1.0", "one", "2.0", "two", "3.0", "three"]);
|
|
|
|
const result = await redis.bzpopmax(key, 0.1);
|
|
expect(result).toBeDefined();
|
|
expect(result).toHaveLength(3);
|
|
expect(result![0]).toBe(key);
|
|
expect(result![1]).toBe("three");
|
|
expect(result![2]).toBe(3);
|
|
|
|
const count = await redis.send("ZCARD", [key]);
|
|
expect(count).toBe(2);
|
|
});
|
|
|
|
test("should timeout with BZPOPMAX when no elements available", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "bzpopmax-empty-test";
|
|
|
|
const result = await redis.bzpopmax(key, 0.1);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should work with multiple keys in BZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "bzpopmin-multi-1";
|
|
const key2 = "bzpopmin-multi-2";
|
|
|
|
await redis.send("ZADD", [key2, "5.0", "five", "6.0", "six"]);
|
|
|
|
const result = await redis.bzpopmin(key1, key2, 0.1);
|
|
expect(result).toBeDefined();
|
|
expect(result![0]).toBe(key2);
|
|
expect(result![1]).toBe("five");
|
|
expect(result![2]).toBe(5);
|
|
});
|
|
|
|
test("should work with multiple keys in BZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
const key1 = "bzpopmax-multi-1";
|
|
const key2 = "bzpopmax-multi-2";
|
|
|
|
await redis.send("ZADD", [key2, "5.0", "five", "6.0", "six"]);
|
|
|
|
const result = await redis.bzpopmax(key1, key2, 0.5);
|
|
expect(result).toBeDefined();
|
|
expect(result![0]).toBe(key2);
|
|
expect(result![1]).toBe("six");
|
|
expect(result![2]).toBe(6);
|
|
});
|
|
|
|
test("should reject invalid arguments in BZPOPMIN", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.bzpopmin({} as any, 1);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'bzpopmin'."`,
|
|
);
|
|
});
|
|
|
|
test("should reject invalid arguments in BZPOPMAX", async () => {
|
|
const redis = ctx.redis;
|
|
expect(async () => {
|
|
await redis.bzpopmax([] as any, 1);
|
|
}).toThrowErrorMatchingInlineSnapshot(
|
|
`"Expected additional arguments to be a string or buffer for 'bzpopmax'."`,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("Hash Operations", () => {
|
|
test("should increment hash field by integer with HINCRBY", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hincrby-test";
|
|
|
|
const val1 = await redis.hincrby(key, "field1", 5);
|
|
expect(val1).toBe(5);
|
|
|
|
const val2 = await redis.hincrby(key, "field1", 3);
|
|
expect(val2).toBe(8);
|
|
|
|
const val3 = await redis.hincrby(key, "field1", -2);
|
|
expect(val3).toBe(6);
|
|
});
|
|
|
|
test("should increment hash field by float with HINCRBYFLOAT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hincrbyfloat-test";
|
|
|
|
const val1 = await redis.hincrbyfloat(key, "field1", 2.5);
|
|
expect(val1).toBe("2.5");
|
|
|
|
const val2 = await redis.hincrbyfloat(key, "field1", 1.3);
|
|
expect(Number.parseFloat(val2)).toBeCloseTo(3.8);
|
|
|
|
const val3 = await redis.hincrbyfloat(key, "field1", -0.8);
|
|
expect(Number.parseFloat(val3)).toBeCloseTo(3.0);
|
|
});
|
|
|
|
test("should get all hash keys with HKEYS", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hkeys-test";
|
|
|
|
const keys1 = await redis.hkeys(key);
|
|
expect(keys1).toEqual([]);
|
|
|
|
await redis.hset(key, "field1", "value1", "field2", "value2", "field3", "value3");
|
|
|
|
const keys2 = await redis.hkeys(key);
|
|
expect(keys2.sort()).toEqual(["field1", "field2", "field3"]);
|
|
});
|
|
|
|
test("should get hash length with HLEN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hlen-test";
|
|
|
|
const len1 = await redis.hlen(key);
|
|
expect(len1).toBe(0);
|
|
|
|
await redis.hset(key, "field1", "value1", "field2", "value2");
|
|
const len2 = await redis.hlen(key);
|
|
expect(len2).toBe(2);
|
|
|
|
await redis.hset(key, "field3", "value3");
|
|
const len3 = await redis.hlen(key);
|
|
expect(len3).toBe(3);
|
|
});
|
|
|
|
test("should get multiple hash values with HMGET where only two arguments are passed because the second is an array", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmget-test";
|
|
|
|
await redis.hset(key, "field1", "value1", "field2", "value2", "field3", "value3");
|
|
|
|
const values = await redis.hmget(key, ["field1", "field2", "field3"]);
|
|
expect(values).toEqual(["value1", "value2", "value3"]);
|
|
|
|
const mixed = await redis.hmget(key, ["field1", "nonexistent", "field2"]);
|
|
expect(mixed).toEqual(["value1", null, "value2"]);
|
|
});
|
|
|
|
test("should get multiple hash values with HMGET", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmget-test";
|
|
|
|
await redis.hset(key, "field1", "value1", "field2", "value2", "field3", "value3");
|
|
|
|
const values = await redis.hmget(key, "field1", "field2", "field3");
|
|
expect(values).toEqual(["value1", "value2", "value3"]);
|
|
|
|
const mixed = await redis.hmget(key, "field1", "nonexistent", "field2");
|
|
expect(mixed).toEqual(["value1", null, "value2"]);
|
|
});
|
|
|
|
test("should get all hash values with HVALS", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hvals-test";
|
|
|
|
const vals1 = await redis.hvals(key);
|
|
expect(vals1).toEqual([]);
|
|
|
|
await redis.hset(key, "field1", "value1", "field2", "value2", "field3", "value3");
|
|
|
|
const vals2 = await redis.hvals(key);
|
|
expect(vals2.sort()).toEqual(["value1", "value2", "value3"]);
|
|
});
|
|
|
|
test("should get hash field string length with HSTRLEN", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hstrlen-test";
|
|
|
|
await redis.hset(key, "field1", "Hello", "field2", "World!");
|
|
|
|
const len1 = await redis.hstrlen(key, "field1");
|
|
expect(len1).toBe(5);
|
|
|
|
const len2 = await redis.hstrlen(key, "field2");
|
|
expect(len2).toBe(6);
|
|
|
|
const len3 = await redis.hstrlen(key, "nonexistent");
|
|
expect(len3).toBe(0);
|
|
});
|
|
|
|
test("should set hash field expiration with HEXPIRE", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpire-test";
|
|
|
|
await redis.hset(key, "field1", "value1", "field2", "value2");
|
|
|
|
const result = await redis.hexpire(key, 60, "FIELDS", 1, "field1");
|
|
expect(result).toEqual([1]);
|
|
|
|
const ttl = await redis.httl(key, "FIELDS", 1, "field1");
|
|
expect(ttl[0]).toBeGreaterThan(0);
|
|
expect(ttl[0]).toBeLessThanOrEqual(60);
|
|
});
|
|
|
|
test("should set hash field expiration at timestamp with HEXPIREAT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpireat-test";
|
|
|
|
await redis.hset(key, "field1", "value1");
|
|
|
|
const futureTs = Math.floor(Date.now() / 1000) + 60;
|
|
const result = await redis.hexpireat(key, futureTs, "FIELDS", 1, "field1");
|
|
expect(result).toEqual([1]);
|
|
|
|
const ttl = await redis.httl(key, "FIELDS", 1, "field1");
|
|
expect(ttl[0]).toBeGreaterThan(0);
|
|
});
|
|
|
|
test("should get hash field expiration time with HEXPIRETIME", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpiretime-test";
|
|
|
|
await redis.hset(key, "field1", "value1");
|
|
|
|
const futureTs = Math.floor(Date.now() / 1000) + 60;
|
|
await redis.hexpireat(key, futureTs, "FIELDS", 1, "field1");
|
|
|
|
const expireTime = await redis.hexpiretime(key, "FIELDS", 1, "field1");
|
|
expect(expireTime[0]).toBeGreaterThan(0);
|
|
expect(expireTime[0]).toBeLessThanOrEqual(futureTs);
|
|
});
|
|
|
|
test("should remove hash field expiration with HPERSIST", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpersist-test";
|
|
|
|
await redis.hset(key, "field1", "value1");
|
|
await redis.hexpire(key, 60, "FIELDS", 1, "field1");
|
|
|
|
const ttlBefore = await redis.httl(key, "FIELDS", 1, "field1");
|
|
expect(ttlBefore[0]).toBeGreaterThan(0);
|
|
|
|
const result = await redis.hpersist(key, "FIELDS", 1, "field1");
|
|
expect(result).toEqual([1]);
|
|
|
|
const ttlAfter = await redis.httl(key, "FIELDS", 1, "field1");
|
|
expect(ttlAfter[0]).toBe(-1);
|
|
});
|
|
|
|
test("should set hash field expiration at timestamp in ms with HPEXPIREAT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpexpireat-test";
|
|
|
|
await redis.hset(key, "field1", "value1");
|
|
|
|
const futureTs = Date.now() + 5000;
|
|
const result = await redis.hpexpireat(key, futureTs, "FIELDS", 1, "field1");
|
|
expect(result).toEqual([1]);
|
|
|
|
const pttl = await redis.hpttl(key, "FIELDS", 1, "field1");
|
|
expect(pttl[0]).toBeGreaterThan(0);
|
|
});
|
|
|
|
test("should get hash field expiration time in ms with HPEXPIRETIME", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpexpiretime-test";
|
|
|
|
await redis.hset(key, "field1", "value1");
|
|
|
|
const futureTs = Date.now() + 5000;
|
|
await redis.hpexpireat(key, futureTs, "FIELDS", 1, "field1");
|
|
|
|
const pexpireTime = await redis.hpexpiretime(key, "FIELDS", 1, "field1");
|
|
expect(pexpireTime[0]).toBeGreaterThan(0);
|
|
expect(pexpireTime[0]).toBeLessThanOrEqual(futureTs);
|
|
});
|
|
|
|
test("should set hash fields using object syntax", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-object-test";
|
|
|
|
const result = await redis.hset(key, { field1: "value1", field2: "value2", field3: "value3" });
|
|
expect(result).toBe(3);
|
|
|
|
const value1 = await redis.hget(key, "field1");
|
|
expect(value1).toBe("value1");
|
|
const value2 = await redis.hget(key, "field2");
|
|
expect(value2).toBe("value2");
|
|
const value3 = await redis.hget(key, "field3");
|
|
expect(value3).toBe("value3");
|
|
});
|
|
|
|
test("should set hash fields using variadic syntax", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-variadic-test";
|
|
|
|
const result = await redis.hset(key, "field1", "value1", "field2", "value2");
|
|
expect(result).toBe(2);
|
|
|
|
const value1 = await redis.hget(key, "field1");
|
|
expect(value1).toBe("value1");
|
|
const value2 = await redis.hget(key, "field2");
|
|
expect(value2).toBe("value2");
|
|
});
|
|
|
|
test("should set single hash field", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-single-test";
|
|
|
|
const result = await redis.hset(key, "field1", "value1");
|
|
expect(result).toBe(1);
|
|
|
|
const value = await redis.hget(key, "field1");
|
|
expect(value).toBe("value1");
|
|
});
|
|
|
|
test("should update existing hash fields", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-update-test";
|
|
|
|
const result1 = await redis.hset(key, { field1: "value1", field2: "value2" });
|
|
expect(result1).toBe(2);
|
|
|
|
const result2 = await redis.hset(key, { field1: "new-value1", field3: "value3" });
|
|
expect(result2).toBe(1);
|
|
|
|
const value1 = await redis.hget(key, "field1");
|
|
expect(value1).toBe("new-value1");
|
|
const value3 = await redis.hget(key, "field3");
|
|
expect(value3).toBe("value3");
|
|
});
|
|
|
|
test("should work with HMSET using object syntax", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmset-object-test";
|
|
|
|
const result = await redis.hmset(key, { field1: "value1", field2: "value2" });
|
|
expect(result).toBe("OK");
|
|
|
|
const value1 = await redis.hget(key, "field1");
|
|
expect(value1).toBe("value1");
|
|
const value2 = await redis.hget(key, "field2");
|
|
expect(value2).toBe("value2");
|
|
});
|
|
|
|
test("should work with HMSET using variadic syntax", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmset-variadic-test";
|
|
|
|
const result = await redis.hmset(key, "field1", "value1", "field2", "value2");
|
|
expect(result).toBe("OK");
|
|
|
|
const value1 = await redis.hget(key, "field1");
|
|
expect(value1).toBe("value1");
|
|
});
|
|
|
|
test("should work with HMSET using array syntax", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmset-array-test";
|
|
|
|
const result = await redis.hmset(key, ["field1", "value1", "field2", "value2"]);
|
|
expect(result).toBe("OK");
|
|
|
|
const value1 = await redis.hget(key, "field1");
|
|
expect(value1).toBe("value1");
|
|
});
|
|
|
|
test("should handle numeric field names and values", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-numeric-test";
|
|
|
|
const result = await redis.hset(key, { 123: "value1", field2: 456 });
|
|
expect(result).toBe(2);
|
|
|
|
const value1 = await redis.hget(key, "123");
|
|
expect(value1).toBe("value1");
|
|
const value2 = await redis.hget(key, "field2");
|
|
expect(value2).toBe("456");
|
|
});
|
|
|
|
test("should throw error for odd number of variadic arguments", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-error-test";
|
|
|
|
expect(async () => {
|
|
await redis.hset(key, "field1", "value1", "field2");
|
|
}).toThrow("HSET requires field-value pairs (even number of arguments after key)");
|
|
});
|
|
|
|
test("should throw error for empty object", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-empty-test";
|
|
|
|
expect(async () => {
|
|
await redis.hset(key, {});
|
|
}).toThrow("HSET requires at least one field-value pair");
|
|
});
|
|
|
|
test("should throw error for array with odd number of elements", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmset-error-test";
|
|
|
|
expect(async () => {
|
|
await redis.hmset(key, ["field1", "value1", "field2"]);
|
|
}).toThrow("Array must have an even number of elements (field-value pairs)");
|
|
});
|
|
|
|
test("should handle large number of fields", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hash-large-test";
|
|
|
|
const fields: Record<string, string> = {};
|
|
for (let i = 0; i < 100; i++) {
|
|
fields[`field${i}`] = `value${i}`;
|
|
}
|
|
|
|
const result = await redis.hset(key, fields);
|
|
expect(result).toBe(100);
|
|
|
|
const value0 = await redis.hget(key, "field0");
|
|
expect(value0).toBe("value0");
|
|
const value99 = await redis.hget(key, "field99");
|
|
expect(value99).toBe("value99");
|
|
});
|
|
|
|
test("should set hash field only if it doesn't exist using hsetnx", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result1 = await redis.hsetnx(key, "name", "John");
|
|
expect(result1).toBe(true);
|
|
|
|
const result2 = await redis.hsetnx(key, "name", "Jane");
|
|
expect(result2).toBe(false);
|
|
|
|
const value = await redis.hget(key, "name");
|
|
expect(value).toBe("John");
|
|
|
|
const result3 = await redis.hsetnx(key, "age", "30");
|
|
expect(result3).toBe(true);
|
|
});
|
|
|
|
test("should get and delete hash field using hgetdel", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const values = await redis.hgetdel(key, "FIELDS", 1, "name");
|
|
expect(values).toEqual(["John"]);
|
|
|
|
const check = await redis.hget(key, "name");
|
|
expect(check).toBeNull();
|
|
|
|
const age = await redis.hget(key, "age");
|
|
expect(age).toBe("30");
|
|
});
|
|
|
|
test("should get and delete multiple hash fields using hgetdel", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const values = await redis.hgetdel(key, "FIELDS", 2, "name", "city");
|
|
expect(values).toEqual(["John", "NYC"]);
|
|
|
|
expect(await redis.hget(key, "name")).toBeNull();
|
|
expect(await redis.hget(key, "city")).toBeNull();
|
|
expect(await redis.hget(key, "age")).toBe("30");
|
|
});
|
|
|
|
test("should get hash field with expiration using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const values = await redis.hgetex(key, "EX", 10, "FIELDS", 1, "name");
|
|
expect(values).toEqual(["John"]);
|
|
|
|
const check = await redis.hget(key, "name");
|
|
expect(check).toBe("John");
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 1, "name");
|
|
expect(ttls).toHaveLength(1);
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(10);
|
|
});
|
|
|
|
test("should get hash fields without expiration using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const values = await redis.hgetex(key, "FIELDS", 2, "name", "age");
|
|
expect(values).toEqual(["John", "30"]);
|
|
});
|
|
|
|
test("should get hash fields with PX expiration using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const values = await redis.hgetex(key, "PX", 5000, "FIELDS", 1, "name");
|
|
expect(values).toEqual(["John"]);
|
|
|
|
const ttls = await redis.hpttl(key, "FIELDS", 1, "name");
|
|
expect(ttls).toHaveLength(1);
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(5000);
|
|
});
|
|
|
|
test("should get hash fields with EXAT using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 60;
|
|
const values = await redis.hgetex(key, "EXAT", futureTimestamp, "FIELDS", 1, "name");
|
|
expect(values).toEqual(["John"]);
|
|
});
|
|
|
|
test("should get hash fields with PXAT using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const futureTimestamp = Date.now() + 60000;
|
|
const values = await redis.hgetex(key, "PXAT", futureTimestamp, "FIELDS", 1, "name");
|
|
expect(values).toEqual(["John"]);
|
|
});
|
|
|
|
test("should get hash fields with PERSIST using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hsetex(key, "EX", 100, "FIELDS", 1, "name", "John");
|
|
|
|
const values = await redis.hgetex(key, "PERSIST", "FIELDS", 1, "name");
|
|
expect(values).toEqual(["John"]);
|
|
});
|
|
|
|
test("should get multiple hash fields and return null for missing fields using hgetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const values = await redis.hgetex(key, "FIELDS", 3, "name", "age", "city");
|
|
expect(values).toEqual(["John", null, null]);
|
|
});
|
|
|
|
test("should set hash field with expiration using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result = await redis.hsetex(key, "EX", 10, "FIELDS", 1, "name", "John");
|
|
expect(result).toBe(1);
|
|
|
|
const value = await redis.hget(key, "name");
|
|
expect(value).toBe("John");
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 1, "name");
|
|
expect(ttls).toHaveLength(1);
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(10);
|
|
});
|
|
|
|
test("should set multiple hash fields with expiration using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result = await redis.hsetex(key, "EX", 10, "FIELDS", 2, "name", "John", "age", "30");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
expect(await redis.hget(key, "age")).toBe("30");
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 2, "name", "age");
|
|
expect(ttls).toHaveLength(2);
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(10);
|
|
expect(ttls[1]).toBeGreaterThan(0);
|
|
expect(ttls[1]).toBeLessThanOrEqual(10);
|
|
});
|
|
|
|
test("should set hash fields without expiration using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result = await redis.hsetex(key, "FIELDS", 2, "name", "John", "age", "30");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
expect(await redis.hget(key, "age")).toBe("30");
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 2, "name", "age");
|
|
expect(ttls).toEqual([-1, -1]);
|
|
});
|
|
|
|
test("should set hash fields with PX (milliseconds) using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result = await redis.hsetex(key, "PX", 5000, "FIELDS", 1, "name", "John");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
});
|
|
|
|
test("should set hash fields with EXAT (unix timestamp seconds) using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 60;
|
|
const result = await redis.hsetex(key, "EXAT", futureTimestamp, "FIELDS", 1, "name", "John");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
});
|
|
|
|
test("should set hash fields with PXAT (unix timestamp milliseconds) using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const futureTimestamp = Date.now() + 60000;
|
|
const result = await redis.hsetex(key, "PXAT", futureTimestamp, "FIELDS", 1, "name", "John");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
});
|
|
|
|
test("should set hash fields with KEEPTTL using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hsetex(key, "EX", 100, "FIELDS", 1, "name", "John");
|
|
|
|
const result = await redis.hsetex(key, "KEEPTTL", "FIELDS", 1, "name", "Jane");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("Jane");
|
|
});
|
|
|
|
test("should set hash fields with FNX flag using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const result1 = await redis.hsetex(key, "FNX", "FIELDS", 2, "name", "Jane", "age", "30");
|
|
expect(result1).toBe(0);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
expect(await redis.hget(key, "age")).toBeNull();
|
|
|
|
const result2 = await redis.hsetex(key, "FNX", "FIELDS", 2, "city", "NYC", "country", "USA");
|
|
expect(result2).toBe(1);
|
|
|
|
expect(await redis.hget(key, "city")).toBe("NYC");
|
|
expect(await redis.hget(key, "country")).toBe("USA");
|
|
});
|
|
|
|
test("should set hash fields with FXX flag using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const result1 = await redis.hsetex(key, "FXX", "FIELDS", 2, "name", "Jane", "age", "30");
|
|
expect(result1).toBe(0);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
expect(await redis.hget(key, "age")).toBeNull();
|
|
|
|
await redis.hset(key, { age: "25" });
|
|
const result2 = await redis.hsetex(key, "FXX", "FIELDS", 2, "name", "Jane", "age", "30");
|
|
expect(result2).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("Jane");
|
|
expect(await redis.hget(key, "age")).toBe("30");
|
|
});
|
|
|
|
test("should set hash fields with FNX and EX combined using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result1 = await redis.hsetex(key, "FNX", "EX", 10, "FIELDS", 2, "name", "John", "age", "30");
|
|
expect(result1).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
expect(await redis.hget(key, "age")).toBe("30");
|
|
|
|
const result2 = await redis.hsetex(key, "FNX", "EX", 10, "FIELDS", 2, "name", "Jane", "age", "35");
|
|
expect(result2).toBe(0);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("John");
|
|
expect(await redis.hget(key, "age")).toBe("30");
|
|
});
|
|
|
|
test("should set hash fields with FXX and PX combined using hsetex", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const result = await redis.hsetex(key, "FXX", "PX", 5000, "FIELDS", 2, "name", "Jane", "age", "35");
|
|
expect(result).toBe(1);
|
|
|
|
expect(await redis.hget(key, "name")).toBe("Jane");
|
|
expect(await redis.hget(key, "age")).toBe("35");
|
|
});
|
|
|
|
test("should check TTL of hash fields using httl", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hsetex(key, "EX", 100, "FIELDS", 1, "name", "John");
|
|
await redis.hset(key, { age: "30" });
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 3, "name", "age", "nonexistent");
|
|
expect(ttls).toHaveLength(3);
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(100);
|
|
expect(ttls[1]).toBe(-1);
|
|
expect(ttls[2]).toBe(-2);
|
|
});
|
|
|
|
test("should check TTL of hash fields using hpttl in milliseconds", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const expireResult = await redis.hpexpire(key, 5000, "FIELDS", 1, "name");
|
|
expect(expireResult).toEqual([1]);
|
|
|
|
const ttls = await redis.hpttl(key, "FIELDS", 2, "name", "age");
|
|
expect(ttls).toHaveLength(2);
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(5000);
|
|
expect(ttls[1]).toBe(-1);
|
|
});
|
|
|
|
test("should delete hash fields using hdel", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const deleted = await redis.hdel(key, "age");
|
|
expect(deleted).toBe(1);
|
|
|
|
const age = await redis.hget(key, "age");
|
|
expect(age).toBeNull();
|
|
|
|
const name = await redis.hget(key, "name");
|
|
expect(name).toBe("John");
|
|
});
|
|
|
|
test("should delete multiple hash fields using hdel", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC", country: "USA" });
|
|
|
|
const deleted = await redis.hdel(key, "age", "city");
|
|
expect(deleted).toBe(2);
|
|
|
|
const remaining = await redis.hgetall(key);
|
|
expect(remaining).toEqual({ name: "John", country: "USA" });
|
|
});
|
|
|
|
test("should return empty object for hgetall on non-existent key", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "nonexistent-hgetall-" + randomUUIDv7();
|
|
const result = await redis.hgetall(key);
|
|
expect(result).toEqual({});
|
|
});
|
|
|
|
test("should check if hash field exists using hexists", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const nameExists = await redis.hexists(key, "name");
|
|
expect(nameExists).toBe(true);
|
|
|
|
const emailExists = await redis.hexists(key, "email");
|
|
expect(emailExists).toBe(false);
|
|
});
|
|
|
|
test("should get random field using hrandfield", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const field = await redis.hrandfield(key);
|
|
expect(["name", "age", "city"]).toContain<string | null>(field);
|
|
});
|
|
|
|
test("should get multiple random fields using hrandfield with count", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const fields = await redis.hrandfield(key, 2);
|
|
expect(fields).toBeInstanceOf(Array);
|
|
expect(fields.length).toBe(2);
|
|
fields.forEach(field => {
|
|
expect(["name", "age", "city"]).toContain(field);
|
|
});
|
|
});
|
|
|
|
test("should get random fields with values using hrandfield WITHVALUES", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const fullData = { name: "Andy", age: "30", city: "Cupertino" };
|
|
await redis.hset(key, fullData);
|
|
|
|
const result = await redis.hrandfield(key, 2, "WITHVALUES");
|
|
expect(result).toBeInstanceOf(Array);
|
|
expect(result.length).toBe(2);
|
|
|
|
const obj = Object.fromEntries(result);
|
|
|
|
expect(Object.keys(obj).length).toBe(2);
|
|
|
|
for (const [field, value] of Object.entries(obj)) {
|
|
expect(fullData).toHaveProperty(field, value);
|
|
}
|
|
});
|
|
|
|
test("should scan hash using hscan", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const [cursor, fields] = await redis.hscan(key, 0);
|
|
expect(typeof cursor).toBe("string");
|
|
expect(fields).toBeInstanceOf(Array);
|
|
expect(fields.length).toBe(6);
|
|
|
|
const obj: Record<string, string> = {};
|
|
for (let i = 0; i < fields.length; i += 2) {
|
|
obj[fields[i]] = fields[i + 1];
|
|
}
|
|
expect(obj).toEqual({ name: "John", age: "30", city: "NYC" });
|
|
});
|
|
|
|
test("should scan hash with pattern using hscan MATCH", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { field1: "val1", field2: "val2", other: "val3" });
|
|
|
|
const [cursor, fields] = await redis.hscan(key, 0, "MATCH", "field*");
|
|
expect(typeof cursor).toBe("string");
|
|
expect(fields).toBeInstanceOf(Array);
|
|
|
|
const obj: Record<string, string> = {};
|
|
for (let i = 0; i < fields.length; i += 2) {
|
|
obj[fields[i]] = fields[i + 1];
|
|
}
|
|
|
|
expect(obj.field1).toBe("val1");
|
|
expect(obj.field2).toBe("val2");
|
|
expect(obj.other).toBeUndefined();
|
|
});
|
|
|
|
test("should scan hash with count using hscan COUNT", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "user:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const fields: Record<string, string> = {};
|
|
for (let i = 0; i < 20; i++) {
|
|
fields[`field${i}`] = `value${i}`;
|
|
}
|
|
await redis.hset(key, fields);
|
|
|
|
const [cursor, result] = await redis.hscan(key, 0, "COUNT", 5);
|
|
expect(typeof cursor).toBe("string");
|
|
expect(result).toBeInstanceOf(Array);
|
|
|
|
expect(result.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
test("should increment hash field by integer using hincrby", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hincrby-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { counter: "10" });
|
|
|
|
const result1 = await redis.hincrby(key, "counter", 5);
|
|
expect(result1).toBe(15);
|
|
|
|
const result2 = await redis.hincrby(key, "counter", -3);
|
|
expect(result2).toBe(12);
|
|
|
|
const value = await redis.hget(key, "counter");
|
|
expect(value).toBe("12");
|
|
});
|
|
|
|
test("should increment hash field from zero using hincrby", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hincrby-zero-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result = await redis.hincrby(key, "newfield", 42);
|
|
expect(result).toBe(42);
|
|
|
|
const value = await redis.hget(key, "newfield");
|
|
expect(value).toBe("42");
|
|
});
|
|
|
|
test("should increment hash field by float using hincrbyfloat", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hincrbyfloat-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { price: "10.5" });
|
|
|
|
const result1 = await redis.hincrbyfloat(key, "price", 2.3);
|
|
expect(result1).toBe("12.8");
|
|
|
|
const result2 = await redis.hincrbyfloat(key, "price", -0.8);
|
|
expect(result2).toBe("12");
|
|
|
|
const value = await redis.hget(key, "price");
|
|
expect(value).toBe("12");
|
|
});
|
|
|
|
test("should increment hash field from zero using hincrbyfloat", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hincrbyfloat-zero-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const result = await redis.hincrbyfloat(key, "newfield", 3.14);
|
|
expect(result).toBe("3.14");
|
|
|
|
const value = await redis.hget(key, "newfield");
|
|
expect(value).toBe("3.14");
|
|
});
|
|
|
|
test("should get all hash keys using hkeys", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hkeys-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const keys = await redis.hkeys(key);
|
|
expect(keys).toBeInstanceOf(Array);
|
|
expect(keys.length).toBe(3);
|
|
expect(keys).toContain("name");
|
|
expect(keys).toContain("age");
|
|
expect(keys).toContain("city");
|
|
});
|
|
|
|
test("should return empty array for non-existent key using hkeys", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hkeys-nonexistent:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const keys = await redis.hkeys(key);
|
|
expect(keys).toEqual([]);
|
|
});
|
|
|
|
test("should get hash length using hlen", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hlen-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const length = await redis.hlen(key);
|
|
expect(length).toBe(3);
|
|
|
|
await redis.hset(key, { country: "USA" });
|
|
const newLength = await redis.hlen(key);
|
|
expect(newLength).toBe(4);
|
|
});
|
|
|
|
test("should return 0 for non-existent key using hlen", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hlen-nonexistent:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const length = await redis.hlen(key);
|
|
expect(length).toBe(0);
|
|
});
|
|
|
|
test("should get multiple hash values using hmget", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmget-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const values = await redis.hmget(key, "name", "age", "city");
|
|
expect(values).toEqual(["John", "30", "NYC"]);
|
|
});
|
|
|
|
test("should return null for missing fields using hmget", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hmget-missing-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const values = await redis.hmget(key, "name", "age", "city");
|
|
expect(values).toEqual(["John", null, null]);
|
|
});
|
|
|
|
test("should get all hash values using hvals", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hvals-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const values = await redis.hvals(key);
|
|
expect(values).toBeInstanceOf(Array);
|
|
expect(values.length).toBe(3);
|
|
expect(values).toContain("John");
|
|
expect(values).toContain("30");
|
|
expect(values).toContain("NYC");
|
|
});
|
|
|
|
test("should return empty array for non-existent key using hvals", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hvals-nonexistent:" + randomUUIDv7().substring(0, 8);
|
|
|
|
const values = await redis.hvals(key);
|
|
expect(values).toEqual([]);
|
|
});
|
|
|
|
test("should get hash field string length using hstrlen", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hstrlen-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", description: "Software Engineer" });
|
|
|
|
const nameLen = await redis.hstrlen(key, "name");
|
|
expect(nameLen).toBe(4);
|
|
|
|
const descLen = await redis.hstrlen(key, "description");
|
|
expect(descLen).toBe(17);
|
|
});
|
|
|
|
test("should return 0 for non-existent field using hstrlen", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hstrlen-nonexistent:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John" });
|
|
|
|
const length = await redis.hstrlen(key, "age");
|
|
expect(length).toBe(0);
|
|
});
|
|
|
|
test("should expire hash fields using hexpire", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpire-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30", city: "NYC" });
|
|
|
|
const result = await redis.hexpire(key, 10, "FIELDS", 2, "name", "age");
|
|
expect(result).toEqual([1, 1]);
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 3, "name", "age", "city");
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(10);
|
|
expect(ttls[1]).toBeGreaterThan(0);
|
|
expect(ttls[1]).toBeLessThanOrEqual(10);
|
|
expect(ttls[2]).toBe(-1);
|
|
});
|
|
|
|
test("should expire hash fields with NX flag using hexpire", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpire-nx-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hsetex(key, "EX", 100, "FIELDS", 1, "name", "John");
|
|
await redis.hset(key, { age: "30" });
|
|
|
|
const result = await redis.hexpire(key, 10, "NX", "FIELDS", 2, "name", "age");
|
|
expect(result).toEqual([0, 1]);
|
|
});
|
|
|
|
test("should expire hash fields at specific time using hexpireat", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpireat-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 60;
|
|
const result = await redis.hexpireat(key, futureTimestamp, "FIELDS", 2, "name", "age");
|
|
expect(result).toEqual([1, 1]);
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 2, "name", "age");
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(60);
|
|
expect(ttls[1]).toBeGreaterThan(0);
|
|
expect(ttls[1]).toBeLessThanOrEqual(60);
|
|
});
|
|
|
|
test("should get hash field expiration time using hexpiretime", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hexpiretime-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const futureTimestamp = Math.floor(Date.now() / 1000) + 100;
|
|
await redis.hexpireat(key, futureTimestamp, "FIELDS", 1, "name");
|
|
|
|
const expiretimes = await redis.hexpiretime(key, "FIELDS", 2, "name", "age");
|
|
expect(expiretimes).toHaveLength(2);
|
|
expect(expiretimes[0]).toBeGreaterThan(0);
|
|
expect(expiretimes[0]).toBeLessThanOrEqual(futureTimestamp);
|
|
expect(expiretimes[1]).toBe(-1);
|
|
});
|
|
|
|
test("should expire hash fields at specific time in milliseconds using hpexpireat", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpexpireat-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const futureTimestamp = Date.now() + 60000;
|
|
const result = await redis.hpexpireat(key, futureTimestamp, "FIELDS", 2, "name", "age");
|
|
expect(result).toEqual([1, 1]);
|
|
|
|
const ttls = await redis.hpttl(key, "FIELDS", 2, "name", "age");
|
|
expect(ttls[0]).toBeGreaterThan(0);
|
|
expect(ttls[0]).toBeLessThanOrEqual(60100);
|
|
expect(ttls[1]).toBeGreaterThan(0);
|
|
expect(ttls[1]).toBeLessThanOrEqual(60100);
|
|
});
|
|
|
|
test("should get hash field expiration time in milliseconds using hpexpiretime", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpexpiretime-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const futureTimestamp = Date.now() + 100000;
|
|
await redis.hpexpireat(key, futureTimestamp, "FIELDS", 1, "name");
|
|
|
|
const expiretimes = await redis.hpexpiretime(key, "FIELDS", 2, "name", "age");
|
|
expect(expiretimes).toHaveLength(2);
|
|
expect(expiretimes[0]).toBeGreaterThan(0);
|
|
expect(expiretimes[0]).toBeLessThanOrEqual(futureTimestamp);
|
|
expect(expiretimes[1]).toBe(-1);
|
|
});
|
|
|
|
test("should persist hash fields using hpersist", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpersist-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hsetex(key, "EX", 100, "FIELDS", 2, "name", "John", "age", "30");
|
|
|
|
const result = await redis.hpersist(key, "FIELDS", 2, "name", "age");
|
|
expect(result).toEqual([1, 1]);
|
|
|
|
const ttls = await redis.httl(key, "FIELDS", 2, "name", "age");
|
|
expect(ttls).toEqual([-1, -1]);
|
|
});
|
|
|
|
test("should return 0 for fields without expiration using hpersist", async () => {
|
|
const redis = ctx.redis;
|
|
const key = "hpersist-noexpire-test:" + randomUUIDv7().substring(0, 8);
|
|
|
|
await redis.hset(key, { name: "John", age: "30" });
|
|
|
|
const result = await redis.hpersist(key, "FIELDS", 2, "name", "age");
|
|
expect(result).toEqual([-1, -1]);
|
|
});
|
|
});
|
|
|
|
describe("Connection State", () => {
|
|
test("should have a connected property", () => {
|
|
const redis = ctx.redis;
|
|
|
|
expect(typeof redis.connected).toBe("boolean");
|
|
});
|
|
});
|
|
|
|
describe("RESP3 Data Types", () => {
|
|
test("should handle hash maps (dictionaries) as command responses", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const userId = "user:" + randomUUIDv7().substring(0, 8);
|
|
const setResult = await redis.send("HSET", [userId, "name", "John", "age", "30", "active", "true"]);
|
|
expect(setResult).toBeDefined();
|
|
|
|
const hash = await redis.send("HGETALL", [userId]);
|
|
expect(hash).toBeDefined();
|
|
|
|
if (typeof hash === "object" && hash !== null) {
|
|
expect(hash).toHaveProperty("name");
|
|
expect(hash).toHaveProperty("age");
|
|
expect(hash).toHaveProperty("active");
|
|
|
|
expect(hash.name).toBe("John");
|
|
expect(hash.age).toBe("30");
|
|
expect(hash.active).toBe("true");
|
|
}
|
|
});
|
|
|
|
test("should handle sets as command responses", async () => {
|
|
const redis = ctx.redis;
|
|
|
|
const setKey = "colors:" + randomUUIDv7().substring(0, 8);
|
|
const addResult = await redis.send("SADD", [setKey, "red", "blue", "green"]);
|
|
expect(addResult).toBeDefined();
|
|
|
|
const setMembers = await redis.send("SMEMBERS", [setKey]);
|
|
expect(setMembers).toBeDefined();
|
|
|
|
expect(Array.isArray(setMembers)).toBe(true);
|
|
|
|
expect(setMembers).toContain("red");
|
|
expect(setMembers).toContain("blue");
|
|
expect(setMembers).toContain("green");
|
|
});
|
|
});
|
|
|
|
describe("Connection Options", () => {
|
|
test("connection errors", async () => {
|
|
const url = new URL(connectionType === ConnectionType.TLS ? TLS_REDIS_URL : DEFAULT_REDIS_URL);
|
|
url.username = "badusername";
|
|
url.password = "secretpassword";
|
|
const customRedis = new RedisClient(url.toString(), {
|
|
tls: connectionType === ConnectionType.TLS ? TLS_REDIS_OPTIONS.tls : false,
|
|
});
|
|
|
|
expect(async () => {
|
|
await customRedis.get("test");
|
|
}).toThrowErrorMatchingInlineSnapshot(`"WRONGPASS invalid username-password pair or user is disabled."`);
|
|
});
|
|
|
|
const testKeyUniquePerDb = crypto.randomUUID();
|
|
test.each([...Array(16).keys()])("Connecting to database with url $url succeeds", async (dbId: number) => {
|
|
const redis = createClient(connectionType, {}, dbId);
|
|
|
|
const testValue = await redis.get(testKeyUniquePerDb);
|
|
expect(testValue).toBeNull();
|
|
|
|
redis.close();
|
|
});
|
|
});
|
|
|
|
describe("Reconnections", () => {
|
|
test.skip("should automatically reconnect after connection drop", async () => {
|
|
const TEST_KEY = "test-key";
|
|
const TEST_VALUE = "test-value";
|
|
|
|
if (!ctx.redis || !ctx.redis.connected) {
|
|
ctx.redis = createClient(connectionType);
|
|
}
|
|
|
|
const valueBeforeStart = await ctx.redis.get(TEST_KEY);
|
|
expect(valueBeforeStart).toBeNull();
|
|
|
|
await ctx.redis.set(TEST_KEY, TEST_VALUE);
|
|
const valueAfterSet = await ctx.redis.get(TEST_KEY);
|
|
expect(valueAfterSet).toBe(TEST_VALUE);
|
|
|
|
await ctx.restartServer();
|
|
|
|
const valueAfterStop = await ctx.redis.get(TEST_KEY);
|
|
expect(valueAfterStop).toBe(TEST_VALUE);
|
|
});
|
|
});
|
|
|
|
describe("PUB/SUB", () => {
|
|
var i = 0;
|
|
const testChannel = () => {
|
|
return `test-channel-${i++}`;
|
|
};
|
|
const testKey = () => {
|
|
return `test-key-${i++}`;
|
|
};
|
|
const testValue = () => {
|
|
return `test-value-${i++}`;
|
|
};
|
|
const testMessage = () => {
|
|
return `test-message-${i++}`;
|
|
};
|
|
|
|
beforeEach(async () => {
|
|
await ctx.cleanupSubscribers();
|
|
});
|
|
|
|
test("publishing to a channel does not fail", async () => {
|
|
expect(await ctx.redis.publish(testChannel(), testMessage())).toBe(0);
|
|
});
|
|
|
|
test("setting in subscriber mode gracefully fails", async () => {
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
|
|
await subscriber.subscribe(testChannel(), () => {});
|
|
|
|
expect(() => subscriber.set(testKey(), testValue())).toThrow(
|
|
"RedisClient.prototype.set cannot be called while in subscriber mode",
|
|
);
|
|
|
|
await subscriber.unsubscribe(testChannel());
|
|
});
|
|
|
|
test("setting after unsubscribing works", async () => {
|
|
const channel = testChannel();
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
await subscriber.subscribe(channel, () => {});
|
|
await subscriber.unsubscribe(channel);
|
|
expect(ctx.redis.set(testKey(), testValue())).resolves.toEqual("OK");
|
|
});
|
|
|
|
test("subscribing to a channel receives messages", async () => {
|
|
const TEST_MESSAGE_COUNT = 128;
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
const channel = testChannel();
|
|
const message = testMessage();
|
|
|
|
const counter = awaitableCounter();
|
|
await subscriber.subscribe(channel, (message, channel) => {
|
|
counter.increment();
|
|
expect(channel).toBe(channel);
|
|
expect(message).toBe(message);
|
|
});
|
|
|
|
Array.from({ length: TEST_MESSAGE_COUNT }).forEach(async () => {
|
|
expect(await ctx.redis.publish(channel, message)).toBe(1);
|
|
});
|
|
|
|
await counter.untilValue(TEST_MESSAGE_COUNT);
|
|
expect(counter.count()).toBe(TEST_MESSAGE_COUNT);
|
|
});
|
|
|
|
test("messages are received in order", async () => {
|
|
const channel = testChannel();
|
|
|
|
await ctx.redis.set("START-TEST", "1");
|
|
const TEST_MESSAGE_COUNT = 1024;
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
|
|
const counter = awaitableCounter();
|
|
var receivedMessages: string[] = [];
|
|
await subscriber.subscribe(channel, message => {
|
|
receivedMessages.push(message);
|
|
counter.increment();
|
|
});
|
|
|
|
const sentMessages = Array.from({ length: TEST_MESSAGE_COUNT }).map(() => {
|
|
return randomUUIDv7();
|
|
});
|
|
await Promise.all(
|
|
sentMessages.map(async message => {
|
|
expect(await ctx.redis.publish(channel, message)).toBe(1);
|
|
}),
|
|
);
|
|
|
|
await counter.untilValue(TEST_MESSAGE_COUNT);
|
|
expect(receivedMessages.length).toBe(sentMessages.length);
|
|
expect(receivedMessages).toEqual(sentMessages);
|
|
|
|
await subscriber.unsubscribe(channel);
|
|
|
|
await ctx.redis.set("STOP-TEST", "1");
|
|
});
|
|
|
|
test("subscribing to multiple channels receives messages", async () => {
|
|
const TEST_MESSAGE_COUNT = 128;
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
|
|
const channels = [testChannel(), testChannel()];
|
|
const counter = awaitableCounter();
|
|
|
|
var receivedMessages: { [channel: string]: string[] } = {};
|
|
await subscriber.subscribe(channels, (message, channel) => {
|
|
receivedMessages[channel] = receivedMessages[channel] || [];
|
|
receivedMessages[channel].push(message);
|
|
counter.increment();
|
|
});
|
|
|
|
var sentMessages: { [channel: string]: string[] } = {};
|
|
for (let i = 0; i < TEST_MESSAGE_COUNT; i++) {
|
|
const channel = channels[randomCoinFlip() ? 0 : 1];
|
|
const message = randomUUIDv7();
|
|
|
|
expect(await ctx.redis.publish(channel, message)).toBe(1);
|
|
|
|
sentMessages[channel] = sentMessages[channel] || [];
|
|
sentMessages[channel].push(message);
|
|
}
|
|
|
|
await counter.untilValue(TEST_MESSAGE_COUNT);
|
|
|
|
expect(Object.keys(receivedMessages).sort()).toEqual(Object.keys(sentMessages).sort());
|
|
|
|
for (const channel of channels) {
|
|
if (sentMessages[channel]) {
|
|
expect(receivedMessages[channel]).toEqual(sentMessages[channel]);
|
|
}
|
|
}
|
|
|
|
await subscriber.unsubscribe(channels);
|
|
});
|
|
|
|
test("unsubscribing from specific channels while remaining subscribed to others", async () => {
|
|
const channel1 = "channel-1";
|
|
const channel2 = "channel-2";
|
|
const channel3 = "channel-3";
|
|
|
|
const subscriber = createClient(connectionType);
|
|
await subscriber.connect();
|
|
|
|
let receivedMessages: { [channel: string]: string[] } = {};
|
|
|
|
const counter = awaitableCounter();
|
|
|
|
await subscriber.subscribe([channel1, channel2, channel3], (message, channel) => {
|
|
receivedMessages[channel] = receivedMessages[channel] || [];
|
|
receivedMessages[channel].push(message);
|
|
counter.increment();
|
|
});
|
|
|
|
expect(await ctx.redis.publish(channel1, "msg1-before")).toBe(1);
|
|
expect(await ctx.redis.publish(channel2, "msg2-before")).toBe(1);
|
|
expect(await ctx.redis.publish(channel3, "msg3-before")).toBe(1);
|
|
|
|
await counter.untilValue(3);
|
|
await subscriber.unsubscribe(channel2);
|
|
|
|
expect(await ctx.redis.publish(channel1, "msg1-after")).toBe(1);
|
|
expect(await ctx.redis.publish(channel2, "msg2-after")).toBe(0);
|
|
expect(await ctx.redis.publish(channel3, "msg3-after")).toBe(1);
|
|
|
|
await counter.untilValue(5);
|
|
|
|
expect(receivedMessages[channel1]).toEqual(["msg1-before", "msg1-after"]);
|
|
expect(receivedMessages[channel2]).toEqual(["msg2-before"]);
|
|
expect(receivedMessages[channel3]).toEqual(["msg3-before", "msg3-after"]);
|
|
|
|
await subscriber.unsubscribe([channel1, channel3]);
|
|
});
|
|
|
|
test("subscribing to the same channel multiple times", async () => {
|
|
const subscriber = createClient(connectionType);
|
|
await subscriber.connect();
|
|
const channel = testChannel();
|
|
|
|
const counter = awaitableCounter();
|
|
|
|
let callCount = 0;
|
|
const listener = () => {
|
|
callCount++;
|
|
counter.increment();
|
|
};
|
|
|
|
let callCount2 = 0;
|
|
const listener2 = () => {
|
|
callCount2++;
|
|
counter.increment();
|
|
};
|
|
|
|
await subscriber.subscribe(channel, listener);
|
|
await subscriber.subscribe(channel, listener2);
|
|
|
|
expect(await ctx.redis.publish(channel, "test-message")).toBe(1);
|
|
|
|
await counter.untilValue(2);
|
|
|
|
expect(callCount).toBe(1);
|
|
expect(callCount2).toBe(1);
|
|
|
|
await subscriber.unsubscribe(channel);
|
|
});
|
|
|
|
test("empty string messages", async () => {
|
|
const channel = "empty-message-channel";
|
|
const subscriber = createClient(connectionType);
|
|
await subscriber.connect();
|
|
|
|
const counter = awaitableCounter();
|
|
let receivedMessage: string | undefined = undefined;
|
|
await subscriber.subscribe(channel, message => {
|
|
receivedMessage = message;
|
|
counter.increment();
|
|
});
|
|
|
|
expect(await ctx.redis.publish(channel, "")).toBe(1);
|
|
await counter.untilValue(1);
|
|
|
|
expect(receivedMessage).not.toBeUndefined();
|
|
expect(receivedMessage!).toBe("");
|
|
|
|
await subscriber.unsubscribe(channel);
|
|
});
|
|
|
|
test("special characters in channel names", async () => {
|
|
const subscriber = createClient(connectionType);
|
|
await subscriber.connect();
|
|
|
|
const specialChannels = [
|
|
"channel:with:colons",
|
|
"channel with spaces",
|
|
"channel-with-unicode-😀",
|
|
"channel[with]brackets",
|
|
"channel@with#special$chars",
|
|
];
|
|
|
|
for (const channel of specialChannels) {
|
|
const counter = awaitableCounter();
|
|
let received = false;
|
|
await subscriber.subscribe(channel, () => {
|
|
received = true;
|
|
counter.increment();
|
|
});
|
|
|
|
expect(await ctx.redis.publish(channel, "test")).toBe(1);
|
|
await counter.untilValue(1);
|
|
|
|
expect(received).toBe(true);
|
|
await subscriber.unsubscribe(channel);
|
|
}
|
|
});
|
|
|
|
test("ping works in subscription mode", async () => {
|
|
const channel = "ping-test-channel";
|
|
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
await subscriber.subscribe(channel, () => {});
|
|
|
|
const pong = await subscriber.ping();
|
|
expect(pong).toBe("PONG");
|
|
|
|
const customPing = await subscriber.ping("hello");
|
|
expect(customPing).toBe("hello");
|
|
});
|
|
|
|
test("publish does not work from a subscribed client", async () => {
|
|
const channel = "self-publish-channel";
|
|
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
await subscriber.subscribe(channel, () => {});
|
|
|
|
expect(async () => subscriber.publish(channel, "self-published")).toThrow(
|
|
"RedisClient.prototype.publish cannot be called while in subscriber mode.",
|
|
);
|
|
});
|
|
|
|
test("complete unsubscribe restores normal command mode", async () => {
|
|
const channel = "restore-test-channel";
|
|
const testKey = "restore-test-key";
|
|
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
await subscriber.subscribe(channel, () => {});
|
|
|
|
expect(() => subscriber.set(testKey, testValue())).toThrow(
|
|
"RedisClient.prototype.set cannot be called while in subscriber mode.",
|
|
);
|
|
|
|
await subscriber.unsubscribe();
|
|
|
|
const result = await ctx.redis.set(testKey, "value");
|
|
expect(result).toBe("OK");
|
|
|
|
const value = await ctx.redis.get(testKey);
|
|
expect(value).toBe("value");
|
|
});
|
|
|
|
test("publishing without subscribers succeeds", async () => {
|
|
const channel = "no-subscribers-channel";
|
|
|
|
expect(await ctx.redis.publish(channel, "message")).toBe(0);
|
|
});
|
|
|
|
test("unsubscribing from non-subscribed channels", async () => {
|
|
const channel = "never-subscribed-channel";
|
|
|
|
expect(() => ctx.redis.unsubscribe(channel)).toThrow(
|
|
"RedisClient.prototype.unsubscribe can only be called while in subscriber mode.",
|
|
);
|
|
});
|
|
|
|
test("high volume pub/sub", async () => {
|
|
const channel = testChannel();
|
|
|
|
const MESSAGE_COUNT = 1000;
|
|
const MESSAGE_SIZE = 1024 * 1024;
|
|
|
|
let byteCounter = awaitableCounter(5_000); // 5s timeout
|
|
const subscriber = await ctx.redis.duplicate();
|
|
await subscriber.subscribe(channel, message => {
|
|
byteCounter.incrementBy(message.length);
|
|
});
|
|
|
|
for (let i = 0; i < MESSAGE_COUNT; i++) {
|
|
await ctx.redis.publish(channel, "X".repeat(MESSAGE_SIZE));
|
|
}
|
|
|
|
expect(await byteCounter.untilValue(MESSAGE_COUNT * MESSAGE_SIZE)).toBe(MESSAGE_COUNT * MESSAGE_SIZE);
|
|
subscriber.close();
|
|
});
|
|
|
|
test("callback errors don't crash the client (without IPC)", async () => {
|
|
const channel = "error-callback-channel";
|
|
|
|
const subscriberProc = spawn({
|
|
cmd: [bunExe(), `${__dirname}/valkey.failing-subscriber-no-ipc.ts`],
|
|
stdout: "pipe",
|
|
stderr: "inherit",
|
|
stdin: "pipe",
|
|
env: { ...process.env, NODE_ENV: "development" },
|
|
});
|
|
|
|
const reader = subscriberProc.stdout.getReader();
|
|
async function* readLines() {
|
|
const decoder = new TextDecoder();
|
|
let buffer = "";
|
|
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
|
|
buffer += decoder.decode(value, { stream: true });
|
|
const lines = buffer.split("\n");
|
|
buffer = lines.pop() || "";
|
|
|
|
for (const line of lines) {
|
|
yield line;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function waitForChildMessage<MsgT extends Message>(expectedEvent: MsgT["event"]): Promise<MsgT> {
|
|
for await (const line of readLines()) {
|
|
const parsed = JSON.parse(line);
|
|
if (typeof parsed !== "object") {
|
|
throw new Error("Expected object message");
|
|
}
|
|
if (parsed.event === undefined || typeof parsed.event !== "string") {
|
|
throw new Error("Expected event field as a string");
|
|
}
|
|
if (parsed.event !== expectedEvent) {
|
|
throw new Error(`Expected event ${expectedEvent} but got ${parsed.event}`);
|
|
}
|
|
return parsed as MsgT;
|
|
}
|
|
throw new Error("Input stream unexpectedly closed");
|
|
}
|
|
|
|
async function messageChild<MsgT extends Message>(msg: MsgT): Promise<void> {
|
|
subscriberProc.stdin!.write(JSON.stringify(msg) + "\n");
|
|
}
|
|
|
|
try {
|
|
// Wait for the process to announce it is ready for messages.
|
|
await waitForChildMessage("ready-for-url");
|
|
|
|
// Tell the child to start and connect to Redis.
|
|
await messageChild({
|
|
event: "start",
|
|
url: connectionType === ConnectionType.TLS ? TLS_REDIS_URL : DEFAULT_REDIS_URL,
|
|
tlsPaths: connectionType === ConnectionType.TLS ? TLS_REDIS_OPTIONS.tlsPaths : undefined,
|
|
});
|
|
await waitForChildMessage("ready");
|
|
|
|
expect(await ctx.redis.publish(channel, "message1")).toBeGreaterThanOrEqual(1);
|
|
expect(await waitForChildMessage("message")).toMatchObject({ index: 1 });
|
|
|
|
// This should throw inside the child process, so it should notify us.
|
|
expect(await ctx.redis.publish(channel, "message2")).toBeGreaterThanOrEqual(1);
|
|
await waitForChildMessage("exception");
|
|
|
|
expect(await ctx.redis.publish(channel, "message1")).toBeGreaterThanOrEqual(1);
|
|
expect(await waitForChildMessage("message")).toMatchObject({ index: 3 });
|
|
} finally {
|
|
subscriberProc.kill();
|
|
await subscriberProc.exited;
|
|
}
|
|
});
|
|
|
|
test("callback errors don't crash the client", async () => {
|
|
const channel = "error-callback-channel";
|
|
|
|
const STEP_WAITING_FOR_URL = 1;
|
|
const STEP_SUBSCRIBED = 2;
|
|
const STEP_FIRST_MESSAGE = 3;
|
|
const STEP_SECOND_MESSAGE = 4;
|
|
const STEP_THIRD_MESSAGE = 5;
|
|
|
|
const stepCounter = awaitableCounter();
|
|
let currentMessage: any = {};
|
|
|
|
const subscriberProc = spawn({
|
|
cmd: [bunExe(), `${__dirname}/valkey.failing-subscriber.ts`],
|
|
stdout: "inherit",
|
|
stderr: "inherit",
|
|
ipc: msg => {
|
|
currentMessage = msg;
|
|
stepCounter.increment();
|
|
},
|
|
env: {
|
|
...process.env,
|
|
NODE_ENV: "development",
|
|
},
|
|
});
|
|
|
|
await stepCounter.untilValue(STEP_WAITING_FOR_URL);
|
|
expect(currentMessage.event).toBe("waiting-for-url");
|
|
subscriberProc.send({
|
|
event: "start",
|
|
url: connectionType === ConnectionType.TLS ? TLS_REDIS_URL : DEFAULT_REDIS_URL,
|
|
tlsPaths: connectionType === ConnectionType.TLS ? TLS_REDIS_OPTIONS.tlsPaths : undefined,
|
|
} as RedisTestStartMessage);
|
|
|
|
try {
|
|
await stepCounter.untilValue(STEP_SUBSCRIBED);
|
|
expect(currentMessage.event).toBe("ready");
|
|
|
|
expect(await ctx.redis.publish(channel, "message1")).toBeGreaterThanOrEqual(1);
|
|
await stepCounter.untilValue(STEP_FIRST_MESSAGE);
|
|
expect(currentMessage.event).toBe("message");
|
|
expect(currentMessage.index).toBe(1);
|
|
|
|
expect(await ctx.redis.publish(channel, "message2")).toBeGreaterThanOrEqual(1);
|
|
await stepCounter.untilValue(STEP_SECOND_MESSAGE);
|
|
expect(currentMessage.event).toBe("exception");
|
|
//expect(currentMessage.index).toBe(2);
|
|
|
|
expect(await ctx.redis.publish(channel, "message3")).toBeGreaterThanOrEqual(1);
|
|
await stepCounter.untilValue(STEP_THIRD_MESSAGE);
|
|
expect(currentMessage.event).toBe("message");
|
|
expect(currentMessage.index).toBe(3);
|
|
} finally {
|
|
subscriberProc.kill();
|
|
await subscriberProc.exited;
|
|
}
|
|
});
|
|
|
|
test("subscriptions return correct counts", async () => {
|
|
const subscriber = createClient(connectionType);
|
|
await subscriber.connect();
|
|
|
|
expect(await subscriber.subscribe("chan1", () => {})).toBe(1);
|
|
expect(await subscriber.subscribe("chan2", () => {})).toBe(2);
|
|
});
|
|
|
|
test("unsubscribing from listeners", async () => {
|
|
const channel = "error-callback-channel";
|
|
|
|
const subscriber = createClient(connectionType);
|
|
await subscriber.connect();
|
|
|
|
const counter = awaitableCounter();
|
|
let messageCount1 = 0;
|
|
const listener1 = () => {
|
|
messageCount1++;
|
|
counter.increment();
|
|
};
|
|
await subscriber.subscribe(channel, listener1);
|
|
|
|
let messageCount2 = 0;
|
|
const listener2 = () => {
|
|
messageCount2++;
|
|
counter.increment();
|
|
};
|
|
await subscriber.subscribe(channel, listener2);
|
|
|
|
await ctx.redis.publish(channel, "message1");
|
|
await counter.untilValue(2);
|
|
|
|
expect(messageCount1).toBe(1);
|
|
expect(messageCount2).toBe(1);
|
|
|
|
console.log("Unsubscribing listener2");
|
|
await subscriber.unsubscribe(channel, listener2);
|
|
|
|
await ctx.redis.publish(channel, "message1");
|
|
await counter.untilValue(3);
|
|
|
|
expect(messageCount1).toBe(2);
|
|
expect(messageCount2).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("duplicate()", () => {
|
|
test("should create duplicate of connected client that gets connected", async () => {
|
|
const duplicate = await ctx.redis.duplicate();
|
|
|
|
expect(duplicate.connected).toBe(true);
|
|
expect(duplicate).not.toBe(ctx.redis);
|
|
|
|
await ctx.redis.set("test-original", "original-value");
|
|
await duplicate.set("test-duplicate", "duplicate-value");
|
|
|
|
expect(await ctx.redis.get("test-duplicate")).toBe("duplicate-value");
|
|
expect(await duplicate.get("test-original")).toBe("original-value");
|
|
|
|
duplicate.close();
|
|
});
|
|
|
|
test("should preserve connection configuration in duplicate", async () => {
|
|
await ctx.redis.connect();
|
|
|
|
const duplicate = await ctx.redis.duplicate();
|
|
|
|
const testKey = `duplicate-config-test-${randomUUIDv7().substring(0, 8)}`;
|
|
const testValue = "test-value";
|
|
|
|
await ctx.redis.set(testKey, testValue);
|
|
const retrievedValue = await duplicate.get(testKey);
|
|
|
|
expect(retrievedValue).toBe(testValue);
|
|
|
|
duplicate.close();
|
|
});
|
|
|
|
test("should allow duplicate to work independently from original", async () => {
|
|
const duplicate = await ctx.redis.duplicate();
|
|
|
|
duplicate.close();
|
|
|
|
const testKey = `independent-test-${randomUUIDv7().substring(0, 8)}`;
|
|
const testValue = "independent-value";
|
|
|
|
await ctx.redis.set(testKey, testValue);
|
|
const retrievedValue = await ctx.redis.get(testKey);
|
|
|
|
expect(retrievedValue).toBe(testValue);
|
|
});
|
|
|
|
test("should handle duplicate of client in subscriber mode", async () => {
|
|
const subscriber = await ctx.newSubscriberClient(connectionType);
|
|
|
|
const testChannel = "test-subscriber-duplicate";
|
|
|
|
await subscriber.subscribe(testChannel, () => {});
|
|
|
|
const duplicate = await subscriber.duplicate();
|
|
|
|
expect(() => duplicate.set("test-key", "test-value")).not.toThrow();
|
|
|
|
await subscriber.unsubscribe(testChannel);
|
|
});
|
|
|
|
test("should create multiple duplicates from same client", async () => {
|
|
await ctx.redis.connect();
|
|
|
|
const duplicate1 = await ctx.redis.duplicate();
|
|
const duplicate2 = await ctx.redis.duplicate();
|
|
const duplicate3 = await ctx.redis.duplicate();
|
|
|
|
expect(duplicate1.connected).toBe(true);
|
|
expect(duplicate2.connected).toBe(true);
|
|
expect(duplicate3.connected).toBe(true);
|
|
|
|
const testKey = `multi-duplicate-test-${randomUUIDv7().substring(0, 8)}`;
|
|
await duplicate1.set(`${testKey}-1`, "value-1");
|
|
await duplicate2.set(`${testKey}-2`, "value-2");
|
|
await duplicate3.set(`${testKey}-3`, "value-3");
|
|
|
|
expect(await duplicate1.get(`${testKey}-1`)).toBe("value-1");
|
|
expect(await duplicate2.get(`${testKey}-2`)).toBe("value-2");
|
|
expect(await duplicate3.get(`${testKey}-3`)).toBe("value-3");
|
|
|
|
expect(await duplicate1.get(`${testKey}-2`)).toBe("value-2");
|
|
expect(await duplicate2.get(`${testKey}-3`)).toBe("value-3");
|
|
expect(await duplicate3.get(`${testKey}-1`)).toBe("value-1");
|
|
|
|
duplicate1.close();
|
|
duplicate2.close();
|
|
duplicate3.close();
|
|
});
|
|
|
|
test("should duplicate client that failed to connect", async () => {
|
|
const url = new URL(connectionType === ConnectionType.TLS ? TLS_REDIS_URL : DEFAULT_REDIS_URL);
|
|
url.username = "invaliduser";
|
|
url.password = "invalidpassword";
|
|
const failedRedis = new RedisClient(url.toString(), {
|
|
tls: connectionType === ConnectionType.TLS ? TLS_REDIS_OPTIONS.tls : false,
|
|
});
|
|
|
|
let connectionFailed = false;
|
|
try {
|
|
await failedRedis.connect();
|
|
} catch {
|
|
connectionFailed = true;
|
|
}
|
|
|
|
expect(connectionFailed).toBe(true);
|
|
expect(failedRedis.connected).toBe(false);
|
|
|
|
const duplicate = await failedRedis.duplicate();
|
|
expect(duplicate.connected).toBe(false);
|
|
});
|
|
|
|
test("should handle duplicate timing with concurrent operations", async () => {
|
|
await ctx.redis.connect();
|
|
|
|
const testKey = `concurrent-test-${randomUUIDv7().substring(0, 8)}`;
|
|
const originalOperation = ctx.redis.set(testKey, "original-value");
|
|
|
|
const duplicate = await ctx.redis.duplicate();
|
|
|
|
await originalOperation;
|
|
|
|
expect(await duplicate.get(testKey)).toBe("original-value");
|
|
|
|
duplicate.close();
|
|
});
|
|
});
|
|
});
|
|
}
|