@adobe/acc-js-sdk 1.0.2 → 1.0.6

package/test/client.test.js

@@ -27,7 +27,6 @@ const { HttpError } = require('../src/transport.js');
 describe('ACC Client', function () {
 
     describe('Init', function () {
-
         it('Should create client', async function () {
             const client = await Mock.makeClient();
             const NLWS = client.NLWS;
@@ -1193,13 +1192,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 +1207,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 +1223,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 +1309,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();
     })
@@ -1877,4 +1876,327 @@ describe('ACC Client', function () {
             expect(calls[0][0].data).toMatch("Logon");
         });
     })
+
+    describe("Security token authentication", () => {
+        // Security token authentication is used when embedding the SDK in Campaign: the session token
+        // is provided by the browser as a cookie. The cookie is not readable by JavaScript code and
+        // should be passed automatically by the browser, not by the SDK
+        it("Should create logged client", async() => {
+            const connectionParameters = sdk.ConnectionParameters.ofSecurityToken("http://acc-sdk:8080", "$security_token$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            expect(client.isLogged()).toBeFalsy();
+            await client.logon();
+            expect(client.isLogged()).toBeTruthy();
+            const logoff = client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.logoff();
+            expect(client.isLogged()).toBeFalsy();
+            // Ensure logoff has been called
+            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", "$token$");
+            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: [] });
+        });
+     })
+
+    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.6.acc-sdk:8080.cache.OptionCache$");
+
+            connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("https://acc-sdk:8080", "admin", "admin", {});
+            client = await sdk.init(connectionParameters);
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.6.acc-sdk:8080.cache.OptionCache$");
+
+            connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("acc-sdk:8080", "admin", "admin", {});
+            client = await sdk.init(connectionParameters);
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.6.acc-sdk:8080.cache.OptionCache$");
+        })
+
+        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");
+        });
+
+    });
 });

package/test/domUtil.test.js

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

package/test/index.test.js

@@ -60,4 +60,19 @@ describe('ACC SDK', function() {
         });
     });
 
+
+    describe("IP", () => {
+        it("Should get IP address", async () => {
+            const t = jest.fn();
+            const old = sdk._transport(t);
+            try {
+                t.mockReturnValueOnce(Promise.resolve({ "ipAddress":"AAA.BBB.CCC.DDD","continentCode":"EU","continentName":"Europe","countryCode":"FR","countryName":"France","stateProv":"Centre-Val de Loire","city":"Bourges" }));
+                const ip = await sdk.ip();
+                expect(ip).toMatchObject({ "ipAddress":"AAA.BBB.CCC.DDD" });
+            } finally {
+                sdk._transport(old);
+            }
+        });
+    })
+
 });

package/test/mock.js

@@ -21,14 +21,16 @@ governing permissions and limitations under the License.
  async function makeAnonymousClient(options) {
     const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("http://acc-sdk:8080", options);
     const client = await sdk.init(connectionParameters);
-    client._transport = jest.fn();
+    if (!options || !options.transport) // allow tests to explicitely set the transport
+        client._transport = jest.fn();
     return client;
 }
 
 async function makeClient(options) {
     const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", options);
     const client = await sdk.init(connectionParameters);
-    client._transport = jest.fn();
+    if (!options || !options.transport) // allow tests to explicitely set the transport
+        client._transport = jest.fn();
     return client;
 }
 
@@ -61,7 +63,7 @@ const LOGON_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <LogonResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
-            <pstrSessionToken xsi:type='xsd:string'>___C8B4A541-48DC-4C97-95AD-066930FD3892</pstrSessionToken>
+            <pstrSessionToken xsi:type='xsd:string'>___$session_token$</pstrSessionToken>
             <pSessionInfo xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
             <sessionInfo>
                 <serverInfo advisedClientBuildNumber="0" allowSQL="false" buildNumber="9219" commitId="f5f3ec3" databaseId="uFE80000000000000F1FA913DD7CC7C480041161C" defaultNameSpace="cus" fohVersion="2" instanceName="ffdamkt" majNumber="6" minClientBuildNumber="8969" minNumber="7" minNumberTechnical="0" releaseName="20.3" securityTimeOut="86400" serverDate="2020-07-05 14:11:31.986Z" servicePack="0" sessionTimeOut="86400" useVault="false"/>
@@ -73,11 +75,32 @@ const LOGON_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
                     </userInfo>
                 </sessionInfo>
             </pSessionInfo>
-            <pstrSecurityToken xsi:type='xsd:string'>@mMBSMLXIpQd56agsZ5X7OGXWz8Q476qMq6FimwqCdT1wByRDq3pQtaYSY4uJnAbCgXIvpXA5TrxHu-3YjUad5g==</pstrSecurityToken>
+            <pstrSecurityToken xsi:type='xsd:string'>@$security_token$==</pstrSecurityToken>
         </LogonResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
 
+    const BEARER_LOGON_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+    <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+    <SOAP-ENV:Body>
+        <BearerTokenLogonResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+            <pstrSessionToken xsi:type='xsd:string'>___$session_token$</pstrSessionToken>
+            <pSessionInfo xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
+            <sessionInfo>
+                <serverInfo advisedClientBuildNumber="0" allowSQL="false" buildNumber="9219" commitId="f5f3ec3" databaseId="uFE80000000000000F1FA913DD7CC7C480041161C" defaultNameSpace="cus" fohVersion="2" instanceName="ffdamkt" majNumber="6" minClientBuildNumber="8969" minNumber="7" minNumberTechnical="0" releaseName="20.3" securityTimeOut="86400" serverDate="2020-07-05 14:11:31.986Z" servicePack="0" sessionTimeOut="86400" useVault="false"/>
+                    <userInfo datakitInDatabase="true" homeDir="" instanceLocale="en" locale="en" login="admin" loginCS="Administrator (admin)" loginId="1059" noConsoleCnx="false" orgUnitId="0" theme="" timezone="Europe/Paris">
+                        <login-group id="1060"/>
+                        <login-right right="admin"/>
+                        <installed-package name="campaign" namespace="nms"/>
+                        <installed-package name="core" namespace="nms"/>
+                    </userInfo>
+                </sessionInfo>
+            </pSessionInfo>
+            <pstrSecurityToken xsi:type='xsd:string'>@$security_token$==</pstrSecurityToken>
+        </BearerTokenLogonResponse>
+    </SOAP-ENV:Body>
+    </SOAP-ENV:Envelope>`);
+
 const LOGON_RESPONSE_NO_USERINFO = Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
@@ -576,6 +599,7 @@ exports.Mock = {
   MC_PING: MC_PING,
   MC_PING_ERROR: MC_PING_ERROR,
   LOGON_RESPONSE: LOGON_RESPONSE,
+  BEARER_LOGON_RESPONSE: BEARER_LOGON_RESPONSE,
   LOGON_RESPONSE_NO_SESSIONTOKEN: LOGON_RESPONSE_NO_SESSIONTOKEN,
   LOGON_RESPONSE_NO_SECURITYTOKEN: LOGON_RESPONSE_NO_SECURITYTOKEN,
   LOGOFF_RESPONSE: LOGOFF_RESPONSE,

package/test/soap.test.js

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