@adobe/acc-js-sdk 1.0.3 → 1.0.7

package/test/client.test.js

@@ -22,12 +22,12 @@ 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');
 
 
 describe('ACC Client', function () {
 
     describe('Init', function () {
-
         it('Should create client', async function () {
             const client = await Mock.makeClient();
             const NLWS = client.NLWS;
@@ -605,11 +605,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 +633,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 +647,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 +670,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 +689,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();
@@ -1193,13 +1202,13 @@ describe('ACC Client', function () {
 
         it("from default representation", async () => {
             const client = await Mock.makeClient();
-            var xml = DomUtil.toXMLString(client.fromRepresentation("root", {}));
+            var xml = DomUtil.toXMLString(client._fromRepresentation("root", {}));
             expect(xml).toBe("<root/>");
         })
 
         it("from SimpleJson representation", async () => {
             const client = await Mock.makeClient();
-            var xml = DomUtil.toXMLString(client.fromRepresentation("root", {}, "SimpleJson"));
+            var xml = DomUtil.toXMLString(client._fromRepresentation("root", {}, "SimpleJson"));
             expect(xml).toBe("<root/>");
         })
 
@@ -1208,14 +1217,14 @@ describe('ACC Client', function () {
             it("Should convert from BadgerFish to BadgerFish", async () => {
                 const client = await Mock.makeClient();
                 var from = { "@id": "1", "child": {} };
-                var to = client.convertToRepresentation(from, "BadgerFish", "BadgerFish");
+                var to = client._convertToRepresentation(from, "BadgerFish", "BadgerFish");
                 expect(to).toStrictEqual(from);
             })
 
             it("Should convert from BadgerFish to SimpleJson", async () => {
                 const client = await Mock.makeClient();
                 var from = { "@id": "1", "child": {} };
-                var to = client.convertToRepresentation(from, "BadgerFish", "SimpleJson");
+                var to = client._convertToRepresentation(from, "BadgerFish", "SimpleJson");
                 expect(to).toStrictEqual({ id: "1", child: {} });
             })
 
@@ -1224,20 +1233,20 @@ describe('ACC Client', function () {
 
         it("Compare representations", async () => {
             const client = await Mock.makeClient();
-            expect(() => { client.isSameRepresentation("json", "json") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("json", "BadgerFish") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("BadgerFish", "json") }).toThrow("SDK-000004");
-            expect(client.isSameRepresentation("SimpleJson", "SimpleJson")).toBeTruthy();
-            expect(client.isSameRepresentation("BadgerFish", "SimpleJson")).toBeFalsy();
-            expect(client.isSameRepresentation("SimpleJson", "BadgerFish")).toBeFalsy();
-            expect(client.isSameRepresentation("xml", "BadgerFish")).toBeFalsy();
-            expect(client.isSameRepresentation("SimpleJson", "xml")).toBeFalsy();
-            expect(() => { client.isSameRepresentation("Xml", "Xml") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("xml", "Xml") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("Xml", "xml") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("", "xml") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("xml", "") }).toThrow("SDK-000004");
-            expect(() => { client.isSameRepresentation("xml", null) }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("json", "json") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("json", "BadgerFish") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("BadgerFish", "json") }).toThrow("SDK-000004");
+            expect(client._isSameRepresentation("SimpleJson", "SimpleJson")).toBeTruthy();
+            expect(client._isSameRepresentation("BadgerFish", "SimpleJson")).toBeFalsy();
+            expect(client._isSameRepresentation("SimpleJson", "BadgerFish")).toBeFalsy();
+            expect(client._isSameRepresentation("xml", "BadgerFish")).toBeFalsy();
+            expect(client._isSameRepresentation("SimpleJson", "xml")).toBeFalsy();
+            expect(() => { client._isSameRepresentation("Xml", "Xml") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("xml", "Xml") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("Xml", "xml") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("", "xml") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("xml", "") }).toThrow("SDK-000004");
+            expect(() => { client._isSameRepresentation("xml", null) }).toThrow("SDK-000004");
         })
     });
 
@@ -1310,7 +1319,7 @@ describe('ACC Client', function () {
 
     it("User agent string", async () => {
         const client = await Mock.makeClient();
-        const ua = client.getUserAgentString();
+        const ua = client._getUserAgentString();
         expect(ua.startsWith("@adobe/acc-js-sdk/")).toBeTruthy();
         expect(ua.endsWith(" ACC Javascript SDK")).toBeTruthy();
     })
@@ -1896,4 +1905,450 @@ describe('ACC Client', function () {
             expect(logoff.mock.calls.length).toBe(1);
         })   
      })
+
+    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 (client) => {
+                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);
+            extAccount1 = await query1.executeQuery();
+            expect(extAccount1).toEqual({ extAccount: [] });
+        });
+
+        it("Expired session refresh client callback for code coverage", async () => {
+            let refreshClient = async (client) => {
+                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 (client) => {
+                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 () => {
+            const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "$user$", "$password$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            const result = client.logon();
+            expect(result instanceof Promise).toBe(true);
+            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);
+            client._transport = jest.fn();
+            const result = client.logon();
+            expect(result instanceof Promise).toBe(true);
+            try {
+                await result;
+            } catch(ex) { /* result or exception is not handled */ }
+        })
+
+        it("Should return a promise with SessionToken", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofSessionToken("http://acc-sdk:8080", "$session_token$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            const result = client.logon();
+            expect(result instanceof Promise).toBe(true);
+            await result;
+        })
+
+        it("Should return a promise with SecurityToken", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofSecurityToken("http://acc-sdk:8080", "$security_token$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            const result = client.logon();
+            expect(result instanceof Promise).toBe(true);
+            await result;
+        })
+
+        it("Should return a promise with AnonymousUser", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("http://acc-sdk:8080");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            const result = client.logon();
+            expect(result instanceof Promise).toBe(true);
+            await result;
+        })
+    })
+
+
+    describe("Should simulate server down", () => {
+        it("Should simulate server down and up again", async () => {
+            // Server is up and getOption
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+            var databaseId = await client.getOption("XtkDatabaseId", false);
+            expect(databaseId).toBe("uFE80000000000000F1FA913DD7CC7C480041161C");
+
+            // Now simulate a connection error (server is down)
+            const error = new Error("connect ECONNREFUSED 3.225.73.178:8080");
+            error.code="ECONNREFUSED";
+            error.errno="ECONNREFUSED";
+            client._transport.mockReturnValueOnce(Promise.reject(error));
+            await expect(client.getOption("XtkDatabaseId", false)).rejects.toMatchObject({
+                message: "500 - Error calling method 'xtk:session#GetOption': Error (connect ECONNREFUSED 3.225.73.178:8080)"
+            });
+
+            // Server is back up again
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+            databaseId = await client.getOption("XtkDatabaseId", false);
+            expect(databaseId).toBe("uFE80000000000000F1FA913DD7CC7C480041161C")
+        });
+    })
+
+    describe("Connection options", () => {
+        it("Should set options cache TTL", async () => {
+           const client = await Mock.makeClient({ optionCacheTTL: -1 });
+           client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+           client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+           await client.NLWS.xtkSession.logon();
+           // Get Option and cache result. Check the value is in cache
+           client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+           await client.getOption("XtkDatabaseId", true);
+           expect(client._optionCache._cache["XtkDatabaseId"].value).toMatchObject({ type: 6, rawValue: "uFE80000000000000F1FA913DD7CC7C480041161C" });
+           // Get it again, it should not use the cache (=> it should make a SOAP call)
+           // To test if the SOAP call is made, we mock the SOAP call answer with a different result
+           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>
+                        <GetOptionResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                            <pstrValue xsi:type='xsd:string'>uFE80000000000000F1FA913DD7CC7C48004116FF</pstrValue>
+                            <pbtType xsi:type='xsd:byte'>6</pbtType>
+                        </GetOptionResponse>
+                    </SOAP-ENV:Body>
+                    </SOAP-ENV:Envelope>`));
+            await client.getOption("XtkDatabaseId", true);
+            expect(client._optionCache._cache["XtkDatabaseId"].value).toMatchObject({ type: 6, rawValue: "uFE80000000000000F1FA913DD7CC7C48004116FF" });
+        })
+
+        it("Should set default value for traceAPICalls", async () => {
+            var client = await Mock.makeClient({ traceAPICalls: undefined });
+            expect(client._traceAPICalls).toBeFalsy();
+            client = await Mock.makeClient({ traceAPICalls: null });
+            expect(client._traceAPICalls).toBeFalsy();
+            client = await Mock.makeClient({ traceAPICalls: false });
+            expect(client._traceAPICalls).toBeFalsy();
+            client = await Mock.makeClient({ traceAPICalls: true });
+            expect(client._traceAPICalls).toBeTruthy();
+        })
+
+        it("Should set default transport", async () => {
+            var client = await Mock.makeClient({ transport: async () => {
+                return "Hello";
+            }});
+            await expect(client._transport()).resolves.toBe("Hello");
+        });
+    })
+
+
+    describe("Local storage", () => {
+        it("Shoud read from local storage", async () => {
+            const storage = {
+                getItem: jest.fn(),
+                setItem: jest.fn(),
+            }
+            const client = await Mock.makeClient({ storage: storage });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            storage.getItem.mockReturnValueOnce(JSON.stringify({value: { value: "Hello", type: 6 }, cachedAt: 1633715996021 }));
+            const value = await client.getOption("XtkDatabaseId");
+            expect(value).toBe("Hello");
+        })
+
+        it("Should write to local storage", async () => {
+            const storage = {
+                getItem: jest.fn(),
+                setItem: jest.fn(),
+            }
+            const client = await Mock.makeClient({ storage: storage });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            storage.getItem.mockReturnValueOnce(JSON.stringify({value: { value: "Hello", type: 6 }, cachedAt: 1633715996021 }));
+            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:wpp:default' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+                            <SOAP-ENV:Body>
+                            <WriteResponse xmlns='urn:wpp:default' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                            </WriteResponse>
+                            </SOAP-ENV:Body>
+                            </SOAP-ENV:Envelope>`));
+            await client.setOption("XtkDatabaseId", "World");
+            var call = undefined;
+            for (var i=0; i<storage.setItem.mock.calls.length; i++) {
+                if (storage.setItem.mock.calls[i][0].endsWith("OptionCache$XtkDatabaseId")) {
+                    call = storage.setItem.mock.calls[i];
+                    break;
+                }
+            }
+            expect(JSON.parse(call[1])).toMatchObject({
+                value: { value: "World", type: 6 }
+            })
+        });
+
+        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$");
+
+            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$");
+
+            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$");
+        })
+
+        it("Should support no storage", async () => {
+            const storage = {
+                getItem: jest.fn(),
+                setItem: jest.fn(),
+            }
+            const client = await Mock.makeClient({ storage: storage, noStorage: true });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+            const value = await client.getOption("XtkDatabaseId");
+            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");
+        });
+
+    });
 });