@adobe/acc-js-sdk 1.0.5 → 1.0.8

package/test/caches.test.js

@@ -18,7 +18,7 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 
 const assert = require('assert');
-const { Cache } = require('../src/util.js');
+const { Cache, SafeStorage } = require('../src/cache.js');
 const OptionCache = require('../src/optionCache.js').OptionCache;
 const MethodCache = require('../src/methodCache.js').MethodCache;
 const XtkEntityCache = require('../src/xtkEntityCache.js').XtkEntityCache;
@@ -205,7 +205,17 @@ describe('Caches', function() {
             assert.equal(found.nodeName, "method");
             assert.equal(found.getAttribute("name"), "Create");
         })
-    
+   
+        it("Deserialized method should be a DOM element", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            const cached = {value: { x:3, method:DomUtil.parse("<hello/>")} };
+            const serialized = serDeser(cached, true); 
+            const deserialized = serDeser(serialized, false);
+            const method = deserialized.value.method;
+            // should be a DOM element, not a DOM document
+            expect(method.nodeType).toBe(1);
+        })
     });
 
     describe("Method cache for interfaces", function() {
@@ -280,4 +290,140 @@ describe('Caches', function() {
             assert.strictEqual(urn, "xtk:session");
         });
     });
+
+    describe("SafeStorage", () => {
+
+        describe("JSON safe storage", () => {
+
+            it("Should find mock json from the cache", () => {
+                const map = {};
+                const delegate = {
+                    getItem: jest.fn((key) => map[key]),
+                    setItem: jest.fn((key, value) => map[key] = value)
+                }
+                const storage = new SafeStorage(delegate, "");
+                expect(storage.getItem("not_found")).toBeUndefined();
+                map["k1"] = `{ "hello": "world" }`;
+                expect(storage.getItem("k1")).toMatchObject({ hello: "world" });
+                map["k2"] = `{ "value": { "hello": "world" } }`;
+                expect(storage.getItem("k2")).toMatchObject({ value: { hello: "world" } });
+            });
+        });
+
+        describe("XML safe storage", () => {
+
+            const xmlSerDeser = (item, serDeser) => {
+                if (serDeser) {
+                    const xml = DomUtil.toXMLString(item.value);
+                    const value = {...item, value: xml };
+                    return JSON.stringify(value);
+                }
+                else {
+                    const json = JSON.parse(item);
+                    const dom = DomUtil.parse(json.value);
+                    return {...json, value:dom.documentElement};
+                }
+            };
+
+            it("Should find mock xml from the cache", () => {
+                const map = {};
+                const delegate = {
+                    getItem: jest.fn((key) => map[key]),
+                    setItem: jest.fn((key, value) => map[key] = value)
+                }
+                const storage = new SafeStorage(delegate, "", xmlSerDeser);
+                expect(storage.getItem("not_found")).toBeUndefined();
+                map["k1"] = `{ "hello": "world" }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute containing serialized XML
+                map["k1"] = `{ "hello": "world", "value": "" }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute containing serialized XML
+                map["k1"] = `{ "value": { "hello": "world" } }`;
+                expect(storage.getItem("k2")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k1"] = `{ "value": "" } }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k1"] = `{ "value": "bad" } }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k2"] = `{ "value": "<hello/>" }`;
+                expect(storage.getItem("k2").value.tagName).toBe("hello");
+            });
+        });
+    });
+
+    describe("Cache seralizers", () => {
+        it("Should serialize json", () => {
+            const cache = new OptionCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({ hello: "World" }, true)).toBe('{"hello":"World"}');
+            expect(serDeser({ }, true)).toBe('{}');
+            expect(() => {serDeser(null, true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser(undefined, true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser("", true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser("Hello", true)}).toThrow("Cannot serialize");
+        })
+
+        it("Should deserialize json", () => {
+            const cache = new OptionCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser('{"hello":"World"}', false)).toMatchObject({ hello: "World" });
+            expect(serDeser('{}', false)).toMatchObject({ });
+            expect(() => {serDeser(null, false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser(undefined, false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser("", false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser("Hello", false)}).toThrow("Unexpected token");
+        })
+
+        it("Should serialize XML entity", () => {
+            const cache = new XtkEntityCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({value: DomUtil.parse("<hello/>")}, true)).toBe('{"value":"<hello/>"}')
+            expect(() => { serDeser({}, true); }).toThrow();
+            expect(() => { serDeser(null, true); }).toThrow();
+            expect(() => { serDeser(undefined, true); }).toThrow();
+            expect(() => { serDeser("", true); }).toThrow();
+            expect(() => { serDeser("Hello", true); }).toThrow();
+        })
+
+        it("Should deserialize XML entity", () => {
+            const cache = new XtkEntityCache();
+            const serDeser = cache._storage._serDeser;
+            expect(DomUtil.toXMLString(serDeser(`{"value":"<hello/>"}`, false).value)).toBe("<hello/>");
+            expect(() => {serDeser(null, false)}).toThrow();
+            expect(() => {serDeser(undefined, false)}).toThrow();
+            expect(() => {serDeser("", false)}).toThrow();
+            expect(() => {serDeser("Hello", false)}).toThrow();
+        })
+
+        it("Should serialize methods", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({value: { x:3, method:DomUtil.parse("<hello/>")} }, true)).toBe('{"value":{"x":3,"method":"<hello/>"}}')
+            expect(() => { serDeser({value: { x:3 }}, true); }).toThrow();
+            expect(() => { serDeser({}, true); }).toThrow();
+            expect(() => { serDeser(null, true); }).toThrow();
+            expect(() => { serDeser(undefined, true); }).toThrow();
+            expect(() => { serDeser("", true); }).toThrow();
+            expect(() => { serDeser("Hello", true); }).toThrow();
+        })
+
+        it("Should deserialize methods", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            expect(DomUtil.toXMLString(serDeser('{"value":{"x":3,"method":"<hello/>"}}', false).value.method)).toBe("<hello/>");
+            expect(() => { serDeser('{"value":{"x":3}}', false); }).toThrow();
+            expect(() => { serDeser({}, false); }).toThrow();
+            expect(() => { serDeser(null, false); }).toThrow();
+            expect(() => { serDeser(undefined, false); }).toThrow();
+            expect(() => { serDeser("", false); }).toThrow();
+            expect(() => { serDeser("Hello", false); }).toThrow();
+        })
+
+        it("Method serialization should not change initial object", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            const cached = {value: { x:3, method:DomUtil.parse("<hello/>")} };
+            serDeser(cached, true); // make sure this call does not change the input parameter "cached"
+            expect(cached.value.x).toBe(3);
+            expect(cached.value.method.documentElement.tagName).toBe("hello");
+        })
+    })
 });

package/test/client.test.js

@@ -22,12 +22,13 @@ 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 () {
 
     describe('Init', function () {
-
         it('Should create client', async function () {
             const client = await Mock.makeClient();
             const NLWS = client.NLWS;
@@ -605,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();
@@ -631,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" });
@@ -643,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";
@@ -664,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);
@@ -681,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();
@@ -1897,6 +1907,200 @@ 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");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+            expect(client.isLogged()).toBeFalsy();
+            await client.logon();
+            expect(client.isLogged()).toBeTruthy();
+            const transport = client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.logoff();
+            expect(client.isLogged()).toBeFalsy();
+            // Ensure logoff has been called
+            expect(transport.mock.calls.length).toBe(2);
+        })
+
+        it("Call SAOP method", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080", "$token$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+            await client.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            var queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+
+            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>`));
+
+            // Select should return empty array
+            var query = client.NLWS.xtkQueryDef.create(queryDef);
+            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", () => {
 
         it("Should return a promise with UserPassword", async () => {
@@ -1909,6 +2113,16 @@ describe('ACC Client', function () {
             await result;
         })
 
+        it("Should return a promise with bearer token", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080", "$token$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+            const result = client.logon();
+            expect(result instanceof Promise).toBe(true);
+            await result;
+        })
+
         it("Should return a promise with UserAndServiceToken", async () => {
             const connectionParameters = sdk.ConnectionParameters.ofUserAndServiceToken("http://acc-sdk:8080", "$user$", "$service_token$");
             const client = await sdk.init(connectionParameters);
@@ -2069,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.5.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.7.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.5.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.7.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.5.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.7.acc-sdk:8080.cache.OptionCache$");
         })
 
         it("Should support no storage", async () => {
@@ -2094,5 +2308,118 @@ describe('ACC Client', function () {
             expect(value).toBe('uFE80000000000000F1FA913DD7CC7C480041161C');
             expect(storage.getItem.mock.calls.length).toBe(0); // storage is disabled and should not have been called
         })
+
+        it("Should cache XML in storage", async () => {
+            const map = {};
+            const storage = {
+                getItem: jest.fn((key) => map[key]),
+                setItem: jest.fn((key, value) => map[key] = value)
+            }
+            let client = await Mock.makeClient({ storage: storage });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+             await client.getSchema("nms:extAccount");
+            // Schema should have been cached to local storage
+            expect(storage.setItem.mock.calls.length).toBe(1);
+            expect(storage.setItem.mock.calls[0][0]).toMatch("cache.XtkEntityCache$xtk:schema|nms:extAccount");
+            // Value is the cached object, it should not be an empty object
+            const cached = JSON.parse(storage.setItem.mock.calls[0][1]);
+            expect(Object.keys(cached.value).length).toBeGreaterThan(0);
+            expect(cached.value).toMatch("<schema");
+
+            // Now simulate reusing the local storage. We need a new client to make sure we do not reuse
+            // the in-memory cache of the client. 
+            client = await Mock.makeClient({ storage: storage });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+            await client.getSchema("nms:extAccount");
+        })
     })
+
+    describe("Get Schema, cache and representations", () => {
+        it("Should get schema with no cache", async () => {
+            const client = await Mock.makeClient();
+            client.clearAllCaches();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+            var schema = await client.getSchema("nms:extAccount");
+            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" });
+        });
+    });
 });