fixed testing

valkey-io · Jun 4, 2024 · 2b6f3ba · 2b6f3ba
1 parent e93129a
commit 2b6f3ba
Show file tree

Hide file tree

Showing 3 changed files with 39 additions and 32 deletions.
diff --git a/.github/workflows/build-node-wrapper/action.yml b/.github/workflows/build-node-wrapper/action.yml
@@ -80,6 +80,5 @@ runs:
           working-directory: ./node
           run: |
               source "$HOME/.cargo/env"
-              TARGET_FLAG=`if [ "${{ inputs.target }}" != ''  ]; then echo "--target ${{ inputs.target }}"; fi`
               BUILD_FLAG=`if [ "${{ inputs.publish }}" == 'true' ]; then echo "build:release"; else echo "build"; fi`
-              npm run $BUILD_FLAG --build-flags="$TARGET_FLAG"
+              npm run $BUILD_FLAG
diff --git a/node/tests/RedisClusterClient.test.ts b/node/tests/RedisClusterClient.test.ts
@@ -32,7 +32,7 @@ type Context = {
     client: RedisClusterClient;
 };
 
-const TIMEOUT = 10000;
+const TIMEOUT = 50000;
 
 describe("RedisClusterClient", () => {
     let testsFailed = 0;

diff --git a/node/tests/SharedTests.ts b/node/tests/SharedTests.ts
@@ -2499,7 +2499,7 @@ export function runBaseTests<Context>(config: {
         const setWithUnixSec = await client.set(key, value, {
             expiry: {
                 type: "unixSeconds",
-                count: 1,
+                count: Math.floor(Date.now() / 1000) + 1,
             },
         });
         expect(setWithUnixSec).toEqual("OK");
@@ -2513,20 +2513,21 @@ export function runBaseTests<Context>(config: {
         const getResWithExpiryKeep = await client.get(key);
         expect(getResWithExpiryKeep).toEqual(value);
         // wait for the key to expire base on the previous set
-        setTimeout(() => {}, 1000);
+        let sleep = new Promise((resolve) => setTimeout(resolve, 1000));
+        await sleep;
         const getResExpire = await client.get(key);
         // key should have expired
         expect(getResExpire).toEqual(null);
-
         const setResWithExpiryWithUmilli = await client.set(key, value, {
             expiry: {
                 type: "unixMilliseconds",
-                count: 2,
+                count: Date.now() + 1000,
             },
         });
         expect(setResWithExpiryWithUmilli).toEqual("OK");
         // wait for the key to expire
-        setTimeout(() => {}, 3);
+        sleep = new Promise((resolve) => setTimeout(resolve, 1001));
+        await sleep;
         const getResWithExpiryWithUmilli = await client.get(key);
         // key should have expired
         expect(getResWithExpiryWithUmilli).toEqual(null);
@@ -2535,19 +2536,23 @@ export function runBaseTests<Context>(config: {
     async function setWithOnlyIfExistOptions(client: BaseClient) {
         const key = uuidv4();
         const value = uuidv4();
+        const setKey = await client.set(key, value);
+        expect(setKey).toEqual("OK");
+        const getRes = await client.get(key);
+        expect(getRes).toEqual(value);
         const setExistingKeyRes = await client.set(key, value, {
             conditionalSet: "onlyIfExists",
         });
         expect(setExistingKeyRes).toEqual("OK");
         const getExistingKeyRes = await client.get(key);
         expect(getExistingKeyRes).toEqual(value);
 
-        const notExistingKeyRes = await client.set(key, value + "1", {
+        const notExistingKeyRes = await client.set(key + 1, value, {
             conditionalSet: "onlyIfExists",
         });
         // key does not exist, so it should not be set
         expect(notExistingKeyRes).toEqual(null);
-        const getNotExistingKey = await client.get(key);
+        const getNotExistingKey = await client.get(key + 1);
         // key should not have been set
         expect(getNotExistingKey).toEqual(null);
     }
@@ -2604,9 +2609,9 @@ export function runBaseTests<Context>(config: {
         const setResWithAllOptions = await client.set(key, value, {
             expiry: {
                 type: "unixSeconds",
-                count: 1,
+                count: Math.floor(Date.now() / 1000) + 1,
             },
-            conditionalSet: "onlyIfExists",
+            conditionalSet: "onlyIfDoesNotExist",
             returnOldValue: true,
         });
         // key does not exist, so old value should be null
@@ -2616,7 +2621,8 @@ export function runBaseTests<Context>(config: {
         expect(getResWithAllOptions).toEqual(value);
 
         // wait for the key to expire
-        setTimeout(() => {}, 1000);
+        const sleep = new Promise((resolve) => setTimeout(resolve, 1001));
+        await sleep;
         // key should have expired
         const gettResWithAllOptions = await client.get(key);
         expect(gettResWithAllOptions).toEqual(null);
@@ -2644,25 +2650,26 @@ export function runBaseTests<Context>(config: {
         for (const expiryVal of expiryCombination) {
             for (const conditionalSetVal of conditionalSetCombination) {
                 for (const returnOldValueVal of returnOldValueCombination) {
-                    const setRes = await client.set(key, value, {
-                        expiry: expiryVal as
-                            | "keepExisting"
-                            | {
-                                  type:
-                                      | "seconds"
-                                      | "milliseconds"
-                                      | "unixSeconds"
-                                      | "unixMilliseconds";
-                                  count: number;
-                              }
-                            | undefined,
-                        conditionalSet: conditionalSetVal as
-                            | "onlyIfExists"
-                            | "onlyIfDoesNotExist"
-                            | undefined,
-                        returnOldValue: returnOldValueVal,
-                    });
-                    expect(setRes).not.toBeNull();
+                    expect(async () => {
+                        await client.set(key, value, {
+                            expiry: expiryVal as
+                                | "keepExisting"
+                                | {
+                                      type:
+                                          | "seconds"
+                                          | "milliseconds"
+                                          | "unixSeconds"
+                                          | "unixMilliseconds";
+                                      count: number;
+                                  }
+                                | undefined,
+                            conditionalSet: conditionalSetVal as
+                                | "onlyIfExists"
+                                | "onlyIfDoesNotExist"
+                                | undefined,
+                            returnOldValue: returnOldValueVal,
+                        });
+                    }).not.toThrowError();
                 }
             }
         }
@@ -2678,6 +2685,7 @@ export function runBaseTests<Context>(config: {
                 await setWithGetOldOptions(client);
                 await setWithAllOptions(client);
                 await testSetWithAllCombination(client);
+                expect(true).toEqual(true);
             }, protocol);
         },
         config.timeout,