@adobe/acc-js-sdk 1.0.2 → 1.0.6

package/test/caches.test.js

@@ -18,6 +18,7 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 
 const assert = require('assert');
+const { Cache, SafeStorage } = require('../src/cache.js');
 const OptionCache = require('../src/optionCache.js').OptionCache;
 const MethodCache = require('../src/methodCache.js').MethodCache;
 const XtkEntityCache = require('../src/xtkEntityCache.js').XtkEntityCache;
@@ -25,6 +26,36 @@ const { DomUtil } = require('../src/domUtil.js');
 
 describe('Caches', function() {
 
+    describe("Generic cache", () => {
+        it("Should cache with default TTL and default key function", () => {
+            const cache = new Cache();
+            cache.put("Hello", "World");
+            expect(cache.get("Hello")).toBe("World");
+        })
+
+        it("Should expires after TTL", () => {
+            const cache = new Cache(undefined, undefined, -1);    // negative TTL => will immediately expire
+            cache.put("Hello", "World");
+            expect(cache.get("Hello")).toBeUndefined();
+        })
+
+        it("Should support custom key function", () => {
+            const cache = new Cache(undefined, undefined, 300000, ((a, b) => a + "||" + b));
+            cache.put("key-part-1", "key-part-2", "value");
+            expect(cache.get("key-part-1")).toBeUndefined();
+            expect(cache.get("key-part-2")).toBeUndefined();
+            expect(cache.get("key-part-1", "key-part-2")).toBe("value");
+        })
+
+        it("Should clear cache", () => {
+            const cache = new Cache();
+            cache.put("Hello", "World");
+            expect(cache.get("Hello")).toBe("World");
+            cache.clear();
+            expect(cache.get("Hello")).toBeUndefined();
+        })
+    })
+
     describe("Entity cache", function() {
         it("Should cache value", function() {
             const cache = new XtkEntityCache();
@@ -55,15 +86,15 @@ describe('Caches', function() {
         it("Should cache value", function() {
             const cache = new OptionCache();
             expect(cache.get("hello")).toBeUndefined();
-            cache.cache("hello", ["world", 6]);
+            cache.put("hello", ["world", 6]);
             expect(cache.get("hello")).toBe("world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
         });
 
         it("Should cache multiple value", function() {
             const cache = new OptionCache();
-            cache.cache("hello", ["world", 6]);
-            cache.cache("foo", ["bar", 6]);
+            cache.put("hello", ["world", 6]);
+            cache.put("foo", ["bar", 6]);
             expect(cache.get("hello")).toBe("world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
             expect(cache.get("foo")).toBe("bar");
@@ -72,17 +103,17 @@ describe('Caches', function() {
 
         it("Should overwrite cached value", function() {
             const cache = new OptionCache();
-            cache.cache("hello", ["world", 6]);
+            cache.put("hello", ["world", 6]);
             expect(cache.get("hello")).toBe( "world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
-            cache.cache("hello", ["cruel world", 6]);
+            cache.put("hello", ["cruel world", 6]);
             expect(cache.get("hello")).toBe("cruel world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "cruel world", "type": 6, "value": "cruel world"});
         });
 
         it("Should clear cache", function() {
             const cache = new OptionCache();
-            cache.cache("hello", ["world", 6]);
+            cache.put("hello", ["world", 6]);
             expect(cache.get("hello")).toBe("world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
             cache.clear();
@@ -96,13 +127,19 @@ describe('Caches', function() {
             expect(cache.getOption("hello")).toBeUndefined();
         });
 
+        it("Deprecated cache methods should now replaced with put", () => {
+            const cache = new OptionCache();
+            cache.cache("hello", ["world", 6]);
+            expect(cache.get("hello")).toBe("world");
+            expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
+        });
     });
 
     describe("Method cache", function() {
         it("Should cache methods", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             var found = cache.get("nms:recipient", "Delete");
             assert.ok(found !== null && found !== undefined);
@@ -118,7 +155,7 @@ describe('Caches', function() {
         it("Should cache interface methods", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient' implements='nms:i'><interface name='i'><method name='Update'/></interface><element name='recipient'/><methods><method name='Delete'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
             // interface method should be on schema
             var found = cache.get("nms:recipient", "Update");
             assert.ok(found !== null && found !== undefined);
@@ -127,10 +164,10 @@ describe('Caches', function() {
             assert.ok(found !== null && found !== undefined);
         });
 
-        it("Should cler the cache", function() {
+        it("Should clear the cache", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             var found = cache.get("nms:recipient", "Delete");
             assert.ok(found !== null && found !== undefined);
@@ -143,7 +180,7 @@ describe('Caches', function() {
         it("Should ignore non-method nodes", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><dummy name='Update'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             var found = cache.get("nms:recipient", "Delete");
             assert.ok(found !== null && found !== undefined);
@@ -152,6 +189,33 @@ describe('Caches', function() {
             found = cache.get("nms:recipient", "Create");
             assert.ok(found !== null && found !== undefined);
         });
+
+        it("Deprecated cache methods should now replaced with put", () => {
+            const cache = new MethodCache();
+            var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><method name='Create'/></methods></schema>");
+            cache.cache(schema.documentElement);
+
+            var found = cache.get("nms:recipient", "Delete");
+            assert.ok(found !== null && found !== undefined);
+            assert.equal(found.nodeName, "method");
+            assert.equal(found.getAttribute("name"), "Delete");
+
+            found = cache.get("nms:recipient", "Create");
+            assert.ok(found !== null && found !== undefined);
+            assert.equal(found.nodeName, "method");
+            assert.equal(found.getAttribute("name"), "Create");
+        })
+   
+        it("Deserialized method should be a DOM element", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            const cached = {value: { x:3, method:DomUtil.parse("<hello/>")} };
+            const serialized = serDeser(cached, true); 
+            const deserialized = serDeser(serialized, false);
+            const method = deserialized.value.method;
+            // should be a DOM element, not a DOM document
+            expect(method.nodeType).toBe(1);
+        })
     });
 
     describe("Method cache for interfaces", function() {
@@ -160,7 +224,7 @@ describe('Caches', function() {
             // Test for fix in verion 0.1.23. The xtk:session schema has a direct method "Logon" but also implements the
             // xtk:persist interface.
             var schema = DomUtil.parse("<schema namespace='xtk' name='session' implements='xtk:persist'><interface name='persist'><method name='Write' static='true'/></interface><methods><method name='Logon'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             // Logon method should be found in xtk:session and have the xtk:session URN (for SOAP action)
             var found = cache.get("xtk:session", "Logon");
@@ -196,7 +260,7 @@ describe('Caches', function() {
         it("Edge cases for getSoapUrn", () => {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='xtk' name='session' implements='xtk:persist'><interface name='persist'><method name='Write' static='true'/></interface><methods><method name='Logon'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             // Schema and method exist
             var urn = cache.getSoapUrn("xtk:session", "Logon");
@@ -215,7 +279,7 @@ describe('Caches', function() {
             const cache = new MethodCache();
             // Schema has xtk:persist interface but does not implement it
             var schema = DomUtil.parse("<schema namespace='xtk' name='session'><interface name='persist'><method name='Write' static='true'/></interface><methods><method name='Logon'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             // Logon method should be found in xtk:session and have the xtk:session URN (for SOAP action)
             var found = cache.get("xtk:session", "Logon");
@@ -226,4 +290,140 @@ describe('Caches', function() {
             assert.strictEqual(urn, "xtk:session");
         });
     });
+
+    describe("SafeStorage", () => {
+
+        describe("JSON safe storage", () => {
+
+            it("Should find mock json from the cache", () => {
+                const map = {};
+                const delegate = {
+                    getItem: jest.fn((key) => map[key]),
+                    setItem: jest.fn((key, value) => map[key] = value)
+                }
+                const storage = new SafeStorage(delegate, "");
+                expect(storage.getItem("not_found")).toBeUndefined();
+                map["k1"] = `{ "hello": "world" }`;
+                expect(storage.getItem("k1")).toMatchObject({ hello: "world" });
+                map["k2"] = `{ "value": { "hello": "world" } }`;
+                expect(storage.getItem("k2")).toMatchObject({ value: { hello: "world" } });
+            });
+        });
+
+        describe("XML safe storage", () => {
+
+            const xmlSerDeser = (item, serDeser) => {
+                if (serDeser) {
+                    const xml = DomUtil.toXMLString(item.value);
+                    const value = {...item, value: xml };
+                    return JSON.stringify(value);
+                }
+                else {
+                    const json = JSON.parse(item);
+                    const dom = DomUtil.parse(json.value);
+                    return {...json, value:dom.documentElement};
+                }
+            };
+
+            it("Should find mock xml from the cache", () => {
+                const map = {};
+                const delegate = {
+                    getItem: jest.fn((key) => map[key]),
+                    setItem: jest.fn((key, value) => map[key] = value)
+                }
+                const storage = new SafeStorage(delegate, "", xmlSerDeser);
+                expect(storage.getItem("not_found")).toBeUndefined();
+                map["k1"] = `{ "hello": "world" }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute containing serialized XML
+                map["k1"] = `{ "hello": "world", "value": "" }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute containing serialized XML
+                map["k1"] = `{ "value": { "hello": "world" } }`;
+                expect(storage.getItem("k2")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k1"] = `{ "value": "" } }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k1"] = `{ "value": "bad" } }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k2"] = `{ "value": "<hello/>" }`;
+                expect(storage.getItem("k2").value.tagName).toBe("hello");
+            });
+        });
+    });
+
+    describe("Cache seralizers", () => {
+        it("Should serialize json", () => {
+            const cache = new OptionCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({ hello: "World" }, true)).toBe('{"hello":"World"}');
+            expect(serDeser({ }, true)).toBe('{}');
+            expect(() => {serDeser(null, true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser(undefined, true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser("", true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser("Hello", true)}).toThrow("Cannot serialize");
+        })
+
+        it("Should deserialize json", () => {
+            const cache = new OptionCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser('{"hello":"World"}', false)).toMatchObject({ hello: "World" });
+            expect(serDeser('{}', false)).toMatchObject({ });
+            expect(() => {serDeser(null, false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser(undefined, false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser("", false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser("Hello", false)}).toThrow("Unexpected token");
+        })
+
+        it("Should serialize XML entity", () => {
+            const cache = new XtkEntityCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({value: DomUtil.parse("<hello/>")}, true)).toBe('{"value":"<hello/>"}')
+            expect(() => { serDeser({}, true); }).toThrow();
+            expect(() => { serDeser(null, true); }).toThrow();
+            expect(() => { serDeser(undefined, true); }).toThrow();
+            expect(() => { serDeser("", true); }).toThrow();
+            expect(() => { serDeser("Hello", true); }).toThrow();
+        })
+
+        it("Should deserialize XML entity", () => {
+            const cache = new XtkEntityCache();
+            const serDeser = cache._storage._serDeser;
+            expect(DomUtil.toXMLString(serDeser(`{"value":"<hello/>"}`, false).value)).toBe("<hello/>");
+            expect(() => {serDeser(null, false)}).toThrow();
+            expect(() => {serDeser(undefined, false)}).toThrow();
+            expect(() => {serDeser("", false)}).toThrow();
+            expect(() => {serDeser("Hello", false)}).toThrow();
+        })
+
+        it("Should serialize methods", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({value: { x:3, method:DomUtil.parse("<hello/>")} }, true)).toBe('{"value":{"x":3,"method":"<hello/>"}}')
+            expect(() => { serDeser({value: { x:3 }}, true); }).toThrow();
+            expect(() => { serDeser({}, true); }).toThrow();
+            expect(() => { serDeser(null, true); }).toThrow();
+            expect(() => { serDeser(undefined, true); }).toThrow();
+            expect(() => { serDeser("", true); }).toThrow();
+            expect(() => { serDeser("Hello", true); }).toThrow();
+        })
+
+        it("Should deserialize methods", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            expect(DomUtil.toXMLString(serDeser('{"value":{"x":3,"method":"<hello/>"}}', false).value.method)).toBe("<hello/>");
+            expect(() => { serDeser('{"value":{"x":3}}', false); }).toThrow();
+            expect(() => { serDeser({}, false); }).toThrow();
+            expect(() => { serDeser(null, false); }).toThrow();
+            expect(() => { serDeser(undefined, false); }).toThrow();
+            expect(() => { serDeser("", false); }).toThrow();
+            expect(() => { serDeser("Hello", false); }).toThrow();
+        })
+
+        it("Method serialization should not change initial object", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            const cached = {value: { x:3, method:DomUtil.parse("<hello/>")} };
+            serDeser(cached, true); // make sure this call does not change the input parameter "cached"
+            expect(cached.value.x).toBe(3);
+            expect(cached.value.method.documentElement.tagName).toBe("hello");
+        })
+    })
 });