@adobe/acc-js-sdk 1.0.7 → 1.1.0

package/test/client.test.js

@@ -23,6 +23,7 @@ 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 () {
@@ -1958,7 +1959,7 @@ describe('ACC Client', function () {
         });
 
         it("Expired session refresh client callback", async () => {
-            let refreshClient = async (client) => {
+            let refreshClient = async () => {
                 const connectionParameters = sdk.ConnectionParameters.ofSecurityToken("http://acc-sdk:8080",
                                                         "$security_token$", {refreshClient: refreshClient});
                 const newClient = await sdk.init(connectionParameters);
@@ -2011,12 +2012,12 @@ describe('ACC Client', function () {
                 </SOAP-ENV:Envelope>`));
             client.traceAPICalls(false);
             var query1  = client.NLWS.xtkQueryDef.create(queryDef);
-            extAccount1 = await query1.executeQuery();
+            const extAccount1 = await query1.executeQuery();
             expect(extAccount1).toEqual({ extAccount: [] });
         });
 
         it("Expired session refresh client callback for code coverage", async () => {
-            let refreshClient = async (client) => {
+            let refreshClient = async () => {
                 const connectionParameters = sdk.ConnectionParameters.ofSessionToken("http://acc-sdk:8080", "$session_token$");
                 const newClient = await sdk.init(connectionParameters);
                 newClient._transport = jest.fn();
@@ -2058,7 +2059,7 @@ describe('ACC Client', function () {
         });
 
         it("Expired session refresh client callback retry failure", async () => {
-            let refreshClient = async (client) => {
+            let refreshClient = async () => {
                 const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080",
                 "$token$", {refreshClient: refreshClient});
                 const newClient = await sdk.init(connectionParameters);
@@ -2282,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.7.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.0.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.7.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.0.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.7.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.0.acc-sdk:8080.cache.OptionCache$");
         })
 
         it("Should support no storage", async () => {
@@ -2349,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/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);
+        })
+    })
 });

package/test/escape.test.js

@@ -18,65 +18,97 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 const sdk = require('../src/index.js');
 
-describe('escapeXtk', function() {
-    
-    describe('Escaping strings', function() {
-        it("Should escape null strings", () => {
-            expect(sdk.escapeXtk(null)).toBe("''");
-        });
-
-        it("Should escape undefined strings", () => {
-            expect(sdk.escapeXtk(undefined)).toBe("''");
-        });
-
-        it("Should escape empty strings", () => {
-            expect(sdk.escapeXtk("")).toBe("''");
-        });
+describe('escaping', function() {
 
-        it("Should escape empty simple strings", () => {
-            expect(sdk.escapeXtk("Hello")).toBe("'Hello'");
-            expect(sdk.escapeXtk("Hello world")).toBe("'Hello world'");
-            expect(sdk.escapeXtk(" ")).toBe("' '");
-        });
+    describe('escapeXtk', function() {
+        
+        describe('Escaping strings', function() {
+            it("Should escape null strings", () => {
+                expect(sdk.escapeXtk(null)).toBe("''");
+            });
+
+            it("Should escape undefined strings", () => {
+                expect(sdk.escapeXtk(undefined)).toBe("''");
+            });
+
+            it("Should escape empty strings", () => {
+                expect(sdk.escapeXtk("")).toBe("''");
+            });
+
+            it("Should escape empty simple strings", () => {
+                expect(sdk.escapeXtk("Hello")).toBe("'Hello'");
+                expect(sdk.escapeXtk("Hello world")).toBe("'Hello world'");
+                expect(sdk.escapeXtk(" ")).toBe("' '");
+            });
+
+            it("Should escape simple quotes", () => {
+                expect(sdk.escapeXtk("Hello 'world'")).toBe("'Hello \\'world\\''");
+            });
+        })
 
-        it("Should escape simple quotes", () => {
-            expect(sdk.escapeXtk("Hello 'world'")).toBe("'Hello \\'world\\''");
-        });
-    })
+        describe('Tagged template litteral', function() {
 
-    describe('Tagged template litteral', function() {
+            it("Should escape in template litteral", () => {
+                expect(sdk.escapeXtk`Hello world`).toBe("Hello world");
+                expect(sdk.escapeXtk`Hello 'world'`).toBe("Hello 'world'");     // only variables are escaped
 
-        it("Should escape in template litteral", () => {
-            expect(sdk.escapeXtk`Hello world`).toBe("Hello world");
-            expect(sdk.escapeXtk`Hello 'world'`).toBe("Hello 'world'");     // only variables are escaped
+                const empty = "";
+                expect(sdk.escapeXtk``).toBe("");
+                expect(sdk.escapeXtk`${empty}`).toBe("''");
 
-            const empty = "";
-            expect(sdk.escapeXtk``).toBe("");
-            expect(sdk.escapeXtk`${empty}`).toBe("''");
+                const name = "Joe's";
+                expect(sdk.escapeXtk`Hello ${name}`).toBe("Hello 'Joe\\'s'");    // variable value is quoted and escaped
 
-            const name = "Joe's";
-            expect(sdk.escapeXtk`Hello ${name}`).toBe("Hello 'Joe\\'s'");    // variable value is quoted and escaped
+                // A more relevant test
+                const userName = 'Alex';
+                expect({ expr: sdk.escapeXtk`@name = ${userName}` }).toEqual({ expr: "@name = 'Alex'" });
 
-            // A more relevant test
-            const userName = 'Alex';
-            expect({ expr: sdk.escapeXtk`@name = ${userName}` }).toEqual({ expr: "@name = 'Alex'" });
+                // Should support multiple variables
+                expect({ expr: sdk.escapeXtk`@name = ${userName} or @name = ${name}` }).toEqual({ expr: "@name = 'Alex' or @name = 'Joe\\'s'" });
+            })
 
-            // Should support multiple variables
-            expect({ expr: sdk.escapeXtk`@name = ${userName} or @name = ${name}` }).toEqual({ expr: "@name = 'Alex' or @name = 'Joe\\'s'" });
+            it("Should support constants", () => {
+                expect(sdk.escapeXtk([],[])).toBe("''");
+            })
         })
 
-        it("Should support constants", () => {
-            expect(sdk.escapeXtk([],[])).toBe("''");
+        it("examples in jsdoc", () => {
+            expect(sdk.escapeXtk("Rock 'n' Roll")).toBe("'Rock \\'n\\' Roll'");
+            expect(sdk.escapeXtk`@name=${"Rock 'n' Roll"}`).toBe("@name='Rock \\'n\\' Roll'");
+        });
+
+        describe('QueryDef & template litteral', () => {
+            
         })
-    })
 
-    it("examples in jsdoc", () => {
-        expect(sdk.escapeXtk("Rock 'n' Roll")).toBe("'Rock \\'n\\' Roll'");
-        expect(sdk.escapeXtk`@name=${"Rock 'n' Roll"}`).toBe("@name='Rock \\'n\\' Roll'");
     });
 
-    describe('QueryDef & template litteral', () => {
-        
-    })
+    describe('escapeForLike', function() {
+        it('Should support null and undefined', () => {
+            expect(sdk.escapeForLike(null)).toBe('');
+            expect(sdk.escapeForLike(undefined)).toBe('');
+            expect(sdk.escapeForLike('')).toBe('');
+        });
+
+        it('Should escape simple strings', () => {
+            expect(sdk.escapeForLike('Hello')).toBe('Hello');
+            expect(sdk.escapeForLike('Hello world')).toBe('Hello world');
+            expect(sdk.escapeForLike('1234')).toBe('1234');
+        });
+
+        it('Should escape special chars', () => {
+            expect(sdk.escapeForLike('99.9%')).toBe('99.9\\%');
+            expect(sdk.escapeForLike("John 'Rusty' Toe")).toBe("John \\'Rusty\\' Toe");
+            expect(sdk.escapeForLike("Hello_Cruel_World")).toBe("Hello\\_Cruel\\_World");
+            expect(sdk.escapeForLike("John \\Rusty\\ Toe")).toBe("John \\\\Rusty\\\\ Toe");
+            // $ is not a special char
+            expect(sdk.escapeForLike('$99.9')).toBe('$99.9');
+        });
+
+        it('Should escape Xtk Variables', () => {
+            expect(sdk.escapeForLike('$99.9', false)).toBe('$99.9');
+            expect(sdk.escapeForLike('1+$id', true)).toBe("1+' + Char('36') + 'id");
+        });
+    });
 
-});
+});

package/test/index.test.js

@@ -73,6 +73,74 @@ describe('ACC SDK', function() {
                 sdk._transport(old);
             }
         });
-    })
+    });
+
+    describe("expandXPath", () => {
+        it("Should support empty paths", () => {
+            expect(sdk.expandXPath(null)).toBe(null);
+            expect(sdk.expandXPath(undefined)).toBe(undefined);
+            expect(sdk.expandXPath("")).toBe("");
+        });
+
+        it("Should preserve already expanded xpath", () => {
+            expect(sdk.expandXPath("[@email]")).toBe("[@email]");
+            expect(sdk.expandXPath("[@recipient-id]")).toBe("[@recipient-id]");
+            expect(sdk.expandXPath("[recipient/@id]")).toBe("[recipient/@id]");
+        });
+
+        it("Should not add brackets if not necessary", () => {
+            expect(sdk.expandXPath("@email")).toBe("@email");
+            expect(sdk.expandXPath("@email_address")).toBe("@email_address");
+        });
+
+        it("Should add brackets if necessary", () => {
+            expect(sdk.expandXPath("@recipient-id")).toBe("[@recipient-id]");
+            expect(sdk.expandXPath("email/@address")).toBe("[email/@address]");
+            expect(sdk.expandXPath("nms:recipient")).toBe("[nms:recipient]");
+        });
+    });
+
+    describe("unexpandXPath", () => {
+        it("Should support empty paths", () => {
+            expect(sdk.unexpandXPath(null)).toBe(null);
+            expect(sdk.unexpandXPath(undefined)).toBe(undefined);
+            expect(sdk.unexpandXPath("")).toBe("");
+        });
+
+        it("Should remove brackets", () => {
+            expect(sdk.unexpandXPath("[@email]")).toBe("@email");
+            expect(sdk.unexpandXPath("[@recipient-id]")).toBe("@recipient-id");
+            expect(sdk.unexpandXPath("[recipient/@id]")).toBe("recipient/@id");
+        });
+
+        it("Should preseve already unexpanded pathx", () => {
+            expect(sdk.unexpandXPath("@email")).toBe("@email");
+            expect(sdk.unexpandXPath("@email_address")).toBe("@email_address");
+        });
+
+        it("Should support array-paths", () => {
+            expect(sdk.unexpandXPath("coll[0]")).toBe("coll[0]");
+            expect(sdk.unexpandXPath("[coll[0]]")).toBe("coll[0]");
+        });
+    });
+    
+    describe("xtkConstText", () => {
+        it("Should handle various types", () => {
+            // Strings are quoted and escaped
+            expect(sdk.xtkConstText("Hello", "string")).toBe("'Hello'");
+            expect(sdk.xtkConstText("", "string")).toBe("''");
+            expect(sdk.xtkConstText(123, "string")).toBe("'123'");
+            expect(sdk.xtkConstText("Hello'World", "memo")).toBe("'Hello\\'World'");
+            // Numbers are unchanged
+            expect(sdk.xtkConstText(123, "long")).toBe("123");
+            expect(sdk.xtkConstText(-42.3, "double")).toBe("-42.3");
+            expect(sdk.xtkConstText("", "long")).toBe("0");
+            expect(sdk.xtkConstText(undefined, "short")).toBe("0");
+            // Timestamps are surrounded by ##
+            expect(sdk.xtkConstText("2022-02-15T09:49:04.000Z", "datetime")).toBe("#2022-02-15T09:49:04.000Z#");
+            expect(sdk.xtkConstText("", "datetime")).toBe("##");
+            expect(sdk.xtkConstText(undefined, "date")).toBe("##");
+        });
+    });
 
 });

package/test/mock.js

@@ -230,7 +230,17 @@ const GET_XTK_SESSION_SCHEMA_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
                     </method>
                     <method name="NonStatic"></method>
                     <method name="TestCnx" static="true"></method>
-                    </methods>
+                    <method name="NonStaticP1">
+                        <parameters>
+                            <param name="name" type="string"/>
+                        </parameters>
+                    </method>
+                    <method name="StaticP1" static="true">
+                        <parameters>
+                            <param name="name" type="string"/>
+                        </parameters>
+                    </method>
+                </methods>
             </schema>
             </pdomDoc>
         </GetEntityIfMoreRecentResponse>

package/test/testUtil.test.js

@@ -0,0 +1,64 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const sdk = require("../src");
+const { DomUtil } = require("../src/domUtil");
+ 
+describe('TestUtil', function() {
+
+    describe('Creating test schema', () => {
+        it ('Should create schema from string', () => {
+            const schema = sdk.TestUtil.newSchema(`
+                <schema namespace="nms" name="recipient">
+                    <enumeration name="gender" basetype="byte">
+                    <value name="unknown" label="None specified" value="0"/>
+                    <value name="male" label="Male" value="1"/>
+                    <value name="female" label="Female" value="2"/>
+                    </enumeration>
+                    <element name="recipient">
+                    <attribute name="id" type="long"/>
+                    <attribute name="email" type="string"/>
+                    <attribute name="age" type="long"/>
+                    <attribute name="gender" type="long" enum="nms:recipient:gender"/>
+                    </element>
+                </schema>
+            `);
+            expect(schema.id).toBe("nms:recipient");
+        });
+
+        it ('Should create schema from XML', () => {
+            const xml = DomUtil.parse(`
+                <schema namespace="nms" name="recipient">
+                    <enumeration name="gender" basetype="byte">
+                    <value name="unknown" label="None specified" value="0"/>
+                    <value name="male" label="Male" value="1"/>
+                    <value name="female" label="Female" value="2"/>
+                    </enumeration>
+                    <element name="recipient">
+                    <attribute name="id" type="long"/>
+                    <attribute name="email" type="string"/>
+                    <attribute name="age" type="long"/>
+                    <attribute name="gender" type="long" enum="nms:recipient:gender"/>
+                    </element>
+                </schema>
+            `);
+            // From DOM document
+            let schema = sdk.TestUtil.newSchema(xml);
+            expect(schema.id).toBe("nms:recipient");
+            // From DOM element
+            schema = sdk.TestUtil.newSchema(xml.documentElement);
+            expect(schema.id).toBe("nms:recipient");
+        });
+    });
+
+});
+