@upstash/redis 0.0.0-ci.babdc47f97e036e2863dfed16300cda2b97bf6ad-20240322001434 → 0.0.0-ci.bb93ac2803c2e927dc8bf1a1b3c5aa2a14034eb6-20240930061920

package/pkg/auto-pipeline.test.ts

@@ -0,0 +1,321 @@
+import { Redis } from "../platforms/nodejs";
+import { keygen, newHttpClient } from "./test-utils";
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { ScriptLoadCommand } from "./commands/script_load";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterEach(cleanup);
+
+describe("Auto pipeline", () => {
+  test("should execute all commands inside a Promise.all in a single pipeline", async () => {
+    const persistentKey = newKey();
+    const persistentKey2 = newKey();
+    const persistentKey3 = newKey();
+    const scriptHash = await new ScriptLoadCommand(["return 1"]).exec(client);
+
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    // all the following commands are in a single pipeline call
+    const result = await Promise.all([
+      redis.append(newKey(), "hello"),
+      redis.bitcount(newKey(), 0, 1),
+      redis.bitop("and", newKey(), newKey()),
+      redis.bitpos(newKey(), 1, 0),
+      redis.dbsize(),
+      redis.decr(newKey()),
+      redis.decrby(newKey(), 1),
+      redis.del(newKey()),
+      redis.echo("hello"),
+      redis.eval("return ARGV[1]", [], ["Hello"]),
+      redis.evalsha(scriptHash, [], ["Hello"]),
+      redis.exists(newKey()),
+      redis.expire(newKey(), 5),
+      redis.expireat(newKey(), Math.floor(Date.now() / 1000) + 60),
+      redis.flushall(),
+      redis.flushdb(),
+      redis.get(newKey()),
+      redis.getbit(newKey(), 0),
+      redis.getdel(newKey()),
+      redis.getset(newKey(), "hello"),
+      redis.hdel(newKey(), "field"),
+      redis.hexists(newKey(), "field"),
+      redis.hget(newKey(), "field"),
+      redis.hgetall(newKey()),
+      redis.hincrby(newKey(), "field", 1),
+      redis.hincrbyfloat(newKey(), "field", 1.5),
+      redis.hkeys(newKey()),
+      redis.hlen(newKey()),
+      redis.hmget(newKey(), newKey()),
+      redis.hmset(newKey(), { field: "field", value: "value" }),
+      redis.hscan(newKey(), 0),
+      redis.hset(newKey(), { field: "value" }),
+      redis.hsetnx(newKey(), "field", "value"),
+      redis.hstrlen(newKey(), "field"),
+      redis.hvals(newKey()),
+      redis.incr(newKey()),
+      redis.incrby(newKey(), 1),
+      redis.incrbyfloat(newKey(), 1.5),
+      redis.keys("*"),
+      redis.lindex(newKey(), 0),
+      redis.linsert(newKey(), "before", "pivot", "value"),
+      redis.llen(newKey()),
+      redis.lmove(newKey(), newKey(), "left", "right"),
+      redis.lpop(newKey()),
+      redis.lpos(newKey(), "value"),
+      redis.lpush(persistentKey, "element"),
+      redis.lpushx(newKey(), "element1", "element2"),
+      redis.lrange(newKey(), 0, 1),
+      redis.lrem(newKey(), 1, "value"),
+      redis.lset(persistentKey, 0, "value"),
+      redis.ltrim(newKey(), 0, 1),
+      redis.hrandfield(newKey()),
+      redis.hrandfield(newKey(), 2),
+      redis.hrandfield(newKey(), 3, true),
+      redis.mget<[string, string]>(newKey(), newKey()),
+      redis.mset({ key1: "value", key2: "value" }),
+      redis.msetnx({ key3: "value", key4: "value" }),
+      redis.persist(newKey()),
+      redis.pexpire(newKey(), 1000),
+      redis.pexpireat(newKey(), Date.now() + 1000),
+      redis.ping(),
+      redis.psetex(newKey(), 1, "value"),
+      redis.pttl(newKey()),
+      redis.publish("test", "hello"),
+      redis.randomkey(),
+      redis.rename(persistentKey, persistentKey2),
+      redis.renamenx(persistentKey2, newKey()),
+      redis.rpop(newKey()),
+      redis.rpush(newKey(), "element1", "element2"),
+      redis.rpushx(newKey(), "element1", "element2"),
+      redis.sadd(newKey(), "memeber1", "member2"),
+      redis.scan(0),
+      redis.scard(newKey()),
+      redis.sdiff(newKey()),
+      redis.sdiffstore(newKey(), newKey()),
+      redis.set(newKey(), "value"),
+      redis.setbit(newKey(), 1, 1),
+      redis.setex(newKey(), 1, "value"),
+      redis.setnx(newKey(), "value"),
+      redis.setrange(newKey(), 1, "value"),
+      redis.sinter(newKey(), newKey()),
+      redis.sinterstore(newKey(), newKey()),
+      redis.sismember(newKey(), "member"),
+      redis.smembers(newKey()),
+      redis.smove(newKey(), newKey(), "member"),
+      redis.spop(newKey()),
+      redis.srandmember(newKey()),
+      redis.srem(newKey(), "member"),
+      redis.sscan(newKey(), 0),
+      redis.strlen(newKey()),
+      redis.sunion(newKey()),
+      redis.sunionstore(newKey(), newKey()),
+      redis.time(),
+      redis.touch(newKey()),
+      redis.ttl(newKey()),
+      redis.type(newKey()),
+      redis.unlink(newKey()),
+      redis.zadd(newKey(), { score: 0, member: "member" }),
+      redis.zcard(newKey()),
+      redis.scriptExists(scriptHash),
+      redis.scriptFlush({ async: true }),
+      redis.scriptLoad("return 1"),
+      redis.zcount(newKey(), 0, 1),
+      redis.zincrby(newKey(), 1, "member"),
+      redis.zinterstore(newKey(), 1, [newKey()]),
+      redis.zlexcount(newKey(), "-", "+"),
+      redis.zpopmax(newKey()),
+      redis.zpopmin(newKey()),
+      redis.zrange(newKey(), 0, 1),
+      redis.zrank(newKey(), "member"),
+      redis.zrem(newKey(), "member"),
+      redis.zremrangebylex(newKey(), "-", "+"),
+      redis.zremrangebyrank(newKey(), 0, 1),
+      redis.zremrangebyscore(newKey(), 0, 1),
+      redis.zrevrank(newKey(), "member"),
+      redis.zscan(newKey(), 0),
+      redis.zscore(newKey(), "member"),
+      redis.zunionstore(newKey(), 1, [newKey()]),
+      redis.zunion(1, [newKey()]),
+      redis.json.set(persistentKey3, "$", { log: ["one", "two"] }),
+      redis.json.arrappend(persistentKey3, "$.log", '"three"'),
+    ]);
+    expect(result).toBeTruthy();
+    expect(result.length).toBe(121); // returns
+    // @ts-expect-error pipelineCounter is not in type but accessible120 results
+    expect(redis.pipelineCounter).toBe(1);
+  });
+
+  test("should group async requests with sync requests", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    // following five commands are added to the pipeline
+    void redis.flushdb();
+    void redis.incr("baz");
+    void redis.incr("baz");
+    void redis.set("foo", "bar");
+    void redis.incr("baz");
+
+    // two get calls are added to the pipeline and pipeline
+    // is executed since we called await
+    const [fooValue, bazValue] = await Promise.all([redis.get("foo"), redis.get("baz")]);
+
+    expect(fooValue).toBe("bar");
+    expect(bazValue).toBe(3);
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(1);
+  });
+
+  test("should execute a pipeline for each consecutive awaited command", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    void redis.flushdb();
+
+    const res1 = await redis.incr("baz");
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(1);
+
+    const res2 = await redis.incr("baz");
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(2);
+
+    const res3 = await redis.set("foo", "bar");
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(3);
+
+    expect([res1, res2, res3]).toEqual([1, 2, "OK"]);
+  });
+
+  test("should execute a single pipeline for several commands inside Promise.all", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const resArray = await Promise.all([
+      redis.flushdb(),
+      redis.incr("baz"),
+      redis.incr("baz"),
+      redis.set("foo", "bar"),
+      redis.get("foo"),
+    ]);
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(1);
+    expect(resArray).toEqual(["OK", 1, 2, "OK", "bar"]);
+  });
+
+  test("should be able to utilize only redis functions 'use' like usual", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    let state = false;
+    redis.use(async (req, next) => {
+      state = true;
+      return await next(req);
+    });
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const a = await redis.incr("aeroplane");
+    expect(a).toEqual(1);
+    expect(state).toEqual(true);
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(1);
+  });
+
+  test("should be able to utilize only redis functions 'multi' and 'pipeline' like usual", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const pipe = redis.pipeline();
+    pipe.incr("voila");
+    pipe.incr("voila");
+    const result = await pipe.exec();
+    expect(result).toEqual([1, 2]);
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const transaction = redis.multi();
+    transaction.incr("et voila");
+    transaction.incr("et voila");
+    const result_2 = await transaction.exec();
+    expect(result_2).toEqual([1, 2]);
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+  });
+
+  test("should be able to utilize only redis functions 'createScript' like usual", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const script = redis.createScript("return ARGV[1];");
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const res = await script.eval([], ["Hello World"]);
+    expect(res).toEqual("Hello World");
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(1);
+  });
+
+  test("should handle JSON commands correctly", async () => {
+    const redis = Redis.fromEnv({
+      latencyLogging: false,
+      enableAutoPipelining: true,
+    });
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(0);
+
+    const res = await Promise.all([
+      redis.set("foo1", "bar"),
+      redis.json.set("baz1", "$", { hello: "world" }),
+      redis.get("foo1"),
+      redis.json.get("baz1"),
+      redis.json.del("baz1"),
+      redis.json.get("baz1"),
+    ]);
+
+    // @ts-expect-error pipelineCounter is not in type but accessible
+    expect(redis.pipelineCounter).toBe(1);
+
+    expect(res).toEqual(["OK", "OK", "bar", { hello: "world" }, 1, null]);
+  });
+});

