@adobe/acc-js-sdk 1.0.3 → 1.0.7

package/test/crypto.test.js

@@ -19,61 +19,65 @@ governing permissions and limitations under the License.
 
 const assert = require('assert');
 const crypto = require('../src/crypto.js');
+const { Mock } = require('./mock.js');
 const Cipher = crypto.Cipher;
 
 describe('crypto', function() {
     
     it("Should decrypt password", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
-        var decrypted = cipher.decryptPassword("@57QS5VHMb9BCsojLVrKI/Q==");
+        const cipher = new Cipher(Mock.makeKey());
+        const encrypted = cipher.encryptPassword("mid");
+        var decrypted = cipher.decryptPassword(encrypted);
         assert.equal(decrypted, "mid");
     });
 
     it("Should fail on invalid encrypted string", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
+        const cipher = new Cipher(Mock.makeKey());
         assert.throws(function() {
             cipher.decryptPassword("Hello");
         });
     });
 
     it("Should decrypt password twice", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
-        var decrypted = cipher.decryptPassword("@57QS5VHMb9BCsojLVrKI/Q==");
+        const cipher = new Cipher(Mock.makeKey());
+        const encrypted = cipher.encryptPassword("mid");
+        var decrypted = cipher.decryptPassword(encrypted);
         assert.equal(decrypted, "mid");
-         decrypted = cipher.decryptPassword("@57QS5VHMb9BCsojLVrKI/Q==");
+         decrypted = cipher.decryptPassword(encrypted);
         assert.equal(decrypted, "mid");
     });
 
     it("Should decrypt password after failure", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
+        const cipher = new Cipher(Mock.makeKey());
         assert.throws(function() {
             cipher.decryptPassword("@Hello");
         });
         // make sure state is valid after failure
-        var decrypted = cipher.decryptPassword("@57QS5VHMb9BCsojLVrKI/Q==");
+        const encrypted = cipher.encryptPassword("mid");
+        var decrypted = cipher.decryptPassword(encrypted);
         assert.equal(decrypted, "mid");
     });
 
     it("Should handle plain text passwords", function() {
-        const cipher = new Cipher("llL97E5mAvLTxgT1fsAH2kjLqZXKCGHfDyR9q0C6Ivs=");
+        const cipher = new Cipher(Mock.makeKey());
         var decrypted = cipher.decryptPassword("__PLAINTEXT__pass");
         assert.equal(decrypted, "pass");
     });
 
     it("Should fail if no marker", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
+        const cipher = new Cipher(Mock.makeKey());
         expect(() => { cipher.decryptPassword("57QS5VHMb9BCsojLVrKI/Q=="); }).toThrow("SDK-000011");
     });
 
     it("Should support empty passwords", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
+        const cipher = new Cipher(Mock.makeKey());
         assert.equal(cipher.decryptPassword(""), "");
         assert.equal(cipher.decryptPassword(null), "");
         assert.equal(cipher.decryptPassword(undefined), "");
     });
 
     it("Encrypt - decrypt", function() {
-        const cipher = new Cipher("HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=");
+        const cipher = new Cipher(Mock.makeKey());
         expect(cipher.decryptPassword(cipher.encryptPassword(""))).toBe("");
         expect(cipher.decryptPassword(cipher.encryptPassword("1"))).toBe("1");
         expect(cipher.decryptPassword(cipher.encryptPassword("Hello"))).toBe("Hello");

package/test/domUtil.test.js

@@ -523,4 +523,27 @@ describe('DomUtil', function() {
         });
     });
 
