@adobe/acc-js-sdk 1.1.2 → 1.1.5

package/test/client.test.js

@@ -25,7 +25,6 @@ const { HttpError } = require('../src/transport.js');
 const { Cipher } = require('../src/crypto.js');
 const { EntityAccessor } = require('../src/entityAccessor.js');
 
-
 describe('ACC Client', function () {
 
     describe('Init', function () {
@@ -2281,17 +2280,19 @@ describe('ACC Client', function () {
         });
 
         it("Should ignore protocol for local storage root key", async () => {
+            const version = sdk.getSDKVersion().version; // "${version}" or similar
+
             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.1.2.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe(`acc.js.sdk.${version}.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.1.2.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe(`acc.js.sdk.${version}.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.1.2.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe(`acc.js.sdk.${version}.acc-sdk:8080.cache.OptionCache$`);
         })
 
         it("Should support no storage", async () => {
@@ -2474,4 +2475,414 @@ describe('ACC Client', function () {
             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"}]}');
         });
     });
+
+    describe('Support for int type parameters such as nms:extAccount#UpdateMCSynchWkf', () => {
+        it("Should call nms:extAccount#UpdateMCSynchWkf", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            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>
+                <GetEntityIfMoreRecentResponse xmlns='urn:wpp:default' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                    <pdomDoc xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
+                        <schema name="extAccount" namespace="nms" xtkschema="xtk:schema">
+                            <element name="extAccount"></element>
+                            <methods>
+                                <method library="nms:messageCenter.js" name="UpdateMCSynchWkf" static="true" hidden="true">
+                                <parameters>
+                                    <param name="extAccountId" type="int" desc="Message Center external account identifier"/>
+                                </parameters>
+                            </method>
+                            </methods>
+                        </schema>
+                    </pdomDoc>
+                </GetEntityIfMoreRecentResponse>
+            </SOAP-ENV:Body>
+            </SOAP-ENV:Envelope>`));
+
+            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:nms:extAccount' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+            <SOAP-ENV:Body>
+            <UpdateMCSynchWkfResponse xmlns='urn:nms:extAccount' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+            </UpdateMCSynchWkfResponse>
+            </SOAP-ENV:Body>
+            </SOAP-ENV:Envelope>`));
+
+            await client.NLWS.nmsExtAccount.updateMCSynchWkf(1);
+        })
+    });
+
+    describe("Method-level HTTP headers", () => {
+        it("Should set header", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.headers({'X-Test': 'hello'}).xtkQueryDef.create(queryDef);
+
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                }
+            });
+            await query.executeQuery();
+            expect(headers).toMatchObject({
+                "SoapAction": "xtk:queryDef#ExecuteQuery",
+                "X-Test": "hello"
+            });
+        });
+
+        it("Should support global and method-level http headers", async () => {
+            const client = await Mock.makeClient({
+                extraHttpHeaders: {
+                    "X-Test": "world",
+                    "X-Test-Global": "global"
+                }
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.headers({'X-Test': 'hello'}).xtkQueryDef.create(queryDef);
+
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                }
+            });
+            await query.executeQuery();
+            expect(headers).toMatchObject({
+                "SoapAction": "xtk:queryDef#ExecuteQuery",
+                "X-Test": "hello",
+                "X-Test-Global": "global"
+            });
+        })
+
+        it("Should support undefined method headers", async () => {
+            const client = await Mock.makeClient({
+                extraHttpHeaders: {
+                    "X-Test": "world",
+                    "X-Test-Global": "global"
+                }
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            // missing headers
+            const query = client.NLWS.headers().xtkQueryDef.create(queryDef);
+
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                }
+            });
+            await query.executeQuery();
+            expect(headers).toMatchObject({
+                "SoapAction": "xtk:queryDef#ExecuteQuery",
+                "X-Test": "world",
+                "X-Test-Global": "global"
+            });
+        })
+
+        it("Should set http headers with an xml representation", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = DomUtil.parse(`
+                <queryDef schema="nms:extAccount" operation="select">
+                    <select>
+                        <node expr="@id"/>
+                        <node expr="@name"/>
+                    </select>
+                </queryDef>
+            `);
+            const query = client.NLWS
+                .headers({'X-Test': 'hello', 'X-Test-Before': 'before'})
+                .xml
+                .headers({'X-Test': 'world', 'X-Test-After': 'after'})
+                .xtkQueryDef.create(queryDef);
+                let headers = {};
+                client.registerObserver({
+                    onSOAPCall: (soapCall) => {
+                        const request = soapCall.request;
+                        headers = request.headers;
+                    }
+                });
+                await query.executeQuery();
+                console.log(headers);
+                expect(headers).toMatchObject({
+                    "SoapAction": "xtk:queryDef#ExecuteQuery",
+                    "X-Test": "world",
+                    "X-Test-Before": "before",
+                    "X-Test-After": "after"
+                });
+        });
+    });
+
+    describe("ACC-SDK HTTP headers", () => {
+
+        const collectHeaders = async (client, callback) => {
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                },
+                onHTTPCall: (request) => {
+                    headers = request.headers;
+                }
+            });
+            await callback();
+            return headers;
+        };
+
+        it("Should set headers by default", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+            });
+            // This header is only set if "clientApp" connection parameter is set
+            expect(headers["ACC-SDK-Client-App"]).toBeUndefined();
+        });
+
+        it("Should disable ACC-SDK headers", async () => {
+            const client = await Mock.makeClient({
+                noSDKHeaders: true
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+            expect(headers["ACC-SDK-Version"]).toBeUndefined();
+            expect(headers["ACC-SDK-Auth"]).toBeUndefined();
+            expect(headers["X-Query-Source"]).toBe(`${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`);
+        });
+
+        it("Should support ACC-SDK-Client-App header", async () => {
+            const client = await Mock.makeClient({
+                clientApp: 'Test client app'
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "ACC-SDK-Client-App": "Test client app",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
+            });
+        });
+
+        it("Should set ACC-SDK headers on ping JSP", async () => {
+            const client = await Mock.makeClient({
+                clientApp: 'Test client app'
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            const headers = await collectHeaders(client, async() => {
+                client._transport.mockReturnValueOnce(Mock.PING);
+                await client.ping();
+            });
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "ACC-SDK-Client-App": "Test client app",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
+            });
+        });
+
+        it("Should set ACC-SDK headers on mcping JSP", async () => {
+            const client = await Mock.makeClient({
+                clientApp: 'Test client app'
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            const headers = await collectHeaders(client, async() => {
+                client._transport.mockReturnValueOnce(Mock.MC_PING);
+                await client.mcPing();
+            });
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "ACC-SDK-Client-App": "Test client app",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
+            });
+        });
+    });
+
+    describe("Pushdown parameters", () => {
+        it("Should push down custom parameters", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            // Pushing down the foo=bar attributes
+            const query = client.NLWS.pushDown({'foo': 'bar'}).xtkQueryDef.create(queryDef);
+            await query.executeQuery();
+            const lastCall = client._transport.mock.calls[client._transport.mock.calls.length-1];
+            expect(lastCall[0].url).toBe("http://acc-sdk:8080/nl/jsp/soaprouter.jsp?xtk:queryDef#ExecuteQuery");
+            expect(lastCall[1].charset).toBe("UTF-8");
+            expect(lastCall[1].foo).toBe("bar");
+        });
+
+        it("Should push down custom parameters defined at the connection level", async () => {
+            const client = await Mock.makeClient({ 'cnxDefault': 3, 'foo': 'foo' });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            // Pushing down the foo=bar attributes (should overload the "foo" set in connecion parameters)
+            const query = client.NLWS.pushDown({'foo': 'bar'}).xtkQueryDef.create(queryDef);
+            await query.executeQuery();
+            const lastCall = client._transport.mock.calls[client._transport.mock.calls.length-1];
+            expect(lastCall[0].url).toBe("http://acc-sdk:8080/nl/jsp/soaprouter.jsp?xtk:queryDef#ExecuteQuery");
+            expect(lastCall[1].charset).toBe("UTF-8");
+            expect(lastCall[1].foo).toBe("bar");
+            expect(lastCall[1].cnxDefault).toBe(3);
+        });
+
+        it("Should chain push options", async () => {
+            const client = await Mock.makeClient({ 'cnxDefault': 3, 'foo': 'foo' });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            // Supports multiple calls to pushDown. each one overrides the previous in case of duplicate key
+            // Also supports undefined
+            const query = client.NLWS.pushDown({'foo': 'bar'}).pushDown().pushDown({'foo': 'fu', x: 2 }).xtkQueryDef.create(queryDef);
+            await query.executeQuery();
+            const lastCall = client._transport.mock.calls[client._transport.mock.calls.length-1];
+            expect(lastCall[0].url).toBe("http://acc-sdk:8080/nl/jsp/soaprouter.jsp?xtk:queryDef#ExecuteQuery");
+            expect(lastCall[1].charset).toBe("UTF-8");
+            expect(lastCall[1].foo).toBe("fu");
+            expect(lastCall[1].cnxDefault).toBe(3);
+            expect(lastCall[1].x).toBe(2);
+        });
+    });
 });