package/pkg/auto-pipeline.ts

@@ -0,0 +1,107 @@
+import type { Command } from "./commands/command";
+import type { Pipeline } from "./pipeline";
+import type { Redis } from "./redis";
+import type { CommandArgs } from "./types";
+
+// properties which are only available in redis
+type redisOnly = Exclude<keyof Redis, keyof Pipeline>;
+
+export function createAutoPipelineProxy(_redis: Redis, json?: boolean): Redis {
+  const redis = _redis as Redis & {
+    autoPipelineExecutor: AutoPipelineExecutor;
+  };
+
+  if (!redis.autoPipelineExecutor) {
+    redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
+  }
+
+  return new Proxy(redis, {
+    get: (redis, command: "pipelineCounter" | keyof Pipeline | redisOnly) => {
+      // return pipelineCounter of autoPipelineExecutor
+      if (command === "pipelineCounter") {
+        return redis.autoPipelineExecutor.pipelineCounter;
+      }
+
+      if (command === "json") {
+        return createAutoPipelineProxy(redis, true);
+      }
+
+      const commandInRedisButNotPipeline =
+        command in redis && !(command in redis.autoPipelineExecutor.pipeline);
+
+      if (commandInRedisButNotPipeline) {
+        return redis[command as redisOnly];
+      }
+
+      // If the method is a function on the pipeline, wrap it with the executor logic
+      const isFunction = json
+        ? typeof redis.autoPipelineExecutor.pipeline.json[command as keyof Pipeline["json"]] ===
+          "function"
+        : typeof redis.autoPipelineExecutor.pipeline[command as keyof Pipeline] === "function";
+      if (isFunction) {
+        return (...args: CommandArgs<typeof Command>) => {
+          // pass the function as a callback
+          return redis.autoPipelineExecutor.withAutoPipeline((pipeline) => {
+            if (json) {
+              (pipeline.json[command as keyof Pipeline["json"]] as (...args: any) => unknown)(
+                ...args
+              );
+            } else {
+              (pipeline[command as keyof Pipeline] as (...args: any) => unknown)(...args);
+            }
+          });
+        };
+      }
+
+      // if the property is not a function, a property of redis or "pipelineCounter"
+      // simply return it from pipeline
+      return redis.autoPipelineExecutor.pipeline[command as keyof Pipeline];
+    },
+  }) as Redis;
+}
+
+class AutoPipelineExecutor {
+  private pipelinePromises = new WeakMap<Pipeline, Promise<unknown[]>>();
+  private activePipeline: Pipeline | null = null;
+  private indexInCurrentPipeline = 0;
+  private redis: Redis;
+  pipeline: Pipeline; // only to make sure that proxy can work
+  pipelineCounter = 0; // to keep track of how many times a pipeline was executed
+
+  constructor(redis: Redis) {
+    this.redis = redis;
+    this.pipeline = redis.pipeline();
+  }
+
+  async withAutoPipeline<T>(executeWithPipeline: (pipeline: Pipeline) => unknown): Promise<T> {
+    const pipeline = this.activePipeline ?? this.redis.pipeline();
+
+    if (!this.activePipeline) {
+      this.activePipeline = pipeline;
+      this.indexInCurrentPipeline = 0;
+    }
+
+    const index = this.indexInCurrentPipeline++;
+    executeWithPipeline(pipeline);
+
+    const pipelineDone = this.deferExecution().then(() => {
+      if (!this.pipelinePromises.has(pipeline)) {
+        const pipelinePromise = pipeline.exec();
+        this.pipelineCounter += 1;
+
+        this.pipelinePromises.set(pipeline, pipelinePromise);
+        this.activePipeline = null;
+      }
+
+      return this.pipelinePromises.get(pipeline)!;
+    });
+
+    const results = await pipelineDone;
+    return results[index] as T;
+  }
+
+  private async deferExecution() {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+}

package/pkg/commands/append.test.ts

@@ -0,0 +1,28 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+import { AppendCommand } from "./append";
+
+import { afterAll, describe, expect, test } from "bun:test";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when key is not set", () => {
+  test("appends to empty value", async () => {
+    const key = newKey();
+    const value = randomID();
+    const res = await new AppendCommand([key, value]).exec(client);
+    expect(res).toEqual(value.length);
+  });
+});
+
+describe("when key is set", () => {
+  test("appends to existing value", async () => {
+    const key = newKey();
+    const value = randomID();
+    const res = await new AppendCommand([key, value]).exec(client);
+    expect(res).toEqual(value.length);
+    const res2 = await new AppendCommand([key, "_"]).exec(client);
+    expect(res2).toEqual(value.length + 1);
+  });
+});

