@adobe/acc-js-sdk 1.1.16 → 1.1.18

package/src/soap.js

@@ -92,6 +92,7 @@ class SoapMethodCall {
         // Current URN and method (for error reporting)
         this.urn = urn;
         this.methodName = methodName;
+        this.isStatic = false;
 
         // Soap calls marked as internal are calls performed by the framework internally
         // (such as GetEntityIfMoreRecent calls needed to lookup schemas)
@@ -341,7 +342,7 @@ class SoapMethodCall {
     getEntity() {
         if (!this.elemCurrent)
             return null;
-            if (this.elemCurrent.getAttribute("xsi:type") != "ns:Element")
+        if (this.elemCurrent.getAttribute("xsi:type") != "ns:Element")
             return null;
         if (this.elemCurrent.tagName != "entity")
             return null;
@@ -612,7 +613,7 @@ class SoapMethodCall {
             this._method.prepend(sessionTokenElem);
         }
         const noMethodInURL = !!this._pushDownOptions.noMethodInURL;
-        const actualUrl = noMethodInURL ? url : `${url}?${this.urn}:${this.methodName}`;
+        const actualUrl = noMethodInURL ? url : `${url}?soapAction=${encodeURIComponent(this.urn + "#" + this.methodName)}`;
 
         // Prepare request and empty response objects
         [this.request, this.requestOptions] = this._createHTTPRequest(actualUrl);

package/test/application.test.js

@@ -1704,6 +1704,34 @@ describe('Application', () => {
                 expect(node.isCalculated).toBe(true);
             });
 
+            it("Should get node edit type", 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="profile" namespace="nms" xtkschema="xtk:schema">
+                              <element name="profile">
+                                  <compute-string expr="@lastName + ' ' + @firstName +' (' + @email + ')'"/>
+                                  <attribute name="firstName"/>
+                                  <attribute name="lastName"/>
+                                  <attribute name="email" edit="memo"/>
+                              </element>
+                          </schema>
+                      </pdomDoc>
+                  </GetEntityIfMoreRecentResponse>
+              </SOAP-ENV:Body>
+              </SOAP-ENV:Envelope>`));
+              const schema = await client.application.getSchema("nms:profile");
+
+              const node = schema.root.children.get("@email");
+              const editType = node.editType;
+              expect(editType).toBe("memo");
+          });
+
             it("Should get compute string for ref nodes", async () => {
                 const client = await Mock.makeClient();
                 client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);

package/test/client.test.js

@@ -842,6 +842,18 @@ describe('ACC Client', function () {
             await client.NLWS.xtkSession.logoff();
         });
 
+        it("Should fail if method parameter inout attribute is not correct", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            await expect(client.NLWS.xtkSession.badParam()).rejects.toMatchObject({ errorCode: "SDK-000006" });
+
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+
         it("Should fail if calling non static function without object", async () => {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
@@ -2304,7 +2316,7 @@ describe('ACC Client', function () {
             expect(JSON.parse(call[1])).toMatchObject({
                 value: { value: "World", type: 6 }
             })
-        });
+        })
 
         it("Should ignore protocol for local storage root key", async () => {
             const version = sdk.getSDKVersion().version; // "${version}" or similar
@@ -2347,7 +2359,7 @@ describe('ACC Client', function () {
             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");
+            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");
@@ -2363,6 +2375,73 @@ describe('ACC Client', function () {
             await client.NLWS.xtkSession.logon();
             client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
             await client.getSchema("nms:extAccount");
+            // Here we can't simply check the length of mock calls since there're for "lastCleared"
+            // We check inside the new calls, since the creation of the second client, if there's 
+            // one for the schema "nms:extAccount"
+            let callLength = storage.getItem.mock.calls.length;
+            expect(storage.getItem.mock.calls[callLength-1][0]).toMatch("cache.XtkEntityCache$xtk:schema|nms:extAccount");
+        })
+
+        it("Should clear storage if necessary", async () => {
+            const sdkVersion = sdk.getSDKVersion().version;
+            const mockSdkVersionItemKey    = "acc.js.sdk.0.0.0.acc-sdk:8080.cache.Hello";
+            const otherItemKey             = "other.Hello";
+            const map = {};
+            const storage = {
+                "acc.js.sdk.0.0.0.acc-sdk:8080.cache.Hello": "0.0.0.World",
+                "other.Hello": "other.World",
+                getItem: jest.fn((key) => map[key]),
+                setItem: jest.fn((key, value) => map[key] = value),
+                removeItem: jest.fn((key) => { delete map[key] })
+            }
+
+            let client = await Mock.makeClient({ storage: storage });
+
+            // Remove item not matches to the current sdk version and begins with "acc.js.sdk"
+            expect(storage.removeItem.mock.calls.length).toBe(1);
+            expect(storage.removeItem.mock.calls[0][0]).toMatch(mockSdkVersionItemKey);
+
+            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");
+            const currentSdkVersionItemKey = "acc.js.sdk."+sdkVersion+".acc-sdk:8080.cache.XtkEntityCache$xtk:schema|nms:extAccount";
+            expect(storage.setItem.mock.calls[0][0]).toMatch(currentSdkVersionItemKey);
+
+            // Remove ONLY the item not matches to the current sdk version but not the one matches
+            // Now simulate reusing the local storage to make sure that we remove ONLY the item 
+            // not matches to the current sdk version.
+            // We need a new client to make sure we do not reuse the in-memory cache of the client.
+            // We use the same test method as the one we use in the previous test "Should cache XML in storage"
+            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");
+            let callLength = storage.getItem.mock.calls.length;
+            expect(storage.getItem.mock.calls[callLength-1][0]).toMatch("cache.XtkEntityCache$xtk:schema|nms:extAccount");
+        })
+
+        it("Should support 'storage.removeItem' not defined", async () => {
+            const mockSdkVersionItemKey    = "acc.js.sdk.0.0.0.acc-sdk:8080.cache.Hello";
+            const map = {};
+            const storage = {
+                "acc.js.sdk.0.0.0.acc-sdk:8080.cache.Hello": "0.0.0.World",
+                getItem: jest.fn((key) => map[key]),
+                setItem: jest.fn((key, value) => map[key] = value)
+            }
+            let client = await Mock.makeClient({ storage: storage });
+            // storage.removeItem not defined. Cache should not be removed.
+            expect(storage[mockSdkVersionItemKey]).toStrictEqual("0.0.0.World");
+        })
+
+        it("Should support 'storage' not defined", async () => {
+            const storage = undefined
+            let client = await Mock.makeClient({ storage: storage });
+            // Create a client with "storage" undefined
+            const NLWS = client.NLWS;
+            expect(NLWS).toBeTruthy();
+            expect(client.isLogged()).toBe(false);
         })
     })
 
@@ -2987,7 +3066,7 @@ describe('ACC Client', function () {
             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[0].url).toBe("http://acc-sdk:8080/nl/jsp/soaprouter.jsp?soapAction=xtk%3AqueryDef%23ExecuteQuery");
             expect(lastCall[1].charset).toBe("UTF-8");
             expect(lastCall[1].foo).toBe("bar");
         });
@@ -3012,7 +3091,7 @@ describe('ACC Client', function () {
             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[0].url).toBe("http://acc-sdk:8080/nl/jsp/soaprouter.jsp?soapAction=xtk%3AqueryDef%23ExecuteQuery");
             expect(lastCall[1].charset).toBe("UTF-8");
             expect(lastCall[1].foo).toBe("bar");
             expect(lastCall[1].cnxDefault).toBe(3);
@@ -3039,7 +3118,7 @@ describe('ACC Client', function () {
             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[0].url).toBe("http://acc-sdk:8080/nl/jsp/soaprouter.jsp?soapAction=xtk%3AqueryDef%23ExecuteQuery");
             expect(lastCall[1].charset).toBe("UTF-8");
             expect(lastCall[1].foo).toBe("fu");
             expect(lastCall[1].cnxDefault).toBe(3);

package/test/mock.js

@@ -280,6 +280,11 @@ const GET_XTK_SESSION_SCHEMA_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
                             <param name="result" type="long" inout="out"/>
                         </parameters>
                     </method>
+                    <method name="badParam" static="true">
+                        <parameters>
+                            <param name="bad" type="long" inout="zz"/>
+                        </parameters>
+                    </method>
                 </methods>
             </schema>
             </pdomDoc>

package/test/observability.test.js

@@ -263,5 +263,154 @@ describe('ACC Client Observability', function () {
         jest.useRealTimers();
     });
 
+    describe("SOAP method intercept", () => {
+        it("Should intercept SOAP call", async () => {
+            const [client, assertion] = await makeObservableClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            const observer = { beforeSoapCall: jest.fn(), afterSoapCall: jest.fn() };
+            client.registerObserver(observer);
+
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+            await client.getOption("XtkDatabaseId");
+            
+            // Only one call is intercepted: xtk:session#GetOption. The internal call to get the xtk:session schema is internal
+            // and hence not interceptable
+            expect(observer.beforeSoapCall).toHaveBeenCalledTimes(1);
+            expect(observer.beforeSoapCall.mock.calls[0]).toEqual([ { urn:"xtk:session", name: "GetOption" }, [ { name:"name", type:"string", value:"XtkDatabaseId" } ], "SimpleJson" ]);
+            expect(observer.afterSoapCall).toHaveBeenCalledTimes(1);
+            expect(observer.afterSoapCall.mock.calls[0]).toEqual([ { urn:"xtk:session", name: "GetOption" }, [ { name:"name", type:"string", value:"XtkDatabaseId" } ], "SimpleJson", [ { name:"value", type:"string", value:"uFE80000000000000F1FA913DD7CC7C480041161C" }, { name:"type", type:"byte", value:6 }] ]);
+
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+
+        it("Should support intercept callback to get schemas", async () => {
+            const [client, assertion] = await makeObservableClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            const observer = { beforeSoapCall: jest.fn(), afterSoapCall: jest.fn() };
+            client.registerObserver(observer);
+
+            var extAccountSchema;
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+            observer.beforeSoapCall.mockImplementationOnce(async (method, inputParameters, representation) => {
+                extAccountSchema = await client.getSchema("nms:extAccount");
+            });
+            var databaseId = await client.getOption("XtkDatabaseId");
+            expect(databaseId).toBe("uFE80000000000000F1FA913DD7CC7C480041161C");
+            expect(extAccountSchema.name).toBe("extAccount");
+            
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+
+        it("Should allow to rewrite method call parameters", async () => {
+            const [client, assertion] = await makeObservableClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            const observer = { beforeSoapCall: jest.fn(), afterSoapCall: jest.fn() };
+            client.registerObserver(observer);
+
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            const getOption = (options) => {
+                // SOAP request contains the option name as <name xsi:type="xsd:string">Dummy</name>
+                const index = options.data.indexOf('<name xsi:type="xsd:string">');
+                const index2 = options.data.indexOf('</name>', index);
+                const name = options.data.substring(index + 28, index2);
+                // Option value is the option name followed by a "ZZ"
+                return 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'>${name}ZZ</pstrValue>
+            <pbtType xsi:type='xsd:byte'>6</pbtType>
+        </GetOptionResponse>
+    </SOAP-ENV:Body>
+    </SOAP-ENV:Envelope>`);
+            };
+            client._transport.mockImplementationOnce(getOption);
+            client.clearOptionCache();
+            var value = await client.getOption("Dummy");
+            expect(value).toBe("DummyZZ");
+
+            jest.clearAllMocks();
+            observer.beforeSoapCall.mockImplementationOnce(async (method, inputParameters, representation) => {
+                if (inputParameters[0].value === "Dummy") inputParameters[0].value = "XtkDatabaseId";
+            });
+            client._transport.mockImplementationOnce(getOption);
+            client.clearOptionCache();
+            var value = await client.getOption("Dummy");
+            expect(value).toBe("XtkDatabaseIdZZ");
+            
+            // Only one call is intercepted: xtk:session#GetOption. The internal call to get the xtk:session schema is internal
+            // and hence not interceptable
+            expect(observer.beforeSoapCall).toHaveBeenCalledTimes(1);
+            expect(observer.beforeSoapCall.mock.calls[0]).toEqual([ { urn:"xtk:session", name: "GetOption" }, [ { name:"name", type:"string", value:"XtkDatabaseId" } ], "SimpleJson" ]);
+            expect(observer.afterSoapCall).toHaveBeenCalledTimes(1);
+            expect(observer.afterSoapCall.mock.calls[0]).toEqual([ { urn:"xtk:session", name: "GetOption" }, [ { name:"name", type:"string", value:"XtkDatabaseId" } ], "SimpleJson", [ { name:"value", type:"string", value:"XtkDatabaseIdZZ" }, { name:"type", type:"byte", value:6 }] ]);
+
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+
+        it("Should allow to rewrite method return parameters", async () => {
+            const [client, assertion] = await makeObservableClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            const observer = { beforeSoapCall: jest.fn(), afterSoapCall: jest.fn() };
+            client.registerObserver(observer);
+
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_DATABASEID_RESPONSE);
+
+            observer.afterSoapCall.mockImplementationOnce(async (method, inputParameters, representation, outputParameters) => {
+                outputParameters[0].value = "Patched";
+            });
+            var value = await client.getOption("XtkDatabaseId");
+            expect(value).toBe("Patched");
+            
+            // Only one call is intercepted: xtk:session#GetOption. The internal call to get the xtk:session schema is internal
+            // and hence not interceptable
+            expect(observer.beforeSoapCall).toHaveBeenCalledTimes(1);
+            expect(observer.beforeSoapCall.mock.calls[0]).toEqual([ { urn:"xtk:session", name: "GetOption" }, [ { name:"name", type:"string", value:"XtkDatabaseId" } ], "SimpleJson" ]);
+            expect(observer.afterSoapCall).toHaveBeenCalledTimes(1);
+            
+            expect(observer.afterSoapCall.mock.calls[0]).toEqual([ { urn:"xtk:session", name: "GetOption" }, [ { name:"name", type:"string", value:"XtkDatabaseId" } ], "SimpleJson", [ { name:"value", type:"string", value:"Patched" }, { name:"type", type:"byte", value:6 }] ]);
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+
+        it("Should not intercept internal calls", async () => {
+            const [client, assertion] = await makeObservableClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            const observer = { beforeSoapCall: jest.fn(), afterSoapCall: jest.fn() };
+            client.registerObserver(observer);
+
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            var schema = await client.getEntityIfMoreRecent("xtk:schema", "xtk:session", undefined, true);
+            expect(schema.name).toBe("session");
+            expect(observer.beforeSoapCall).not.toHaveBeenCalled();
+            expect(observer.afterSoapCall).not.toHaveBeenCalled();
+
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+            schema = await client.getEntityIfMoreRecent("xtk:schema", "xtk:session", undefined, false);
+            expect(schema.name).toBe("session");
+            expect(observer.beforeSoapCall).toHaveBeenCalledTimes(1);
+            expect(observer.afterSoapCall).toHaveBeenCalledTimes(1);
+
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+    });
 });
 

package/test/soap.test.js

@@ -734,7 +734,7 @@ describe('SOAP', function() {
             const client = await sdk.init(connectionParameters);
             client._transport = jest.fn();
             expect(client._connectionParameters._options.charset).toBe('UTF-8');
-            const soapCall = client._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", true);
+            const soapCall = client._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", true, true);
             expect (soapCall._charset).toBe('UTF-8');
             const [ request ] = soapCall._createHTTPRequest(URL);
             assert.equal(request.headers["Content-type"], "application/soap+xml;charset=UTF-8");
@@ -745,7 +745,7 @@ describe('SOAP', function() {
             const client = await sdk.init(connectionParameters);
             client._transport = jest.fn();
             expect(client._connectionParameters._options.charset).toBe('');
-            const soapCall = client._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", true);
+            const soapCall = client._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", true, true);
             expect (soapCall._charset).toBe('');
             const [ request ] = soapCall._createHTTPRequest(URL);
             assert.equal(request.headers["Content-type"], "application/soap+xml");
@@ -756,7 +756,7 @@ describe('SOAP', function() {
             const client = await sdk.init(connectionParameters);
             client._transport = jest.fn();
             expect(client._connectionParameters._options.charset).toBe('ISO-8859-1');
-            const soapCall = client._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", true);
+            const soapCall = client._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", true, true);
             expect (soapCall._charset).toBe('ISO-8859-1');
             const [ request ] = soapCall._createHTTPRequest(URL);
             assert.equal(request.headers["Content-type"], "application/soap+xml;charset=ISO-8859-1");
@@ -901,7 +901,7 @@ describe("Campaign exception", () => {
         it("Should add the method name by default in the URL", () => {
             const call = makeSoapMethodCall(undefined, "xtk:session", "Empty", "$session$", "$security$");
             call.finalize(URL);
-            expect(call.request.url).toBe("https://soap-test/nl/jsp/soaprouter.jsp?xtk:session:Empty");
+            expect(call.request.url).toBe("https://soap-test/nl/jsp/soaprouter.jsp?soapAction=xtk%3Asession%23Empty");
         });
 
         it("Should be able to disable adding the method name by default in the URL", () => {