cacheGet and cacheSet must not accept undefined parameters

wallet.id can be undefined if Wallet.generate_entity() is called without
saving the result and then `asyncEvmAddress` property is accessed.  This
only occurred in tests and those instances have been resolved.

Author: mlclay

src/__tests__/contracts.ts

@@ -50,7 +50,9 @@ export const ContractEntityTests = async function() {
         async () => {
             await Project.loadFixturesFromFile('/app/src/__tests__/meta.json');
             const owner = await Wallet.generate_entity();
+            await owner.save();
             const other = await Wallet.generate_entity();
+            await other.save();
 
             const local = await utils.setupLocalTestNetContracts({ ShipToken: LATEST_SHIPTOKEN, LOAD: LATEST_LOAD, NOTARY: LATEST_NOTARY }, [owner]);
             const network: Network = await Network.getLocalTestNet();

src/__tests__/eventsubscriptions.ts

@@ -82,7 +82,9 @@ export const EventSubscriptionEntityTests = async  function() {
             }
             await Project.loadFixturesFromFile('/app/src/__tests__/meta.json');
             const owner = await Wallet.generate_entity();
+            await owner.save();
             const other = await Wallet.generate_entity();
+            await other.save();
 
             const local = await utils.setupLocalTestNetContracts({ShipToken: LATEST_SHIPTOKEN, LOAD: LATEST_LOAD}, [owner]);
             const network: Network = await Network.getLocalTestNet();

src/__tests__/redis.ts

@@ -75,4 +75,69 @@ export const RedisTests = async function() {
         expect(returnedValue).toEqual(value2);
     });
 
+    it(`cacheSet should throw on undefined key`, async() => {
+        let caughtError;
+
+        try {
+            await cacheSet(undefined, field, value);
+            fail(`Should have thrown`);
+        } catch (err) {
+            caughtError = err;
+        }
+
+        expect(caughtError.toString()).toContain(`Invalid parameters for cacheSet: (undefined,${field},${value})`);
+    });
+
+    it(`cacheSet should throw on undefined field`, async() => {
+        let caughtError;
+
+        try {
+            await cacheSet(key, undefined, value);
+            fail(`Should have thrown`);
+        } catch (err) {
+            caughtError = err;
+        }
+
+        expect(caughtError.toString()).toContain(`Invalid parameters for cacheSet: (${key},undefined,${value})`);
+    });
+
+    it(`cacheSet should throw on undefined value`, async() => {
+        let caughtError;
+
+        try {
+            await cacheSet(key, field, undefined);
+            fail(`Should have thrown`);
+        } catch (err) {
+            caughtError = err;
+        }
+
+        expect(caughtError.toString()).toContain(`Invalid parameters for cacheSet: (${key},${field},undefined)`);
+    });
+
+    it(`cacheGet should throw on undefined key`, async() => {
+        let caughtError;
+
+        try {
+            await cacheGet(undefined, field);
+            fail(`Should have thrown`);
+        } catch (err) {
+            caughtError = err;
+        }
+
+        expect(caughtError.toString()).toContain(`Invalid parameters for cacheGet: (undefined,${field})`);
+    });
+
+    it(`cacheGet should throw on undefined field`, async() => {
+        let caughtError;
+
+        try {
+            await cacheGet(key, undefined);
+            fail(`Should have thrown`);
+        } catch (err) {
+            caughtError = err;
+        }
+
+        expect(caughtError.toString()).toContain(`Invalid parameters for cacheGet: (${key},undefined)`);
+    });
+
 };

src/redis.ts

@@ -47,7 +47,12 @@ export function getRedisClient() {
 }
 
 export async function cacheGet(key: string, field: string): Promise<any> {
+    if (!key || !field) {
+        throw new Error(`Invalid parameters for cacheGet: (${key},${field})`);
+    }
+
     const client = getRedisClient();
+
     try {
         return await client.asyncHashGet(key, field);
     } catch (err) {
@@ -57,7 +62,12 @@ export async function cacheGet(key: string, field: string): Promise<any> {
 }
 
 export async function cacheSet(key: string, field: string, value: any): Promise<void> {
+    if (!key || !field || !value) {
+        throw new Error(`Invalid parameters for cacheSet: (${key},${field},${value})`);
+    }
+
     const client = getRedisClient();
+
     try {
         await client.asyncHashSet(key, field, value);
     } catch (err) {