package/pkg/commands/append.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/append
+ */
+export class AppendCommand extends Command<number, number> {
+  constructor(cmd: [key: string, value: string], opts?: CommandOptions<number, number>) {
+    super(["append", ...cmd], opts);
+  }
+}

package/pkg/commands/bitcount.test.ts

@@ -0,0 +1,37 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { BitCountCommand } from "./bitcount";
+
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when key is not set", () => {
+  test("returns 0", async () => {
+    const key = newKey();
+    const res = await new BitCountCommand([key]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("when key is set", () => {
+  test("returns bitcount", async () => {
+    const key = newKey();
+    const value = "Hello World";
+    await new SetCommand([key, value]).exec(client);
+    const res = await new BitCountCommand([key]).exec(client);
+    expect(res).toEqual(43);
+  });
+
+  test("with start and end", () => {
+    test("returns bitcount", async () => {
+      const key = newKey();
+      const value = "Hello World";
+      await new SetCommand([key, value]).exec(client);
+      const res = await new BitCountCommand([key, 4, 8]).exec(client);
+      expect(res).toEqual(22);
+    });
+  });
+});

package/pkg/commands/bitcount.ts

@@ -0,0 +1,29 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/bitcount
+ */
+export class BitCountCommand extends Command<number, number> {
+  constructor(
+    cmd: [key: string, start?: never, end?: never],
+    opts?: CommandOptions<number, number>
+  );
+  constructor(
+    cmd: [key: string, start: number, end: number],
+    opts?: CommandOptions<number, number>
+  );
+  constructor(
+    [key, start, end]: [key: string, start?: number, end?: number],
+    opts?: CommandOptions<number, number>
+  ) {
+    const command: unknown[] = ["bitcount", key];
+    if (typeof start === "number") {
+      command.push(start);
+    }
+    if (typeof end === "number") {
+      command.push(end);
+    }
+    super(command, opts);
+  }
+}

package/pkg/commands/bitfield.test.ts

@@ -0,0 +1,51 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { BitFieldCommand } from "./bitfield";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when key is not set", () => {
+  test("returns 0", async () => {
+    const key = newKey();
+    const res = await new BitFieldCommand([key], client).get("u4", "#0").exec();
+    expect(res).toEqual([0]);
+  });
+});
+
+describe("when key is set", () => {
+  test("sets / gets value", async () => {
+    const key = newKey();
+    const value = 42;
+    const res = await new BitFieldCommand([key], client)
+      .set("u8", "#0", value)
+      .get("u8", "#0")
+      .exec();
+    expect(res).toEqual([0, value]);
+  });
+
+  test("increments value", async () => {
+    const key = newKey();
+    const value = 42;
+    const increment = 10;
+    const res = await new BitFieldCommand([key], client)
+      .set("u8", "#0", value)
+      .incrby("u8", "#0", increment)
+      .exec();
+    expect(res).toEqual([0, value + increment]);
+  });
+
+  test("overflows", async () => {
+    const key = newKey();
+    const value = 255;
+    const bitWidth = 8;
+    const res = await new BitFieldCommand([key], client)
+      .set(`u${bitWidth}`, "#0", value)
+      .incrby(`u${bitWidth}`, "#0", 10)
+      .overflow("WRAP")
+      .exec();
+    expect(res).toEqual([0, (value + 10) % 2 ** bitWidth]);
+  });
+});

package/pkg/commands/bitfield.ts

@@ -0,0 +1,50 @@
+import { type Requester } from "../http";
+import { Command, type CommandOptions } from "./command";
+
+type SubCommandArgs<TRest extends unknown[] = []> = [
+  encoding: string, // u1 - u63 | i1 - i64
+  offset: number | string, // <int> | #<int>
+  ...rest: TRest,
+];
+
+/**
+ * @see https://redis.io/commands/bitfield
+ */
+export class BitFieldCommand<T = Promise<number[]>> {
+  private command: (string | number)[];
+
+  constructor(
+    args: [key: string],
+    private client: Requester,
+    private opts?: CommandOptions<number[], number[]>,
+    private execOperation = (command: Command<number[], number[]>) => command.exec(this.client) as T
+  ) {
+    this.command = ["bitfield", ...args];
+  }
+
+  private chain(...args: typeof this.command) {
+    this.command.push(...args);
+    return this;
+  }
+
+  get(...args: SubCommandArgs) {
+    return this.chain("get", ...args);
+  }
+
+  set(...args: SubCommandArgs<[value: number]>) {
+    return this.chain("set", ...args);
+  }
+
+  incrby(...args: SubCommandArgs<[increment: number]>) {
+    return this.chain("incrby", ...args);
+  }
+
+  overflow(overflow: "WRAP" | "SAT" | "FAIL") {
+    return this.chain("overflow", overflow);
+  }
+
+  exec() {
+    const command = new Command(this.command, this.opts);
+    return this.execOperation(command);
+  }
+}

package/pkg/commands/bitop.test.ts

@@ -0,0 +1,45 @@
+import { BitOpCommand } from "./bitop";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when key is not set", () => {
+  test("returns 0", async () => {
+    const source = newKey();
+    const dest = newKey();
+    const res = await new BitOpCommand(["and", dest, source]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("when key is set", () => {
+  describe("not", () => {
+    test("inverts all bits", async () => {
+      const source = newKey();
+      const sourcevalue = "Hello World";
+      const dest = newKey();
+      const destValue = "foo: bar";
+      await new SetCommand([source, sourcevalue]).exec(client);
+      await new SetCommand([dest, destValue]).exec(client);
+      const res = await new BitOpCommand(["not", dest, source]).exec(client);
+      expect(res).toEqual(11);
+    });
+  });
+  describe("and", () => {
+    test("works", async () => {
+      const source = newKey();
+      const sourcevalue = "Hello World";
+      const dest = newKey();
+      const destValue = "foo: bar";
+      await new SetCommand([source, sourcevalue]).exec(client);
+      await new SetCommand([dest, destValue]).exec(client);
+      const res = await new BitOpCommand(["and", dest, source]).exec(client);
+      expect(res).toEqual(11);
+    });
+  });
+});