chore(test): update tests

Author: aleclarson

test/send.test.ts

@@ -7,6 +7,7 @@ import {
   RedisClient,
   RedisCommand,
   RedisKey,
+  RedisSet,
   SADD,
   SCARD,
   SDIFF,
@@ -31,6 +32,12 @@ afterAll(async () => {
   await redis.close();
 });
 
+async function sendOnce(redis: RedisClient, command: RedisCommand) {
+  const result = await redis.send(command);
+  await redis.close();
+  return result;
+}
+
 test("send", async () => {
   const encoder = new TextEncoder();
 
@@ -46,80 +53,80 @@ test("send", async () => {
 
   // sendOnce will disconnect after the command is resolved.
   expect(redis.connected).toBe(true);
-  expect(await redis.sendOnce(GET(foo))).toEqual(undefined);
+  expect(await sendOnce(redis, GET(foo))).toEqual(undefined);
   expect(redis.connected).toBe(false);
 
   // This reconnects before sending the command.
-  expect(await redis.sendOnce(PING())).toEqual("PONG");
+  expect(await sendOnce(redis, PING())).toEqual("PONG");
 });
 
 test("set commands", async () => {
-  const setKey = new RedisKey("myset", Type.String());
+  const fooSet = new RedisSet("myset", Type.String());
   const member1 = "member1";
   const member2 = "member2";
   const member3 = "member3";
 
   // SMEMBERS non-existent set
-  expect(await redis.send(SMEMBERS(setKey))).toEqual([]);
+  expect(await redis.send(SMEMBERS(fooSet))).toEqual([]);
 
   // SADD
-  expect(await redis.send(SADD(setKey, member1, member2))).toEqual(2);
-  expect(await redis.send(SADD(setKey, member1))).toEqual(0); // Already exists
+  expect(await redis.send(SADD(fooSet, member1, member2))).toEqual(2);
+  expect(await redis.send(SADD(fooSet, member1))).toEqual(0); // Already exists
 
   // SCARD
-  expect(await redis.send(SCARD(setKey))).toEqual(2);
+  expect(await redis.send(SCARD(fooSet))).toEqual(2);
 
   // SMEMBERS
-  expect(await redis.send(SMEMBERS(setKey))).toEqual(
+  expect(await redis.send(SMEMBERS(fooSet))).toEqual(
     expect.arrayContaining([member1, member2]),
   );
 
   // SISMEMBER
-  expect(await redis.send(SISMEMBER(setKey, member1))).toEqual(true);
-  expect(await redis.send(SISMEMBER(setKey, member3))).toEqual(false);
+  expect(await redis.send(SISMEMBER(fooSet, member1))).toEqual(true);
+  expect(await redis.send(SISMEMBER(fooSet, member3))).toEqual(false);
 
   // SPOP
-  let poppedMember = await redis.send(SPOP(setKey));
+  let poppedMember = await redis.send(SPOP(fooSet));
   expect([member1, member2]).toContain(poppedMember);
-  expect(await redis.send(SCARD(setKey))).toEqual(1); // Size reduced by 1
+  expect(await redis.send(SCARD(fooSet))).toEqual(1); // Size reduced by 1
 
   // SADD back member1 and member2 for further tests
-  await redis.send(SADD(setKey, member1, member2));
+  await redis.send(SADD(fooSet, member1, member2));
 
   // SREM
-  expect(await redis.send(SREM(setKey, member1))).toEqual(1);
-  expect(await redis.send(SREM(setKey, member3))).toEqual(0); // Not exists
-  expect(await redis.send(SCARD(setKey))).toEqual(1); // Size reduced by 1
+  expect(await redis.send(SREM(fooSet, member1))).toEqual(1);
+  expect(await redis.send(SREM(fooSet, member3))).toEqual(0); // Not exists
+  expect(await redis.send(SCARD(fooSet))).toEqual(1); // Size reduced by 1
 
   // SADD back member1 for further tests
-  await redis.send(SADD(setKey, member1));
+  await redis.send(SADD(fooSet, member1));
 
-  const anotherSetKey = new RedisKey("anotherset", Type.String());
-  await redis.send(SADD(anotherSetKey, member2, member3));
+  const otherSet = new RedisSet("anotherset", Type.String());
+  await redis.send(SADD(otherSet, member2, member3));
 
   // SDIFF
-  expect(await redis.send(SDIFF(setKey, anotherSetKey))).toEqual(
+  expect(await redis.send(SDIFF(fooSet, otherSet))).toEqual(
     expect.arrayContaining([member1]),
   );
 
   // SINTER
-  expect(await redis.send(SINTER(setKey, anotherSetKey))).toEqual(
+  expect(await redis.send(SINTER(fooSet, otherSet))).toEqual(
     expect.arrayContaining([member2]),
   );
 
   // SUNION
-  expect(await redis.send(SUNION(setKey, anotherSetKey))).toEqual(
+  expect(await redis.send(SUNION(fooSet, otherSet))).toEqual(
     expect.arrayContaining([member1, member2, member3]),
   );
 
   // DEL set key
-  expect(await redis.send(DEL(setKey))).toEqual(1);
-  expect(await redis.send(DEL(anotherSetKey))).toEqual(1);
+  expect(await redis.send(DEL(fooSet))).toEqual(1);
+  expect(await redis.send(DEL(otherSet))).toEqual(1);
 });
 
 test("error handling", async () => {
   await expect(
-    redis.sendOnce(new RedisCommand(["MY_GO"])),
+    sendOnce(redis, new RedisCommand(["MY_GO"])),
   ).rejects.toThrowError(
     "ERR unknown command 'MY_GO', with args beginning with: ",
   );