@adobe/acc-js-sdk 1.0.2 → 1.0.6

package/test/util.test.js

@@ -17,7 +17,8 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
 
-const { Util } = require('../src/util.js');
+ const { Util } = require('../src/util.js');
+ const { SafeStorage, Cache } = require('../src/cache.js');
 
 
 describe('Util', function() {
@@ -80,6 +81,155 @@ describe('Util', function() {
             expect(Util.trim({hello:'Lead<sessiontoken xsi:type="xsd:string">Stuff</sessiontoken>Trail'})).toStrictEqual({hello:'Lead<sessiontoken xsi:type="xsd:string">***</sessiontoken>Trail'});
         })
 
+        it("Should remove password", () => {
+            expect(Util.trim({hello:`<sessiontoken xsi:type="xsd:string"/><login xsi:type="xsd:string">admin</login><password xsi:type="xsd:string">password</password><parameters xsi:type="ns:Element" SOAP-ENV:encodingStyle="http://xml.apache.org/xml-soap/literalxml"/>`})).toStrictEqual({hello:`<sessiontoken xsi:type="xsd:string"/><login xsi:type="xsd:string">admin</login><password xsi:type="xsd:string">***</password><parameters xsi:type="ns:Element" SOAP-ENV:encodingStyle="http://xml.apache.org/xml-soap/literalxml"/>`});
+        })
+
+        it("Should hide X-Security-Token properties", () => {
+            expect(Util.trim({"x-security-token": "Hello"})).toMatchObject({"x-security-token": "***"});
+            expect(Util.trim({"X-Security-Token": "Hello"})).toMatchObject({"X-Security-Token": "***"});
+        })
+
+        it("Should remove session tokens from cookies", () => {
+            expect(Util.trim({"Cookie": "__sessiontoken=ABC"})).toMatchObject({"Cookie": "__sessiontoken=***"});
+            expect(Util.trim({"Cookie": "__sessionToken=ABC"})).toMatchObject({"Cookie": "__sessionToken=***"});
+            expect(Util.trim({"Cookie": "__sessiontoken=ABC;"})).toMatchObject({"Cookie": "__sessiontoken=***;"});
+            expect(Util.trim({"Cookie": "__sessiontoken =ABC"})).toMatchObject({"Cookie": "__sessiontoken =***"});
+            expect(Util.trim({"Cookie": "__sessiontoken ABC"})).toMatchObject({"Cookie": "__sessiontoken ABC"});  // no = sign => no token value
+            expect(Util.trim({"Cookie": "a=b; __sessiontoken =ABC"})).toMatchObject({"Cookie": "a=b; __sessiontoken =***"});  
+            expect(Util.trim({"Cookie": "a=b; __sessiontoken =ABC; c=d"})).toMatchObject({"Cookie": "a=b; __sessiontoken =***; c=d"});
+            expect(Util.trim({"Cookie": "a=b; __token =ABC; c=d"})).toMatchObject({"Cookie": "a=b; __token =ABC; c=d"});
+        })
+    })
+
+
+    describe("Safe storage", () => {
+      it("Should support undefined delegate", () => {
+          const storage = new SafeStorage();
+          expect(storage.getItem("Hello")).toBeUndefined();
+          storage.setItem("Hello", { text: "World" });
+          expect(storage.getItem("Hello")).toBeUndefined();
+          storage.setItem("Hello", "World");    // value should be JSON but errors are ignored
+          expect(storage.getItem("Hello")).toBeUndefined();
+          storage.removeItem("Hello");
+          expect(storage.getItem("Hello")).toBeUndefined();
+      })  
+
+      it("Should handle map", () => {
+        const map = {};
+        const delegate = {
+            getItem: (key) => map[key],
+            setItem: (key, value) => { map[key] = value },
+            removeItem: (key) => { delete map[key] }
+        };
+        const storage = new SafeStorage(delegate);
+        expect(storage.getItem("Hello")).toBeUndefined();
+        storage.setItem("Hello", { text: "World" });
+        expect(map["Hello"]).toStrictEqual(JSON.stringify({text: "World"}));
+        expect(storage.getItem("Hello")).toStrictEqual({"text": "World"});
+        storage.setItem("Hello", "World");    // value should be JSON but errors are ignored
+        expect(storage.getItem("Hello")).toBeUndefined();
+        storage.setItem("Hello", { text: "World" });
+        storage.removeItem("Hello");
+        expect(storage.getItem("Hello")).toBeUndefined();
+      })
+
+      it("Should handle root key", () => {
+        const map = {};
+        const delegate = {
+            getItem: (key) => map[key],
+            setItem: (key, value) => { map[key] = value },
+            removeItem: (key) => { delete map[key] }
+        };
+        const storage = new SafeStorage(delegate, "root");
+        expect(storage.getItem("Hello")).toBeUndefined();
+        storage.setItem("Hello", { text: "World" });
+        expect(map["root$Hello"]).toStrictEqual(JSON.stringify({text: "World"}));
+        expect(storage.getItem("Hello")).toStrictEqual({"text": "World"});
+        storage.setItem("Hello", "World");    // value should be JSON but errors are ignored
+        expect(map["root$Hello"]).toBeUndefined();
+        expect(storage.getItem("Hello")).toBeUndefined();
+        storage.setItem("Hello", { text: "World" });
+        storage.removeItem("Hello");
+        expect(map["root$Hello"]).toBeUndefined();
+        expect(storage.getItem("Hello")).toBeUndefined();
+      })
+
+      it("Edge cases", () => {
+        expect(new SafeStorage()._storage).toBeUndefined();
+        expect(new SafeStorage()._rootKey).toBe("");
+        expect(new SafeStorage(null)._storage).toBeUndefined();
+        expect(new SafeStorage(null)._rootKey).toBe("");
+        expect(new SafeStorage(null, "")._storage).toBeUndefined();
+        expect(new SafeStorage(null, "")._rootKey).toBe("");
+      })
+
+      it("Should remove invalid items on get", () => {
+        const map = {};
+        const delegate = {
+            getItem: (key) => map[key],
+            setItem: (key, value) => { map[key] = value },
+            removeItem: (key) => { delete map[key] }
+        };
+        const storage = new SafeStorage(delegate, "root");
+        // value is not valid because not a JSON serialized string
+        map["root$Hello"] = "Invalid";
+        expect(storage.getItem("Hello")).toBeUndefined();
+        // Get should have removed invalid value
+        expect(map["root$Hello"]).toBeUndefined()
+      })
+
+      it("Should handle cache last cleared", () => {
+        const map = {};
+        const delegate = {
+            getItem: (key) => map[key],
+            setItem: (key, value) => { map[key] = value },
+            removeItem: (key) => { delete map[key] }
+        };
+        const cache = new Cache(delegate, "root");
+        cache.put("Hello", "World");
+        expect(JSON.parse(map["root$Hello"])).toMatchObject({ value:"World" });
+        expect(cache.get("Hello")).toBe("World");
+        cache.clear();
+        // Clear could not remove the item from the map
+        expect(JSON.parse(map["root$Hello"])).toMatchObject({ value:"World" });
+        // But get from cache will
+        expect(cache.get("Hello")).toBeUndefined();
+      })
+    })
+
+    it("Should preserve last cleared", () => {
+        const map = {};
+        const delegate = {
+            getItem: (key) => map[key],
+            setItem: (key, value) => { map[key] = value },
+            removeItem: (key) => { delete map[key] }
+        };
+        const cache = new Cache(delegate, "root");
+        expect(cache._lastCleared).toBeUndefined();
+        cache.put("Hello", "World");
+        cache.clear();
+        const lastCleared = cache._lastCleared;
+        expect(lastCleared).not.toBeUndefined();
+        expect(cache.get("Hello")).toBeUndefined();
+        expect(map["root$lastCleared"]).toBe(JSON.stringify({timestamp:lastCleared}));
+        // New cache with same delegate storage should preserve lastCleared date
+        const cache2 = new Cache(delegate, "root");
+        expect(cache2._lastCleared).toBe(lastCleared);
+    })
+
+    it("Should cache in memory value which is in local storage", () => {
+        const map = {};
+        const delegate = {
+            getItem: (key) => map[key],
+            setItem: (key, value) => { map[key] = value },
+            removeItem: (key) => { delete map[key] }
+        };
+        const cache = new Cache(delegate, "root");
+        map["root$Hello"] = JSON.stringify({ value: "World", cachedAt:Date.now() + 99999999 });
+        const value = cache.get("Hello");
+        expect(value).toBe("World");
+        expect(cache._cache["Hello"].value).toBe("World");
     })
 
 });