@adobe/acc-js-sdk 1.0.6 → 1.0.9

package/test/client.test.js

@@ -22,6 +22,8 @@ const { Client, ConnectionParameters } = require('../src/client.js');
 const DomUtil = require('../src/domUtil.js').DomUtil;
 const Mock = require('./mock.js').Mock;
 const { HttpError } = require('../src/transport.js');
+const { Cipher } = require('../src/crypto.js');
+const { EntityAccessor } = require('../src/entityAccessor.js');
 
 
 describe('ACC Client', function () {
@@ -604,11 +606,13 @@ describe('ACC Client', function () {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
+            const key = Mock.makeKey();
+            const encrypted = new Cipher(key).encryptPassword("mid");
 
             client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_MID_EXT_ACCOUNT_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_MID_EXT_ACCOUNT_RESPONSE(encrypted));
             client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE(key));
             var connectionParameters = await sdk.ConnectionParameters.ofExternalAccount(client, "defaultEmailMid");
             var midClient = await sdk.init(connectionParameters);
             midClient._transport = jest.fn();
@@ -630,11 +634,13 @@ describe('ACC Client', function () {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
+            const key = Mock.makeKey();
+            const encrypted = new Cipher(key).encryptPassword("mid");
 
             client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_BAD_EXT_ACCOUNT_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_BAD_EXT_ACCOUNT_RESPONSE(encrypted));
             client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE(key));
             await expect(async () => {
                 return sdk.ConnectionParameters.ofExternalAccount(client, "bad");
             }).rejects.toMatchObject({ errorCode: "SDK-000005" });
@@ -642,14 +648,16 @@ describe('ACC Client', function () {
 
         it("Should fail if invalid representation", async () => {
             const client = await Mock.makeClient();
+            const key = Mock.makeKey();
+            const encrypted = new Cipher(key).encryptPassword("mid");
 
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
 
             client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_MID_EXT_ACCOUNT_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_MID_EXT_ACCOUNT_RESPONSE(encrypted));
             client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE(key));
 
             await expect(async () => {
                 client._representation = "Dummy";
@@ -663,14 +671,16 @@ describe('ACC Client', function () {
         it("Should fail not fail with SimpleJson representation", async () => {
             const client = await Mock.makeClient();
             client._representation = "SimpleJson";
+            const key = Mock.makeKey();
+            const encrypted = new Cipher(key).encryptPassword("mid");
 
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
 
             client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_MID_EXT_ACCOUNT_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_MID_EXT_ACCOUNT_RESPONSE(encrypted));
             client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE(key));
 
             var connectionParameters = await sdk.ConnectionParameters.ofExternalAccount(client, "defaultEmailMid");
             await sdk.init(connectionParameters);
@@ -680,9 +690,10 @@ describe('ACC Client', function () {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
-
+            const key = Mock.makeKey();
+            
             client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
-            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_SECRET_KEY_OPTION_RESPONSE(key));
             var cipher = await client._getSecretKeyCipher();
             expect(cipher).not.toBeNull();
             expect(cipher.key).not.toBeNull();
@@ -1899,7 +1910,7 @@ describe('ACC Client', function () {
     describe("Bearer token authentication", () => {
         // Bearer token authentication is used when embedding IMS for authentication
         it("Should create logged client", async() => {
-            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080", "$token$");
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080");
             const client = await sdk.init(connectionParameters);
             client._transport = jest.fn();
             client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
@@ -1946,7 +1957,149 @@ describe('ACC Client', function () {
             var extAccount = await query.executeQuery();
             expect(extAccount).toEqual({ extAccount: [] });
         });
-     })
+
+        it("Expired session refresh client callback", async () => {
+            let refreshClient = async () => {
+                const connectionParameters = sdk.ConnectionParameters.ofSecurityToken("http://acc-sdk:8080",
+                                                        "$security_token$", {refreshClient: refreshClient});
+                const newClient = await sdk.init(connectionParameters);
+                newClient._transport = jest.fn();
+                newClient._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+                await newClient.logon();
+                return newClient;
+            }
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080", 
+                                                    "$token$", {refreshClient: refreshClient});
+            const client = await sdk.init(connectionParameters);
+            client.traceAPICalls(true);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Promise.resolve(`XSV-350008 Session has expired or is invalid. Please reconnect.`));
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(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-collection/>
+                    </pdomOutput></ExecuteQueryResponse>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
+            await client.logon();
+            var queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            var query = client.NLWS.xtkQueryDef.create(queryDef);
+            var extAccount = await query.executeQuery();
+            expect(extAccount).toEqual({ extAccount: [] });
+            // Same test as before traceAPICalls = false for code coverage
+            client._transport.mockReturnValueOnce(Promise.resolve(`XSV-350008 Session has expired or is invalid. Please reconnect.`));
+            client._transport.mockReturnValueOnce(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-collection/>
+                    </pdomOutput></ExecuteQueryResponse>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
+            client.traceAPICalls(false);
+            var query1  = client.NLWS.xtkQueryDef.create(queryDef);
+            const extAccount1 = await query1.executeQuery();
+            expect(extAccount1).toEqual({ extAccount: [] });
+        });
+
+        it("Expired session refresh client callback for code coverage", async () => {
+            let refreshClient = async () => {
+                const connectionParameters = sdk.ConnectionParameters.ofSessionToken("http://acc-sdk:8080", "$session_token$");
+                const newClient = await sdk.init(connectionParameters);
+                newClient._transport = jest.fn();
+                newClient._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+                await newClient.logon();
+                return newClient;
+            }
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080",
+                                                    "$token$", {refreshClient: refreshClient});
+            const client = await sdk.init(connectionParameters);
+            client.traceAPICalls(true);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Promise.resolve(`XSV-350008 Session has expired or is invalid. Please reconnect.`));
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(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-collection/>
+                    </pdomOutput></ExecuteQueryResponse>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
+            await client.logon();
+            var queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            var query = client.NLWS.xtkQueryDef.create(queryDef);
+            var extAccount = await query.executeQuery();
+            expect(extAccount).toEqual({ extAccount: [] });
+        });
+
+        it("Expired session refresh client callback retry failure", async () => {
+            let refreshClient = async () => {
+                const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080",
+                "$token$", {refreshClient: refreshClient});
+                const newClient = await sdk.init(connectionParameters);
+                newClient._transport = jest.fn();
+                newClient._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+                await newClient.logon();
+                return newClient;
+            }
+            const connectionParameters = sdk.ConnectionParameters.ofSecurityToken("http://acc-sdk:8080",
+                                                    "$security_token$", {refreshClient: refreshClient});
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Promise.resolve(`XSV-350008 Session has expired or is invalid. Please reconnect.`));
+            client._transport.mockReturnValueOnce(Promise.resolve(`XSV-350008 Session has expired or is invalid. Please reconnect.`));
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(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-collection/>
+                    </pdomOutput></ExecuteQueryResponse>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
+            await client.logon();
+            var queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            var query = client.NLWS.xtkQueryDef.create(queryDef);
+            await expect(query.executeQuery()).rejects.toMatchObject({ errorCode: "SDK-000012" });
+            expect(client._transport.mock.calls.length).toBe(2);
+         });
+    })
 
     describe("Logon should always return a promise", () => {
 
@@ -2130,15 +2283,15 @@ describe('ACC Client', function () {
         it("Should ignore protocol for local storage root key", async () => {
             var connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", {});
             var client = await sdk.init(connectionParameters);
-            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.6.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.9.acc-sdk:8080.cache.OptionCache$");
 
             connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("https://acc-sdk:8080", "admin", "admin", {});
             client = await sdk.init(connectionParameters);
-            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.6.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.9.acc-sdk:8080.cache.OptionCache$");
 
             connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("acc-sdk:8080", "admin", "admin", {});
             client = await sdk.init(connectionParameters);
-            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.6.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.9.acc-sdk:8080.cache.OptionCache$");
         })
 
         it("Should support no storage", async () => {
@@ -2197,6 +2350,76 @@ describe('ACC Client', function () {
             expect(schema["namespace"]).toBe("nms");
             expect(schema["name"]).toBe("extAccount");
         });
+    });
+
+    describe("Calling SOAP method with parameters as a function", () => {
+        it("Should make SOAP call", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+            const scope = client.NLWS["xtkSession"];
+            const fn = scope["getOption"];
+            const result = await fn.call(scope, "XtkDatabaseId");
+            expect(result).toMatchObject([ "uFE80000000000000F1FA913DD7CC7C480041161C", 6 ]);
+        });
+
+        it("Should make static SOAP call with functional parameters", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            const scope = client.NLWS["xtkSession"];
+            const method = scope["staticP1"]; // SOAP method to call
+            const paramsFn = jest.fn(); // function returning SOAP call parameters
+            paramsFn.mockReturnValueOnce(["XtkDatabaseId"]);
+            
+            client._transport.mockReturnValueOnce(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>
+                    <StaticP1Response xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                    </StaticP1Response>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
+
+            const result = await method.call(scope, paramsFn);
+            expect(result).toBeNull();
+            expect(paramsFn.mock.calls.length).toBe(1);
+            // first parameter is the XML method
+            const xmlMethod = paramsFn.mock.calls[0][0];
+            expect(EntityAccessor.getAttributeAsString(xmlMethod, "name")).toBe("StaticP1");
+            // second parameter is the call context
+            expect(paramsFn.mock.calls[0][1]).toMatchObject({ schemaId: "xtk:session", namespace: "xtkSession" });
+        });
+
+        it("Should make non static SOAP call with functional parameters", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            const scope = client.NLWS["xtkSession"];
+            const method = scope["nonStaticP1"]; // SOAP method to call
+            const paramsFn = jest.fn(); // function returning SOAP call parameters
+            paramsFn.mockReturnValueOnce(["XtkDatabaseId"]);
+            
+            client._transport.mockReturnValueOnce(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>
+                    <StaticP1Response xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                    </StaticP1Response>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
 
+            const object = scope.create({ dummy: true }); // "this" object for the non-static SOAP call
+            const result = await method.call(object, paramsFn);
+            expect(result).toBeNull();
+            expect(paramsFn.mock.calls.length).toBe(1);
+            // first parameter is the XML method
+            const xmlMethod = paramsFn.mock.calls[0][0];
+            expect(EntityAccessor.getAttributeAsString(xmlMethod, "name")).toBe("NonStaticP1");
+            // second parameter is the call context
+            expect(paramsFn.mock.calls[0][1]).toMatchObject({ schemaId: "xtk:session", namespace: "xtkSession" });
+        });
     });
 });

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

@@ -18,8 +18,7 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 
 const assert = require('assert');
-const { DomUtil } = require('../src/domUtil.js');
-const { Util } = require('../src/util.js');
+const { DomUtil, XPath, XPathElement } = require('../src/domUtil.js');
 
 
 describe('DomUtil', function() {
@@ -546,4 +545,153 @@ describe('DomUtil', function() {
         });
     });
 
+    describe("XPath", () => {
+
+        it("Should create XPath", () => {
+            expect(new XPath("").asString()).toBe("");
+            expect(new XPath(" ").asString()).toBe("");
+            expect(new XPath(null).asString()).toBe("");
+            expect(new XPath(undefined).asString()).toBe("");
+            expect(new XPath("@name").asString()).toBe("@name");
+            expect(new XPath("country/@name").asString()).toBe("country/@name");
+            expect(new XPath("..").asString()).toBe("..");
+            expect(new XPath(".").asString()).toBe(".");
+        })
+
+        it("Should create expanded XPath", () => {
+            expect(new XPath("[@name]").asString()).toBe("@name");
+            expect(new XPath("[country/@name]").asString()).toBe("country/@name");
+        })
+
+        it("toString", () => {
+            expect(new XPath("").toString()).toBe("");
+            expect(new XPath(" ").toString()).toBe("");
+            expect(new XPath(null).toString()).toBe("");
+            expect(new XPath(undefined).toString()).toBe("");
+            expect(new XPath("@name").toString()).toBe("@name");
+            expect(new XPath("country/@name").toString()).toBe("country/@name");
+            expect(new XPath("..").toString()).toBe("..");
+            expect(new XPath(".").toString()).toBe(".");
+        })
+
+        it("Should test empty XPath", () => {
+            expect(new XPath("").isEmpty()).toBe(true);
+            expect(new XPath(" ").isEmpty()).toBe(true);
+            expect(new XPath(null).isEmpty()).toBe(true);
+            expect(new XPath(undefined).isEmpty()).toBe(true);
+            expect(new XPath("@name").isEmpty()).toBe(false);
+            expect(new XPath("country/@name").isEmpty()).toBe(false);
+            expect(new XPath("..").isEmpty()).toBe(false);
+            expect(new XPath(".").isEmpty()).toBe(false);
+        })
+
+        it("Should test absolute XPath", () => {
+            expect(new XPath("").isAbsolute()).toBe(false);
+            expect(new XPath(" ").isAbsolute()).toBe(false);
+            expect(new XPath(null).isAbsolute()).toBe(false);
+            expect(new XPath(undefined).isAbsolute()).toBe(false);
+            expect(new XPath("@name").isAbsolute()).toBe(false);
+            expect(new XPath("country/@name").isAbsolute()).toBe(false);
+            expect(new XPath("..").isAbsolute()).toBe(false);
+            expect(new XPath(".").isAbsolute()).toBe(false);
+            expect(new XPath("/").isAbsolute()).toBe(true);
+            expect(new XPath("/country/@name").isAbsolute()).toBe(true);
+        })
+
+        it("Should test self XPath", () => {
+            expect(new XPath("").isSelf()).toBe(false);
+            expect(new XPath(" ").isSelf()).toBe(false);
+            expect(new XPath(null).isSelf()).toBe(false);
+            expect(new XPath(undefined).isSelf()).toBe(false);
+            expect(new XPath("@name").isSelf()).toBe(false);
+            expect(new XPath("country/@name").isSelf()).toBe(false);
+            expect(new XPath("..").isSelf()).toBe(false);
+            expect(new XPath(".").isSelf()).toBe(true);
+            expect(new XPath("/").isSelf()).toBe(false);
+            expect(new XPath("/country/@name").isSelf()).toBe(false);
+        })
+
+        it("Should test root XPath", () => {
+            expect(new XPath("").isRootPath()).toBe(false);
+            expect(new XPath(" ").isRootPath()).toBe(false);
+            expect(new XPath(null).isRootPath()).toBe(false);
+            expect(new XPath(undefined).isRootPath()).toBe(false);
+            expect(new XPath("@name").isRootPath()).toBe(false);
+            expect(new XPath("country/@name").isRootPath()).toBe(false);
+            expect(new XPath("..").isRootPath()).toBe(false);
+            expect(new XPath(".").isRootPath()).toBe(false);
+            expect(new XPath("/").isRootPath()).toBe(true);
+            expect(new XPath("/country/@name").isRootPath()).toBe(false);
+        })
+
+        it("Should return XPath elements", () => {
+
+            function elements(xpath) {
+                const result = [];
+                const list = xpath.getElements();
+                for (const e of list) {
+                    result.push(e._pathElement);
+                }
+                return result;
+            }
+
+            expect(elements(new XPath(""))).toEqual([  ]);
+            expect(elements(new XPath(" "))).toEqual([  ]);
+            expect(elements(new XPath(null))).toEqual([  ]);
+            expect(elements(new XPath(undefined))).toEqual([  ]);
+            expect(elements(new XPath("@name"))).toEqual([ "@name" ]);
+            expect(elements(new XPath("country/@name"))).toEqual([ "country", "@name" ]);
+            expect(elements(new XPath(".."))).toEqual([ ".." ]);
+            expect(elements(new XPath("."))).toEqual([ "." ]);
+            expect(elements(new XPath("/"))).toEqual([  ]);
+            expect(elements(new XPath("/country/@name"))).toEqual([ "country", "@name" ]);
+        })
+
+        it("Should get relative path", () => {
+            expect(new XPath("").getRelativePath().asString()).toBe("");
+            expect(new XPath(" ").getRelativePath().asString()).toBe("");
+            expect(new XPath(null).getRelativePath().asString()).toBe("");
+            expect(new XPath(undefined).getRelativePath().asString()).toBe("");
+            expect(new XPath("@name").getRelativePath().asString()).toBe("@name");
+            expect(new XPath("country/@name").getRelativePath().asString()).toBe("country/@name");
+            expect(new XPath("..").getRelativePath().asString()).toBe("..");
+            expect(new XPath(".").getRelativePath().asString()).toBe(".");
+            expect(new XPath("/").getRelativePath().asString()).toBe("");
+            expect(new XPath("/country/@name").getRelativePath().asString()).toBe("country/@name");
+        })
+    });
+
+    describe("XPathElement", () => {
+        it("Should create XPathElement", () => {
+            expect(() => { new XPathElement(""); }).toThrow("Invalid empty xpath element");
+            expect(() => { new XPathElement(" "); }).toThrow("Invalid empty xpath element");
+            expect(() => { new XPathElement(null); }).toThrow("Invalid empty xpath element");
+            expect(() => { new XPathElement(undefined); }).toThrow("Invalid empty xpath element");
+            expect(new XPathElement("@name").asString()).toBe("@name");
+            expect(new XPathElement("country").asString()).toBe("country");
+            expect(new XPathElement("..").asString()).toBe("..");
+            expect(new XPathElement(".").asString()).toBe(".");
+        })
+
+        it("toString", () => {
+            expect(new XPathElement("@name").toString()).toBe("@name");
+            expect(new XPathElement("country").toString()).toBe("country");
+            expect(new XPathElement("..").toString()).toBe("..");
+            expect(new XPathElement(".").toString()).toBe(".");
+        })
+
+        it("Should test if path element is self", () => {
+            expect(new XPathElement("@name").isSelf()).toBe(false);
+            expect(new XPathElement("country").isSelf()).toBe(false);
+            expect(new XPathElement("..").isSelf()).toBe(false);
+            expect(new XPathElement(".").isSelf()).toBe(true);
+        })
+
+        it("Should test if path element is the parent path (..)", () => {
+            expect(new XPathElement("@name").isParent()).toBe(false);
+            expect(new XPathElement("country").isParent()).toBe(false);
+            expect(new XPathElement("..").isParent()).toBe(true);
+            expect(new XPathElement(".").isParent()).toBe(false);
+        })
+    })
 });