@adobe/acc-js-sdk 1.0.5 → 1.0.6

package/src/util.js

@@ -135,236 +135,7 @@ class Util {
   }
 }
 
-
-/**********************************************************************************
- * 
- * A simple cache for XtkEntities, options, etc.
- * 
- *********************************************************************************/
-
-/**
- * @private
- * @class
- * @constructor
- * @memberof Utils
- */
-class SafeStorage {
-
-  /**
-   * A wrapper to the Storage interface (LocalStorage, etc.) which is "safe", i.e.
-   * 
-   * - it will never throw / support local stroage to be undefined or not accessible
-   * - Handle the notion of "root key", i.e. prefix 
-   * - Set/get values as JSON only and not as strings
-   * - Silently caches all exceptions
-   * - Automatically remove from storage cached values which are not valid, expired, or cannot be parsed
-   * 
-   * SafeStorage objects are created automatically by Caches
-   * 
-   * @param {Storage} delegate an optional delegate options, confomring to the Storage interface (getItem, setItem, removeItem)
-   * @param {string} rootKey an optional prefix which will be prepend to all keys
-   */
-  constructor(delegate, rootKey) {
-    this._delegate = delegate;
-    this._rootKey = rootKey ? `${rootKey}$` : "";
-  }
-
-  /**
-   * Get an item from storage
-   * @param {string} key the item key (relative to the root key)
-   * @returns {Object} the cached JSON object, or undefined if not found 
-   */
-  getItem(key) {
-    if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
-      return;
-    const itemKey = `${this._rootKey}${key}`;
-    const raw = this._delegate.getItem(itemKey);
-    if (!raw)
-      return undefined;
-    try {
-      return JSON.parse(raw);
-    } catch(ex) {
-      this.removeItem(key);
-    }
-  }
-
-  /**
-   * Put an item into storage
-   * @param {string} key the item key (relative to the root key)
-   * @param {Object} json the value to cache
-   */
-   setItem(key, json) {
-    if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
-      return;
-    try {
-      if (json && typeof json === "object") {
-        const raw = JSON.stringify(json);
-        this._delegate.setItem(`${this._rootKey}${key}`, raw);
-        return;
-      }
-    } catch(ex) { /* Ignore errors in safe class */
-    }
-    this.removeItem(key);
-  }
-
-  /**
-   * Removes an item from the storage
-   * @param {string} key the item key (relative to the root key)
-   */
-  removeItem(key) {
-    if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
-      return;
-    try {
-      this._delegate.removeItem(`${this._rootKey}${key}`);
-    } catch(ex) { /* Ignore errors in safe class */
-    }
-  }
-}
-
-/**
- * @private
- * @class
- * @constructor
- * @memberof Utils
- */
-class CachedObject {
-
-  /**
-   * An object in the cache, i.e. a wrapped to a cached value and additional metadata to manage the cache.
-   * Do not create such objects directly, they are 100% managed by the Cache object
-   * 
-   * @param {*} value the cached value
-   * @param {number} cachedAt the timestamp at which the value was cached
-   * @param {number} expiresAt the timestamp at which the cached value expires
-   */
-  constructor(value, cachedAt, expiresAt) {
-      this.value = value;
-      this.cachedAt = cachedAt;
-      this.expiresAt = expiresAt;
-  }
-}
-
-/** 
- * @private
- * @class
- * @constructor
- * @memberof Utils
- */
-class Cache {
-
-  /**
-   * A general purpose in-memory cache with TTL. In addition to caching in memory, the cache has the ability to delegate the caching
-   * to a persistent cache, such as the browser localStorage. The interface is 100% synchronous.
-   * 
-   * By default, caches take a single parameter for the key. It is possible however to use a more complex scenario by setting a makeKeyFn.
-   * When set, such a function will take 1 or more arguments and will be responsible to create a primitive key (a string) from the arguments.
-   * The cache public APIs : get and put therefore can take a variable number of key arguments, which will be combined into the actual primitive key.
-   * 
-   * @param {Storage} storage is an optional Storage object, such as localStorage or sessionStorage. This object will be wrapped into a SafeStorage object to ensure access is safe and will not throw any exceptions
-   * @param {string} rootKey is an optional root key to use for the storage object
-   * @param {number} ttl is the TTL for objects in ms. Defaults to 5 mins
-   * @param {function} makeKeyFn is an optional function which will generate a key for objects in the cache. It's passed the arguments of the cache 'get' function
-   */
-  constructor(storage, rootKey, ttl, makeKeyFn) {
-      this._storage = new SafeStorage(storage, rootKey);
-      this._ttl = ttl || 1000*300;
-      this._makeKeyFn = makeKeyFn || ((x) => x);
-      this._cache = {};
-      // timestamp at which the cache was last cleared
-      this._lastCleared = this._loadLastCleared();
-  }
-
-  // Load timestamp at which the cache was last cleared
-  _loadLastCleared() {
-    const json = this._storage.getItem("lastCleared");
-    return json ? json.timestamp : undefined;
-  }
-
-  _saveLastCleared() {
-    const now = Date.now();
-    this._lastCleared = now;
-    this._storage.setItem("lastCleared", { timestamp: now});
-  }
-
-  // Load from local storage
-  _load(key) {
-    const json = this._storage.getItem(key);
-    if (!json || !json.cachedAt || json.cachedAt <= this._lastCleared) {
-      this._storage.removeItem(key);
-      return;
-    }
-    return json;
-  }
-
-  // Save to local storage
-  _save(key, cached) {
-    this._storage.setItem(key, cached);
-  }
-
-  // Remove from local storage
-  _remove(key) {
-    this._storage.removeItem(key);
-  }
-
-  _getIfActive(key) {
-    // In memory cache?
-    var cached = this._cache[key];
-    // Local storage ?
-    if (!cached) {
-      cached = this._load(key);
-      this._cache[key] = cached;
-    }
-    if (!cached) 
-      return undefined;
-    if (cached.expiresAt <= Date.now()) {
-      delete this._cache[key];
-      this._remove(key);
-      return undefined;
-    }
-    return cached.value;
-  }
-
-  /**
-   * Get a value from the cache
-   * @param {*} key the key or keys of the value to retreive
-   * @returns {*} the cached value, or undefined if not found
-   */
-  get() {
-      const key = this._makeKeyFn.apply(this, arguments);
-      const cached = this._getIfActive(key);
-      return cached;
-  }
-
-  /**
-   * Put a value from the cache
-   * @param {*} key the key or keys of the value to retreive
-   * @param {*} value the value to cache
-   * @returns {CachedObject} a cached object containing the cached value
-   */
-   put() {
-      const value = arguments[arguments.length -1];
-      const key = this._makeKeyFn.apply(this, arguments);
-      const now = Date.now();
-      const expiresAt = now + this._ttl;
-      const cached = new CachedObject(value, now, expiresAt);
-      this._cache[key] = cached;
-      this._save(key, cached);
-      return cached;
-  }
-  
-  /**
-   * Removes everything from the cache. It does not directly removes data from persistent storage if there is, but it marks the cache
-   * as cleared so that subsequent get operation will not actually return any data cached in persistent storage
-   */
-  clear() {
-      this._cache = {};
-      this._saveLastCleared();
-  }
-}
-
 // Public expots
 exports.Util = Util;
