@adobe/acc-js-sdk 1.1.14 → 1.1.16

package/src/domUtil.js

@@ -386,6 +386,7 @@ class DomUtil {
     static _getTextIfTextNode(xml) {
         const child = xml.firstChild;
         if (!child) return null;                   // no children
+        if (xml.hasAttributes()) return null;      // no attributes
         if (child.nextSibling) return null;        // more than 1 child
         if (child.nodeType !== 3 && child.nodeType !== 4) return null;
         const text = child.nodeValue;
@@ -400,29 +401,37 @@ class DomUtil {
      * @param {Element} xml the DOM element to convert to JSON
      * @param {Object} json the object literal to write to
      * @param {string} flavor the JSON flavor: "SimpleJson" or "BadgerFish"
+     * @param {Object} parentJson parent JSON node during recursion. Is undefined for first call
+     * @param {boolean} forceTextAs is set during recursion (SimpleJson format) to force serialization of text nodes using "$: value" syntax 
+     *                  instead of "$name: value" syntax. This is necessary to process collections and arrays of elements which only 
+     *                  contain text nodes.
      */
-    static _toJSON(xml, json, flavor) {
-        if (xml.hasAttributes()) {
-            var attributes = xml.attributes;
-            for (var i=0; i<attributes.length; i++) {
-                var att = attributes[i];
-                var attName = (flavor == "BadgerFish" ? "@" : "") + att.name;
-                json[attName] = att.value;
-            }
-        }
+    static _toJSON(xml, json, flavor, parentJson, forceTextAs$) {
 
         // Heuristic to determine if element is an object or an array
         const isCollection = xml.tagName.length > 11 && xml.tagName.substr(xml.tagName.length-11) == '-collection';
 
+        // Figure out which elements are arrays. Keep a count of elements for each tag name.
+        // When count >1 we consider this tag name to be an array
+        var hasChildElements = false; // Will be set if there is at least one child element
+        const countByTag = {};
         var child = xml.firstChild;
         while (child) {
-            var childName = child.nodeName;
-            if (isCollection && (json[childName] === null || json[childName] === undefined))
-                json[childName] = [ ];
-            var isArray = !!json[childName];
-            if (isArray && !Util.isArray(json[childName]))
-                json[childName] = [ json[childName] ];
-            if (child.nodeType == 1) {  // element
+            if (child.nodeType == 1) {
+                const childName = child.nodeName;
+                if (countByTag[childName] === undefined) countByTag[childName] = 1;
+                else countByTag[childName] = countByTag[childName] + 1;
+                hasChildElements = true;
+            }
+            child = child.nextSibling;
+        }
+        
+        child = xml.firstChild;
+        while (child) {
+            if (child.nodeType == 1) {
+                const childName = child.nodeName;
+                const isArray = isCollection || countByTag[childName] > 1;
+                if (isArray && !json[childName]) json[childName] = [];
                 // In SimpleJson representation, ensure we have proper transformation
                 // of text and CDATA nodes. For instance, the following
                 //  <workflow><desc>Hello</desc></workflow>
@@ -434,12 +443,12 @@ class DomUtil {
                 // from the schema, we cannot know if <desc></desc> should be
                 // transformed into "$desc": "" or into "desc": {}
                 const text = this._getTextIfTextNode(child);
-                if (text !== null && flavor == "SimpleJson") {
+                if (!isArray && text !== null && flavor == "SimpleJson") {
                     json[`$${childName}`] = text;
                 }
                 else {
                     const jsonChild = flavor == "BadgerFish" ? new BadgerFishObject() : {};
-                    this._toJSON(child, jsonChild, flavor);
+                    this._toJSON(child, jsonChild, flavor, json, isArray);
                     if (isArray) 
                         json[childName].push(jsonChild);
                     else
@@ -457,6 +466,46 @@ class DomUtil {
             }
             child = child.nextSibling;
         }
+
+        // Proceed with text nodes in SimpleJson format. 
+        if (flavor === "SimpleJson") {
+            var text = "";
+            child = xml.firstChild;
+            while (child) {
+                if (child.nodeType === 3) { // text 
+                    var nodeText = child.nodeValue;
+                    // Whitespace trimming rule: always trim for the root node, and trim for non-root nodes
+                    // which actually have children elements
+                    // Never trim CDATA nodes (nodeType 4)
+                    if (!parentJson || hasChildElements)
+                        nodeText = nodeText.trim(); 
+                    if (nodeText) text = text + nodeText;
+                }    
+                else if (child.nodeType === 4) { // CDATA    
+                    const cdataText = child.nodeValue;
+                    if (cdataText) text = text + cdataText;
+                }    
+                child = child.nextSibling;
+            }
+            if (text) {
+                json.$ = text;
+            }
+        }
+
+        // Finally proceed with attributes. They are processed last so that we get a chance to prefix
+        // the attribute name with "@" in SimpleJson format if there's already an element with the
+        // same name
+        if (xml.hasAttributes()) {
+            const attributes = xml.attributes;
+            for (var i=0; i<attributes.length; i++) {
+                const att = attributes[i];
+                var attName = (flavor == "BadgerFish" ? "@" : "") + att.name;
+                if (json[attName] !== undefined && flavor === "SimpleJson")
+                    // There's already an element with the same name as the attribute
+                    attName = "@" + attName;
+                json[attName] = att.value;
+            }
+        }
     }
 
     /**

package/src/index.js

@@ -112,15 +112,15 @@ class SDK {
      * There are 2 alternate signatures for this function
      * <ul>
      * <li> the first one takes one single parameter which is a string and returns the escaped, quoted string
-     * <li> the second one takes 2 array of strings and is called when using the function in tagged string litterals. The first array is the constant parts
-     *   of the string litteral, and the second array contains the variable parts. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
+     * <li> the second one takes 2 array of strings and is called when using the function in tagged string literals. The first array is the constant parts
+     *   of the string literal, and the second array contains the variable parts. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
      * </ul>
      * <p>
-     * The function can be used in a tagged string litterals like this: "var expr = escapeXtk`@name=${hello}`"
+     * The function can be used in a tagged string literals like this: "var expr = escapeXtk`@name=${hello}`"
      * <p>
      * @memberof Campaign
-     * @param {string|string[]} p1 is the text to escape. If the text is null or undefined, it will be handled as an empty string. when using the escapeXtk for a tagged string litteral, this parameter is the array of constant values in the template.
-     * @param {undefined|string[]} p2 when using the escapeXtk for a tagged string litteral, this parameter is the array of expression values in the template.
+     * @param {string|string[]} p1 is the text to escape. If the text is null or undefined, it will be handled as an empty string. when using the escapeXtk for a tagged string literal, this parameter is the array of constant values in the template.
+     * @param {undefined|string[]} p2 when using the escapeXtk for a tagged string literal, this parameter is the array of expression values in the template.
      * @returns {string} the escaped and quoted (simple quotes) text.
      * 
      * @example
@@ -138,7 +138,7 @@ class SDK {
             return "'" + String(p1).replace(/\\/g, "\\\\").replace(/'/g,  "\\'") + "'";
         }
 
-        // Second syntax: for use in tagged template litterals
+        // Second syntax: for use in tagged template literals
         // instead of writing:  { expr: "@name = " + escapeXtk(userName) }
         // you write { expr: escapeXtk`@name = {userName}` }
         if (p1.length == 0) return "''";

package/src/soap.js

@@ -85,7 +85,7 @@ const NS_XSD = "http://www.w3.org/2001/XMLSchema";
 class SoapMethodCall {
     
     constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, pushDownOptions, extraHttpHeaders) {
-        this.request = undefined;       // The HTTP request (object litteral passed to the transport layer)
+        this.request = undefined;       // The HTTP request (object literal passed to the transport layer)
         this.requestOptions = undefined;
         this.response = undefined;      // The HTTP response object (in case of success)
 

package/src/transport.js

@@ -114,7 +114,6 @@ if (!Util.isBrowser()) {
         method: options.method,
         headers: headers,
         body: options.data,
-        credentials: options.credentials || 'same-origin'
     });
 
     const p = fetch(r).then(async (response) => {

package/src/util.js

@@ -55,7 +55,7 @@ class Util {
     // JavaScript arrays are objects
     if (typeof obj != "object") return false;
     // They also have a length property. But checking the length is not enough
-    // since, it can also be an object litteral with a "length" property. Campaign
+    // since, it can also be an object literal with a "length" property. Campaign
     // schema attributes typically have a "length" attribute and are not arrays
     if (obj.length === undefined || obj.length === null) return false;
     // So check for a "push" function
@@ -133,6 +133,24 @@ class Util {
     }
     return obj;
   }
+
+  /**
+   * Get Schema id from namespace (find first upper case letter)
+   * @param {string} namespace a SDK namespace, i.e. xtkWorkflow, nmsDelivery, etc.
+   * @return {string} the corresponding schema id, i.e. xtk:workflow, nms:delivery, etc.
+   */
+  static schemaIdFromNamespace(namespace) {
+    var schemaId = "";
+    for (var i=0; i<namespace.length; i++) {
+        const c = namespace[i];
+        if (c >='A' && c<='Z') {
+            schemaId = schemaId + ":" + c.toLowerCase() + namespace.substr(i+1);
+            break;
+        }
+        schemaId = schemaId + c;
+    }
+    return schemaId;
+  }
 }
 
 /**

package/src/xtkJob.js

@@ -0,0 +1,337 @@
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+(function() {
+"use strict";
+
+const { CampaignException } = require("./campaign.js");
+const { DomUtil } = require("./domUtil.js");
+const { XtkCaster } = require("./xtkCaster.js");
+
+/**
+ * @namespace Campaign
+ * 
+ * @typedef {DOMElement} SoapMethodDefinition
+ * @memberof Campaign
+ */
+
+
+
+/**
+ * The complete Triforce, or one or more components of the Triforce.
+ * @typedef {Object} XtkSoapCallSpec
+ * @property {string} method - the Soap method name (without any schema information)
+ * @property {string} xtkschema - the method schema id. It can be ommited if the object has a xtkschema property
+ * @property {any} object - the object ("this") to call the method with, possibly null for static methods. Should implement the xtk:job interface
+ * @property {Array} args - the list of arguments to the SOAP call
+ * @memberOf Campaign
+ */
+
+/**
+ * @typedef {Object} XtkJobLog
+ * @property {number} id - the job log id, which can be used for subsequent calls to getStatus
+ * @property {number} iRc - the job return code (0 = ok)
+ * @property {Date} logDate - the timestamp of the log
+ * @property {number} logType - the level of the log message according
+ * @property {string} message - the log message
+ * @property {string} object - the log object
+ * @property {string} errorCode - the log error code if any
+ * @memberOf Campaign
+ */
+
+
+/**
+ * @typedef {Object} XtkJobStatus
+ * @property {number} status - the job status code, as defined in the xtk:job:jobStatus enumeration
+ * @property {XtkJobLog[]} logs - the job log messages
+ * @property {{key: string, value: string}} properties - job properties
+ * @memberOf Campaign
+ */
+
+/**********************************************************************************
+ *
+ * Job Interface
+ * Wraps the xtk:jobInterface interface into convenient JavaScript class
+ *
+ *********************************************************************************/
+/**
+ * @private
+ * @class
+ * @constructor
+ * @memberof Campaign
+ */
+class XtkJobInterface {
+
+    /**
+     * Create a job interface from a client and a SOAP call definition. This method is not meant to be called directly, 
+     * use client.jobInterface instead
+     * @param {Campaign.Client} client the Client object to call Campaign API
+     * @param {Campaign.XtkSoapCallSpec} soapCallSpec the definition of the SOAP call
+     */
+    constructor(client, soapCallSpec) {
+        this._client = client;
+        this._soapCall = soapCallSpec;
+        this._maxLogCount = 100; // default fetch size
+        this._reset();
+    }
+
+    // Reset state before executing or submitting a job
+    _reset() {
+        this.jobId = undefined;
+        this.status = undefined;
+        this.result = undefined;
+        this.lastLogId = 0;
+        this.iRc = 0;
+        this.lastErrorCode = undefined;
+        this.firstErrorCode = undefined;
+    }
+
+    /**
+     * Execute job synchronously (xtk:jobInterface#Execute). Expects the job to have been built with an object implementing the xtk:job interface,
+     * for instance a delivery, and with the method to call (for instance "Prepare")
+     * Static methods are not supported
+     * @returns {string} a job id
+     */
+    async execute() {
+        this._reset();
+        const methodName = this._soapCall.method;
+        const entitySchemaId = this._soapCall.xtkschema ? this._soapCall.xtkschema : (this._soapCall.object ? this._soapCall.object.xtkschema : undefined);
+        if (!entitySchemaId)
+            throw CampaignException.SOAP_UNKNOWN_METHOD(entitySchemaId, methodName, `No schema was provided in soap call or object`);
+        const callContext = {
+            client: this._client,
+            object: this._soapCall.object,
+            schemaId: 'xtk:jobInterface',
+            entitySchemaId: entitySchemaId
+        };
+        var jobId = await callContext.client._callMethod("Execute", callContext, [ methodName ]);
+        this.jobId = jobId;
+        return jobId;
+    }
+
+    /**
+     * Execute job asynchronously (xtk:jobInterface#Execute). Expects the job to have been built with an object implementing the xtk:job interface,
+     * for instance a delivery, and with the method to call (for instance "Prepare")
+     * Static methods are not supported
+     * @returns {string} a job id
+     */
+     async submit() {
+        this._reset();
+        const methodName = this._soapCall.method;
+        const entitySchemaId = this._soapCall.xtkschema ? this._soapCall.xtkschema : (this._soapCall.object ? this._soapCall.object.xtkschema : undefined);
+        if (!entitySchemaId)
+            throw CampaignException.SOAP_UNKNOWN_METHOD(entitySchemaId, methodName, `No schema was provided in soap call or object`);
+        const callContext = {
+            client: this._client,
+            object: this._soapCall.object,
+            schemaId: 'xtk:jobInterface',
+            entitySchemaId: entitySchemaId
+        };
+        var jobId = await callContext.client._callMethod("Submit", callContext, [ this._soapCall.method ]);
+        this.jobId = jobId;
+        return jobId;
+    }
+
+    /**
+     * Execute a SOAP call asynchronously (xtk:jobInterface#Execute). Expects the job to have been built with an object implementing the xtk:job interface,
+     * for instance a delivery, and with the method to call (for instance "Prepare"). Can optionally pass parameters to the job.
+     * Static methods are not supported
+     * @returns {string} a job id
+     */
+     async submitSoapCall() {
+        this._reset();
+        const entitySchemaId = this._soapCall.xtkschema ? this._soapCall.xtkschema : (this._soapCall.object ? this._soapCall.object.xtkschema : undefined);
+        const callContext = {
+            client: this._client,
+            object: this._soapCall.object,
+            schemaId: 'xtk:jobInterface',
+            entitySchemaId: entitySchemaId,
+        };
+
+        const methodName = this._soapCall.method;
+        var schema = await this._client.getSchema(entitySchemaId, "xml", true);
+        if (!schema)
+            throw CampaignException.SOAP_UNKNOWN_METHOD(entitySchemaId, methodName, `Schema '${entitySchemaId}' not found`);
+        var method = this._client._methodCache.get(entitySchemaId, methodName);
+        if (!method)
+            throw CampaignException.SOAP_UNKNOWN_METHOD(entitySchemaId, methodName, `Method '${methodName}' of schema '${entitySchemaId}' not found`);
+        // SubmitSoapCall does not support 
+        const isStatic = DomUtil.getAttributeAsBoolean(method, "static");
+        if (isStatic) 
+            throw CampaignException.SOAP_UNKNOWN_METHOD(entitySchemaId, methodName, `Method '${methodName}' of schema '${entitySchemaId}' is static`);
+
+
+        var jobId = await callContext.client._callMethod("SubmitSoapCall", callContext, [ {
+            name: this._soapCall.method,
+            service: this._soapCall.xtkschema,
+            param: [
+                { name:"this", type:"DOMDocument", value: this._soapCall.object },
+                { name:"bStart", type:"boolean", value:"false" },
+            ]
+        } ]);
+        this.jobId = jobId;
+        return jobId;
+    }
+
+    /**
+     * Poll the status of a job previously submitted with Execute, Submit, or SubmitSoapCall. The status is made of 3 objects: the status code,
+     * logs, and job properties. Job Properties are arbitrary key value pairs set by the job, but also contains progress information.
+     * This call will fetch the most recent status and logs and aggregate it with previously fetched statuses
+     * @param {number|undefined} lastLogId the log id fetch logs from. If unspecified, this function will return the next batch of logs. If set to 0, will return logs from the beginning
+     * @param {number|undefined} maxLogCount the max number of logs to fetch. Defaults to 100
+     * @returns {Campaign.XtkJobStatus} an object containing the job status, all logs fetched so for, and job properties
+     */
+    async getStatus(lastLogId, maxLogCount) {
+        if (lastLogId === undefined) lastLogId = this.lastLogId;
+        if (maxLogCount === null || maxLogCount === undefined) maxLogCount = this._maxLogCount;
+        var status = await this._client.NLWS.xtkJob.getStatus(this.jobId, lastLogId, maxLogCount);
+        if (this._client._representation === "xml") {
+            status[1] = this._client._toRepresentation(status[1], "SimpleJson");
+            status[2] = this._client._toRepresentation(status[2], "SimpleJson");
+        }
+        status = this._makeJobStatus(status);
+        this._updateStatus(status);
+        return status;
+    }
+
+    // Aggregate new status with previously fetched status
+    _updateStatus(status) {
+        for (var i=0; i<status.logs.length; i++) {
+            if (status.logs[i].id > this.lastLogId)
+                this.lastLogId = status.logs[i].id;
+        }
+        if (this.status === undefined) {
+            this.status = status;
+        }
+        else {
+            const oldLogs = this.status.logs;
+            this.status = status;
+            this.status.logs = oldLogs.concat(this.status.logs);
+        }
+    }
+
+    /**
+     * Returns current progress of the job as a percentage (value between 0 and 1). This requires getStatus to have been called before
+     * @returns {number} the current job progress as a percentage value
+     */
+    getProgress() {
+        if (!this.status || !this.status.properties || !this.status.properties.progress) return 0;
+        if (!this.status.properties.progress.max) return 0;
+        return this.status.properties.progress.current / this.status.properties.progress.max;
+    }
+
+    /**
+     * Get the result of a job, i.e. the value returned by the underlying SOAP call if it had been called directlty. 
+     * Assumes that the job is successful. If not, this call will throw an exception
+     * @returns {*} the job result
+     */
+    async getResult() {
+        var result = await this._client.NLWS.xtkJob.getResult(this.jobId);
+        result = this._makeJobResult(result);
+        this.result = result;
+        return result;
+    }
+
+    // Convert the job result into a typed object
+    _makeJobResult(rawResult) {
+        return rawResult;
+    }
+
+    // Convert job logs into a type object
+    _makeLogs(rawLogs) {
+        const logs = [];
+        rawLogs = rawLogs || {};
+        rawLogs = XtkCaster.asArray(rawLogs.log);
+        for (var i=0; i<rawLogs.length; i++) {
+            const rawLog = rawLogs[i];
+            var message = XtkCaster.asString(rawLog.message);
+            const match = message.match(/(\w{3}-\d{6})(.*)/);
+            var errorCode = undefined;
+            if (match && match.length >= 2) {
+                errorCode = match[1];
+                message = match[2] || "";
+                message = message.trim();
+            }
+            rawLog.id = XtkCaster.asLong(rawLog.id);
+            rawLog.iRc = XtkCaster.asLong(rawLog.iRc);
+            rawLog.logDate = XtkCaster.asDatetime(rawLog.logDate);
+            rawLog.logType = XtkCaster.asLong(rawLog.logType);
+            rawLog.message = message;
+            rawLog.object = XtkCaster.asString(rawLog.object);
+            rawLog.errorCode = errorCode;
+            logs.push(rawLog);
+
+            if (errorCode) 
+                this.lastErrorCode = errorCode;
+            if (errorCode && !this.firstErrorCode)
+                this.firstErrorCode = errorCode;
+            if (rawLog.iRc != 0)
+                this.iRc = rawLog.iRc;
+        }
+        return logs;
+    }
+
+    // Convert job properties into a typed object
+    _makeProperties(rawProperties) {
+        rawProperties = rawProperties || {};
+        rawProperties.warning = XtkCaster.asBoolean(rawProperties.warning);
+        if (!rawProperties.progress) rawProperties.progress = {};
+        rawProperties.progress.current = XtkCaster.asLong(rawProperties.progress.current);
+        rawProperties.progress.max = XtkCaster.asLong(rawProperties.progress.max);
+        return rawProperties;
+    }
+
+    // Parse the result of GetStatus API. The result is an array of 3 object. The first is the status code,
+    // followed by the the logs, and finally the properties
+    _makeJobStatus(rawStatus) {
+        if (!rawStatus) rawStatus = [];
+        return {
+            status: XtkCaster.asLong(rawStatus[0]),
+            logs: this._makeLogs(rawStatus[1]),
+            properties: this._makeProperties(rawStatus[2])
+        };
+    }
+
+    /**
+     * Cancel a preciously submitted job
+     */
+     async cancel() {
+        await this._client.NLWS.xtkJob.cancel(this.jobId);
+    }
+
+    /**
+     * Pause a preciously submitted job
+     */
+    async   pause() {
+        await this._client.NLWS.xtkJob.pause(this.jobId);
+    }
+    
+    /**
+     * Waits until a job is actually cancelled
+     * @param {number} timeoutSeconds in seconds
+     */
+     async waitJobCancelled(timeoutSeconds) {
+        await this._client.NLWS.xtkJob.waitJobCancelled(this.jobId, timeoutSeconds);
+    }
+
+    /**
+     * Queries if warnings or errors have been generated for this job
+     * @return {boolean} Returns 'true' if there has been at least one warning or error message
+     */
+     async hasWarning() {
+        return XtkCaster.asBoolean(await this._client.NLWS.xtkJob.hasWarning(this.jobId));
+    }
+}
+
+// Public exports
+exports.XtkJobInterface = XtkJobInterface;
+
+})();

package/test/client.test.js

@@ -40,14 +40,14 @@ describe('ACC Client', function () {
         it('Create client with invalid parameters', () => {
             // No 4th parameter should be ok
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"))).not.toBeFalsy();
-            // Object litteral is ok too
+            // Object literal is ok too
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"), {})).not.toBeFalsy();
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"), { representation: "BadgerFish" })).not.toBeFalsy();
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"), { dummy: 1 })).not.toBeFalsy();
             // Boolean is not ok
-            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", true)); }).toThrow("An object litteral is expected");
-            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", false)); }).toThrow("An object litteral is expected");
-            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", "BadgerFish")); }).toThrow("An object litteral is expected");
+            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", true)); }).toThrow("An object literal is expected");
+            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", false)); }).toThrow("An object literal is expected");
+            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", "BadgerFish")); }).toThrow("An object literal is expected");
             // Invalid representation is not ok
             expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", { representation: "Hello" })); }).toThrow("Invalid representation");
         });
@@ -2614,7 +2614,7 @@ describe('ACC Client', function () {
         </extAccount-collection>`);
         });
 
-        it("Should force an json representation", async () => {
+        it("Should force a json representation", async () => {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
@@ -2633,7 +2633,7 @@ describe('ACC Client', function () {
             const query = client.NLWS.json.xtkQueryDef.create(queryDef);
             const result = await query.executeQuery();
             const json = JSON.stringify(result);
-            expect(json).toBe('{"#text":[],"extAccount":[{"id":"1816","name":"defaultPopAccount"},{"id":"1818","name":"defaultOther"},{"id":"1849","name":"billingReport"},{"id":"12070","name":"TST_EXT_ACCOUNT_POSTGRESQL"},{"id":"1817","name":"defaultEmailBulk"},{"id":"2087","name":"ffda"},{"id":"2088","name":"defaultEmailMid"}]}');
+            expect(json).toBe('{"extAccount":[{"id":"1816","name":"defaultPopAccount"},{"id":"1818","name":"defaultOther"},{"id":"1849","name":"billingReport"},{"id":"12070","name":"TST_EXT_ACCOUNT_POSTGRESQL"},{"id":"1817","name":"defaultEmailBulk"},{"id":"2087","name":"ffda"},{"id":"2088","name":"defaultEmailMid"}]}');
         });
     });
 
@@ -3252,8 +3252,10 @@ describe('ACC Client', function () {
                     url: expect.any(String),
                     method: 'POST',
                     processData: false,
-                    credentials: 'include',
-                    headers: expect.anything(),
+                    headers: expect.objectContaining({
+                        'X-Security-Token': expect.any(String),
+                        'X-Session-Token': expect.any(String),
+                    }),
                 })
             );
 
@@ -3514,6 +3516,18 @@ describe('ACC Client', function () {
                 schema: "nms:delivery",
                 formData: {ctx: {}}
             });
+            expect(client._transport).toHaveBeenLastCalledWith(
+                expect.objectContaining({
+                    data: expect.anything(),
+                    url: expect.any(String),
+                    method: 'POST',
+                    headers: expect.objectContaining({
+                        'X-Security-Token': expect.any(String),
+                        'X-Session-Token': expect.any(String),
+                        "Content-Type": "application/x-www-form-urlencoded",
+                    }),
+                })
+            );
             expect(report._reportContext).toBe("throughput");
             expect(report._selection).toBe("12133");
             expect(report.vars.$period).toBe("604800");