+    describe("Text and CDATA nodes", () => {
+        it("Should handle cdata node", () => {
+            const xml = DomUtil.parse(`<workflow-collection><workflow id="1840" internalName="cleanup" label="Database cleanup"><desc><![CDATA[Ensure that obsolete data are deleted from the database.]]></desc></workflow></workflow-collection>`);
+            const json = DomUtil.toJSON(xml);
+            expect(json.workflow[0]["$desc"]).toBe("Ensure that obsolete data are deleted from the database.");
+            expect(json.workflow[0]["desc"]).toBeUndefined();
+        });
+
+        it("Should handle text node", () => {
+            const xml = DomUtil.parse(`<workflow-collection><workflow id="1840" internalName="cleanup" label="Database cleanup"><desc>Ensure that obsolete data are deleted from the database.</desc></workflow></workflow-collection>`);
+            const json = DomUtil.toJSON(xml);
+            expect(json.workflow[0]["$desc"]).toBe("Ensure that obsolete data are deleted from the database.");
+            expect(json.workflow[0]["desc"]).toBeUndefined();
+        });
+
+        it("Should handle empty node", () => {
+            const xml = DomUtil.parse(`<workflow-collection><workflow id="1840" internalName="cleanup" label="Database cleanup"><desc/></workflow></workflow-collection>`);
+            const json = DomUtil.toJSON(xml);
+            expect(json.workflow[0]["$desc"]).toBeUndefined();
+            expect(json.workflow[0]["desc"]).toStrictEqual({});
+        });
+    });
+
 });

package/test/mock.js

@@ -17,18 +17,31 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
  const sdk = require('../src/index.js');
+ const crypto = require("crypto");
+
+ const makeKey = () => {
+    const a = [];
+    for (let i=0; i<32; i++) {
+        a.push(Math.floor(crypto.randomInt(0, 256))); 
+    }
+    const buffer = Buffer.from(a);
+    const s = buffer.toString('base64');
+    return s;
+ }
 
  async function makeAnonymousClient(options) {
     const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("http://acc-sdk:8080", options);
     const client = await sdk.init(connectionParameters);
-    client._transport = jest.fn();
+    if (!options || !options.transport) // allow tests to explicitely set the transport
+        client._transport = jest.fn();
     return client;
 }
 
 async function makeClient(options) {
     const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", options);
     const client = await sdk.init(connectionParameters);
-    client._transport = jest.fn();
+    if (!options || !options.transport) // allow tests to explicitely set the transport
+        client._transport = jest.fn();
     return client;
 }
 
@@ -61,7 +74,7 @@ const LOGON_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <LogonResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
-            <pstrSessionToken xsi:type='xsd:string'>___C8B4A541-48DC-4C97-95AD-066930FD3892</pstrSessionToken>
+            <pstrSessionToken xsi:type='xsd:string'>___$session_token$</pstrSessionToken>
             <pSessionInfo xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
             <sessionInfo>
                 <serverInfo advisedClientBuildNumber="0" allowSQL="false" buildNumber="9219" commitId="f5f3ec3" databaseId="uFE80000000000000F1FA913DD7CC7C480041161C" defaultNameSpace="cus" fohVersion="2" instanceName="ffdamkt" majNumber="6" minClientBuildNumber="8969" minNumber="7" minNumberTechnical="0" releaseName="20.3" securityTimeOut="86400" serverDate="2020-07-05 14:11:31.986Z" servicePack="0" sessionTimeOut="86400" useVault="false"/>
@@ -73,11 +86,32 @@ const LOGON_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
                     </userInfo>
                 </sessionInfo>
             </pSessionInfo>
-            <pstrSecurityToken xsi:type='xsd:string'>@mMBSMLXIpQd56agsZ5X7OGXWz8Q476qMq6FimwqCdT1wByRDq3pQtaYSY4uJnAbCgXIvpXA5TrxHu-3YjUad5g==</pstrSecurityToken>
+            <pstrSecurityToken xsi:type='xsd:string'>@$security_token$==</pstrSecurityToken>
         </LogonResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
 