-exports.SafeStorage = SafeStorage;
-exports.Cache = Cache;
 
 })();

package/src/xtkEntityCache.js

@@ -13,7 +13,7 @@ governing permissions and limitations under the License.
 "use strict";
 
 const DomUtil = require('./domUtil.js').DomUtil;
-const { Cache } = require('./util.js');
+const { Cache } = require('./cache.js');
 
 
 /**********************************************************************************
@@ -32,14 +32,30 @@ class XtkEntityCache extends Cache {
     
     /**
      * A in-memory cache for xtk entities. Not intended to be used directly,
-     * but an internal cache for the Campaign.Client object
+     * but an internal cache for the Campaign.Client object.
+     * 
+     * Cached object are made of
+     * - the key is a string in the form <entityType>|<entityName>, such as "xtk:schema|nms:recipient"
+     * - the value is a DOM element corresponding to the entity. It's always a DOM element, regardless of the client representation
      * 
      * @param {Storage} storage is an optional Storage object, such as localStorage or sessionStorage
      * @param {string} rootKey is an optional root key to use for the storage object
      * @param {number} ttl is the TTL for objects in ms. Defaults to 5 mins
      */
      constructor(storage, rootKey, ttl) {
-        super(storage, rootKey, ttl, (entityType, entityFullName) => entityType + "|" + entityFullName);
+        super(storage, rootKey, ttl, (entityType, entityFullName) => entityType + "|" + entityFullName, (item, serDeser) => {
+            if (serDeser) {
+                if (!item || !item.value) throw Error(`Cannot serialize falsy cached item`);
+                const value = Object.assign({}, item);
+                value.value = DomUtil.toXMLString(item.value);
+                return JSON.stringify(value);
+            }
+            else {
+                const json = JSON.parse(item);
+                json.value = DomUtil.parse(json.value).documentElement;
+                return json;
+            }
+        });
     }
 
     /**

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

@@ -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;
@@ -1897,6 +1896,58 @@ describe('ACC Client', function () {
         })   
      })
 
+    describe("Bearer token authentication", () => {
+        // Bearer token authentication is used when embedding IMS for authentication
+        it("Should create logged client", async() => {
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080", "$token$");
+            const 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 () => {
@@ -1909,6 +1960,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 +2130,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.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.5.acc-sdk:8080.cache.OptionCache$");
+            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.5.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.0.6.acc-sdk:8080.cache.OptionCache$");
         })
 
         it("Should support no storage", async () => {
@@ -2094,5 +2155,48 @@ 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");
+        });
+
+    });
 });

package/test/mock.js

@@ -63,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"/>
@@ -75,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>
@@ -578,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/util.test.js

@@ -17,7 +17,8 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
 
-const { Util, SafeStorage, Cache } = require('../src/util.js');
+ const { Util } = require('../src/util.js');
+ const { SafeStorage, Cache } = require('../src/cache.js');
 
 
 describe('Util', function() {