+    const BEARER_LOGON_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+    <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+    <SOAP-ENV:Body>
+        <BearerTokenLogonResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+            <pstrSessionToken xsi:type='xsd:string'>___$session_token$</pstrSessionToken>
+            <pSessionInfo xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
+            <sessionInfo>
+                <serverInfo advisedClientBuildNumber="0" allowSQL="false" buildNumber="9219" commitId="f5f3ec3" databaseId="uFE80000000000000F1FA913DD7CC7C480041161C" defaultNameSpace="cus" fohVersion="2" instanceName="ffdamkt" majNumber="6" minClientBuildNumber="8969" minNumber="7" minNumberTechnical="0" releaseName="20.3" securityTimeOut="86400" serverDate="2020-07-05 14:11:31.986Z" servicePack="0" sessionTimeOut="86400" useVault="false"/>
+                    <userInfo datakitInDatabase="true" homeDir="" instanceLocale="en" locale="en" login="admin" loginCS="Administrator (admin)" loginId="1059" noConsoleCnx="false" orgUnitId="0" theme="" timezone="Europe/Paris">
+                        <login-group id="1060"/>
+                        <login-right right="admin"/>
+                        <installed-package name="campaign" namespace="nms"/>
+                        <installed-package name="core" namespace="nms"/>
+                    </userInfo>
+                </sessionInfo>
+            </pSessionInfo>
+            <pstrSecurityToken xsi:type='xsd:string'>@$security_token$==</pstrSecurityToken>
+        </BearerTokenLogonResponse>
+    </SOAP-ENV:Body>
+    </SOAP-ENV:Envelope>`);
+
 const LOGON_RESPONSE_NO_USERINFO = Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
@@ -257,37 +291,43 @@ const GET_XTK_QUERY_SCHEMA_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
 
-const GET_MID_EXT_ACCOUNT_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+const GET_MID_EXT_ACCOUNT_RESPONSE = (encryptedPassword) => {
+    return  Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:queryDef' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <ExecuteQueryResponse xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
             <pdomOutput xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
-                <extAccount account="mid" id="2088" name="defaultEmailMid" password="@57QS5VHMb9BCsojLVrKI/Q==" server="http://ffdamid:8080" type="3"/>
+                <extAccount account="mid" id="2088" name="defaultEmailMid" password="${encryptedPassword}" server="http://ffdamid:8080" type="3"/>
             </pdomOutput>
         </ExecuteQueryResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
+}
 
-const GET_BAD_EXT_ACCOUNT_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+const GET_BAD_EXT_ACCOUNT_RESPONSE = (encryptedPassword) => {
+    return Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:queryDef' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <ExecuteQueryResponse xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
             <pdomOutput xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
-                <extAccount account="bad" id="2088" name="bad" password="@57QS5VHMb9BCsojLVrKI/Q==" server="http://zz:8080" type="999"/>
+                <extAccount account="bad" id="2088" name="bad" password="${encryptedPassword}" server="http://zz:8080" type="999"/>
             </pdomOutput>
         </ExecuteQueryResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
+}
 
-const GET_SECRET_KEY_OPTION_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+const GET_SECRET_KEY_OPTION_RESPONSE = (key) => {
+    return Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <GetOptionResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
-            <pstrValue xsi:type='xsd:string'>HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=</pstrValue>
+            <pstrValue xsi:type='xsd:string'>${key}</pstrValue>
             <pbtType xsi:type='xsd:byte'>6</pbtType>
         </GetOptionResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
+}
 
 const GET_LOGON_MID_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
@@ -571,11 +611,13 @@ exports.Mock = {
   makeClient: makeClient,
   makeAnonymousClient: makeAnonymousClient,
   withMockConsole: withMockConsole,
+  makeKey: makeKey,
   R_TEST: R_TEST,
   PING: PING,
   MC_PING: MC_PING,
   MC_PING_ERROR: MC_PING_ERROR,
   LOGON_RESPONSE: LOGON_RESPONSE,
+  BEARER_LOGON_RESPONSE: BEARER_LOGON_RESPONSE,
   LOGON_RESPONSE_NO_SESSIONTOKEN: LOGON_RESPONSE_NO_SESSIONTOKEN,
   LOGON_RESPONSE_NO_SECURITYTOKEN: LOGON_RESPONSE_NO_SECURITYTOKEN,
   LOGOFF_RESPONSE: LOGOFF_RESPONSE,

package/test/soap.test.js

@@ -154,11 +154,8 @@ describe('SOAP', function() {
             const env = DomUtil.parse(request.data).documentElement;
             const header = hasChildElement(env, "SOAP-ENV:Header");
             expect(DomUtil.findElement(header, "Cookie")).toBeFalsy();
-            hasChildElement(header, "X-Security-Token");
             const body = hasChildElement(env, "SOAP-ENV:Body");
             const method = hasChildElement(body, "m:Empty", undefined, "xmlns:m", "urn:xtk:session", "SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/");
-            // sessiontoken is always required as first parameter, even if not set
-            expect(DomUtil.findElement(method, "sessiontoken")).toBeTruthy();
         });
 
         it('Should have set authentication tokens', function() {
@@ -168,11 +165,8 @@ describe('SOAP', function() {
             assert.equal(request.headers["Cookie"], "__sessiontoken=$session$", "Session token matches");
             const env = DomUtil.parse(request.data).documentElement;
             const header = hasChildElement(env, "SOAP-ENV:Header");
-            hasChildElement(header, "Cookie", "__sessiontoken=$session$");
-            hasChildElement(header, "X-Security-Token", "$security$");
             const body = hasChildElement(env, "SOAP-ENV:Body");
             const method = hasChildElement(body, "m:Empty");
-            hasChildElement(method, "sessiontoken", "$session$", "xsi:type", "xsd:string");
         });
 
         it('Should set boolean parameters', function() {
@@ -792,5 +786,18 @@ describe("Campaign exception", () => {
         })
     })
 
+    it("CampaignException should hide sensitive information", () => {
+        const call = makeSoapMethodCall(undefined, "xtk:session", "Date", "$session$", "$security$", "My User Agent");
+        call.finalize("http://ffdamkt:8080/nl/jsp/soaprouter.jsp")
+        const ex = makeCampaignException(call, new Error("Failed"));
+        const req = ex.methodCall.request;
+        expect(req.data.indexOf("$session$")).toBe(-1);
+        expect(req.data.indexOf("$security$")).toBe(-1);
+        expect(req.headers.Cookie.indexOf("$session$")).toBe(-1);
+        expect(req.headers.Cookie.indexOf("$security$")).toBe(-1);
+        expect(req.headers["X-Security-Token"].indexOf("$session$")).toBe(-1);
+        expect(req.headers["X-Security-Token"].indexOf("$security$")).toBe(-1);
+    })
+
 });
 

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");
     })
 
 });

package/test/xtkCaster.test.js

@@ -696,14 +696,22 @@ describe('XtkCaster', function() {
         expect(XtkCaster._variantStorageAttribute(6)).toBe("stringValue");
         expect(XtkCaster._variantStorageAttribute("string")).toBe("stringValue");
         expect(XtkCaster._variantStorageAttribute("int64")).toBe("stringValue");
+        expect(XtkCaster._variantStorageAttribute("uuid")).toBe("stringValue");
         expect(XtkCaster._variantStorageAttribute(12)).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute(13)).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute("memo")).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute("CDATA")).toBe("memoValue");
+        expect(XtkCaster._variantStorageAttribute("blob")).toBe("memoValue");
+        expect(XtkCaster._variantStorageAttribute("html")).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute(1)).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(2)).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(3)).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(15)).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("byte")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("short")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("long")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("int")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("boolean")).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(4)).toBe("doubleValue");
         expect(XtkCaster._variantStorageAttribute(5)).toBe("doubleValue");
         expect(XtkCaster._variantStorageAttribute("float")).toBe("doubleValue");
@@ -716,4 +724,93 @@ describe('XtkCaster', function() {
         expect(XtkCaster._variantStorageAttribute("date")).toBe("timeStampValue");
         expect(() => { XtkCaster._variantStorageAttribute(777); }).toThrow("Cannot get variant storage");
     });
+
+    describe("Array tests", () => {
+            it("Should return array", () => {
+            expect(XtkCaster.asArray(null)).toStrictEqual([]);
+            expect(XtkCaster.asArray(undefined)).toStrictEqual([]);
+            expect(XtkCaster.asArray(false)).toStrictEqual([false]);
+            expect(XtkCaster.asArray("Hello")).toStrictEqual(["Hello"]);
+            expect(XtkCaster.asArray([])).toStrictEqual([]);
+            expect(XtkCaster.asArray([null])).toStrictEqual([null]);
+        })
+    
+        it("Should support arrays", () => {
+            expect(XtkCaster.as(null, "array")).toStrictEqual([]);
+            expect(XtkCaster.as(undefined, "array")).toStrictEqual([]);
+            expect(XtkCaster.as(false, "array")).toStrictEqual([false]);
+            expect(XtkCaster.as("Hello", "array")).toStrictEqual(["Hello"]);
+            expect(XtkCaster.as([], "array")).toStrictEqual([]);
+            expect(XtkCaster.as([null], "array")).toStrictEqual([null]);
+        });
+    });
+
+    describe("Timespan test", () => {
+        it("Should return timespan", () => {
+            expect(XtkCaster.asTimespan(null)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(undefined)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(false)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan("Hello")).toStrictEqual(0);
+            expect(XtkCaster.asTimespan([])).toStrictEqual(0);
+            expect(XtkCaster.asTimespan([null])).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(NaN)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(Number.POSITIVE_INFINITY)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(Number.NEGATIVE_INFINITY)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan("86400")).toStrictEqual(86400);
+            expect(XtkCaster.asTimespan(86400)).toStrictEqual(86400);
+        })
+
+        it("As should support 'timspan'", () => {
+            expect(XtkCaster.as(null, "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as(undefined, "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as(false, "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as("Hello", "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as([], "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as([null], "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as("86400", "timespan")).toStrictEqual(86400);
+            expect(XtkCaster.as(86400, "timespan")).toStrictEqual(86400);
+        });
+
+        it("As should support type 14", () => {
+            expect(XtkCaster.as(null, 14)).toStrictEqual(0);
+            expect(XtkCaster.as(undefined, 14)).toStrictEqual(0);
+            expect(XtkCaster.as(false, 14)).toStrictEqual(0);
+            expect(XtkCaster.as("Hello", 14)).toStrictEqual(0);
+            expect(XtkCaster.as([], 14)).toStrictEqual(0);
+            expect(XtkCaster.as([null], 14)).toStrictEqual(0);
+            expect(XtkCaster.as("86400", 14)).toStrictEqual(86400);
+            expect(XtkCaster.as(86400, 14)).toStrictEqual(86400);
+        });
+    })
+
+    describe("Other string types", () => {
+        it("Type 'html'", () => {
+            expect(XtkCaster.as(null, "html")).toStrictEqual("");
+            expect(XtkCaster.as(undefined, "html")).toStrictEqual("");
+            expect(XtkCaster.as("Hello", "html")).toStrictEqual("Hello");
+            expect(XtkCaster.as("0", "html")).toStrictEqual("0");
+        });
+
+        it("Type 'uuid'", () => {
+            expect(XtkCaster.as(null, "uuid")).toStrictEqual("");
+            expect(XtkCaster.as(undefined, "uuid")).toStrictEqual("");
+            expect(XtkCaster.as("Hello", "uuid")).toStrictEqual("Hello");
+            expect(XtkCaster.as("0", "uuid")).toStrictEqual("0");
+        });
+
+        it("Type 'blob'", () => {
+            expect(XtkCaster.as(null, "blob")).toStrictEqual("");
+            expect(XtkCaster.as(undefined, "blob")).toStrictEqual("");
+            expect(XtkCaster.as("Hello", "blob")).toStrictEqual("Hello");
+            expect(XtkCaster.as("0", "blob")).toStrictEqual("0");
+        });
+
+        it("Type 'int'", () => {
+            expect(XtkCaster.as(null, "int")).toStrictEqual(0);
+            expect(XtkCaster.as(undefined, "int")).toStrictEqual(0);
+            expect(XtkCaster.as("42", "int")).toStrictEqual(42);
+            expect(XtkCaster.as("0", "int")).toStrictEqual(0);
+        });
+    })
+
 });