@adobe/acc-js-sdk 1.1.5 → 1.1.6

package/test/cacheRefresher.test.js

@@ -0,0 +1,338 @@
+/*
+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.
+*/
+
+
+/**********************************************************************************
+ * 
+ * Unit tests for the cache refresher
+ * 
+ *********************************************************************************/
+
+
+const sdk = require('../src/index.js');
+const { Cache } = require('../src/cache.js');
+const Mock = require('./mock.js').Mock;
+const CacheRefresher = require('../src/cacheRefresher.js').CacheRefresher;
+
+
+describe("CacheRefresher cache", function () {
+
+    it('Should call refresh', async () => {
+        const client =  await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
+        await cacheRefresher._callAndRefresh();
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
+        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
+        await cacheRefresher._callAndRefresh();
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
+        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+
+    it('Should call refresh after 1 seconds', async () => {
+        const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin");
+        const client = await sdk.init(connectionParameters);
+        client._transport = jest.fn();
+
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        expect(client.isLogged()).toBeTruthy();
+        const cache = new Cache();
+
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBeUndefined();
+        expect(cacheRefresher._refresherStateCache.get("time")).toBeUndefined();
+        client._transport.mockReturnValue(Promise.resolve(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE));
+        jest.useFakeTimers();
+        cacheRefresher.startAutoRefresh(5000);
+        jest.advanceTimersByTime(6000);
+        jest.useRealTimers();
+        
+        // to allow soap call to finish
+        await new Promise(process.nextTick);
+
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
+        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+
+        cacheRefresher.stopAutoRefresh();
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+
+    it('Should send buildNumber when call refresh', async () => {
+        const client = await Mock.makeClient();
+        const logs = await Mock.withMockConsole(async () => {
+            client.traceAPICalls(true);
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+            await client.NLWS.xtkSession.logon();
+
+            const cache = new Cache();
+
+            const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+            cacheRefresher._refresherStateCache.put("buildNumber", "9469");
+            cacheRefresher._refresherStateCache.put("time", "2022-07-28T14:38:55.766Z");
+
+            client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
+            await cacheRefresher._callAndRefresh();
+            expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
+            expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+
+
+            await client.NLWS.xtkSession.logoff();
+
+        })
+        expect(logs.length).toBe(6);
+        expect(logs[0]).toMatch(/SOAP.*request.*Logon/is)
+        expect(logs[1]).toMatch(/SOAP.*response.*LogonResponse/is)
+        expect(logs[2]).toMatch(/SOAP.*request.*buildNumber.*9469.*2022-07-28T14:38:55.766Z.*GetModifiedEntities*/is)
+        expect(logs[3]).toMatch(/SOAP.*response.*GetModifiedEntitiesResponse/is)
+        expect(logs[4]).toMatch(/SOAP.*request.*Logoff/is)
+        expect(logs[5]).toMatch(/SOAP.*response.*LogoffResponse/is)
+    });
+
+    it('Should refresh cache', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        cache.put("xtk:schema|nms:recipient", "<content recipient>");
+        cache.put("xtk:schema|nms:replicationStrategy", "<content xtk:schema|nms:replicationStrategy>");
+        cache.put("xtk:schema|nms:operation", "<content xtk:schema|nms:operation>");
+        expect(cache.get("xtk:schema|nms:recipient")).toBe("<content recipient>");
+        expect(cache.get("xtk:schema|nms:replicationStrategy")).toBe("<content xtk:schema|nms:replicationStrategy>");
+        expect(cache.get("xtk:schema|nms:operation")).toBe("<content xtk:schema|nms:operation>");
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_SCHEMA_RESPONSE);
+        await cacheRefresher._callAndRefresh();
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
+        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T15:32:00.785Z");
+        expect(cache.get("xtk:schema|nms:recipient")).toBeUndefined();
+        expect(cache.get("xtk:schema|nms:replicationStrategy")).toBeUndefined();
+        expect(cache.get("xtk:schema|nms:operation")).toBe("<content xtk:schema|nms:operation>");
+
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+
+    it('Should stop refresh if method not exist', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        cacheRefresher.startAutoRefresh();
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_UNDEFINED_RESPONSE);
+        await cacheRefresher._callAndRefresh();
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBeUndefined();
+        expect(cacheRefresher._refresherStateCache.get("time")).toBeUndefined();
+        expect(cacheRefresher._intervalId).toBeNull();
+
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+
+    it('Should not stop refresh if error different from undefined', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        cacheRefresher.startAutoRefresh();
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_ERROR_RESPONSE);
+        try {
+            await cacheRefresher._callAndRefresh();
+            fail('exception is expected');
+        } catch (e) {
+            expect(e).not.toBeNull();
+        }
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBeUndefined();
+        expect(cacheRefresher._refresherStateCache.get("time")).toBeUndefined();
+        expect(cacheRefresher._intervalId).not.toBeNull();
+
+        cacheRefresher.stopAutoRefresh();
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+
+    it('Should be able to call start refresh twice', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        jest.useFakeTimers();
+        cacheRefresher.startAutoRefresh(100000);
+        expect(cacheRefresher._intervalId).not.toBeNull();
+        const firstIntervalId = cacheRefresher._intervalId;
+        cacheRefresher.startAutoRefresh(5000);
+        expect(cacheRefresher._intervalId).not.toBeNull();
+        expect(cacheRefresher._intervalId != firstIntervalId);
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
+        
+        jest.advanceTimersByTime(6000);
+        jest.useRealTimers();
+
+        // to allow soap call to finish
+        await new Promise(process.nextTick);
+
+        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
+        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+
+        cacheRefresher.stopAutoRefresh();
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+
+    it('Should notify when refresh cache', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+
+        class Listener {
+            constructor() {
+                this._schemas = {};
+            }
+            add(schemaId) {
+                this._schemas[schemaId] = "1";
+            }
+
+            invalidateCacheItem(schemaId) {
+                this._schemas[schemaId] = undefined;
+            }
+            getSchema(schemaId) {
+                return this._schemas[schemaId];
+            }
+        }
+
+        let listener = new Listener();
+        client._registerCacheChangeListener(listener);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        cache.put("xtk:schema|nms:recipient", "<content recipient>");
+        cache.put("xtk:schema|nms:replicationStrategy", "<content xtk:schema|nms:replicationStrategy>");
+        cache.put("xtk:schema|nms:operation", "<content xtk:schema|nms:operation>");
+
+        listener.add("nms:recipient");
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_SCHEMA_RESPONSE);
+        await cacheRefresher._callAndRefresh();
+
+        expect(listener.getSchema("nms:recipient")).toBeUndefined();
+
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+        client._unregisterCacheChangeListener(listener);
+    });
+
+    it('Should protect callAndRefresh from re-entrance', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+        let count = 0;
+        cacheRefresher._callAndRefresh = jest.fn(() => { count = count + 1 });
+        expect(cacheRefresher._running).toBe(false);
+        await cacheRefresher._callAndRefresh();
+        expect(count).toBe(1);
+        expect(cacheRefresher._running).toBe(false);
+        await cacheRefresher._safeCallAndRefresh();
+        expect(count).toBe(2);
+        expect(cacheRefresher._running).toBe(false);
+
+        cacheRefresher._running = true;
+        await cacheRefresher._safeCallAndRefresh();
+        expect(count).toBe(2); // should not have been called since already executing
+    })
+
+    it('Throw CampaignException when calling _callAndRefresh without logon', async () => {
+        const client = await Mock.makeClient();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        try {
+            await cacheRefresher._callAndRefresh();
+             fail('exception is expected');
+         } catch (e) {
+             expect(e.name).toBe("CampaignException");
+             expect(e.errorCode).toBe("SDK-000010");
+         }
+    });
+
+    it('Ignore error when calling _safeCallAndRefresh without logon', async () => {
+        const client = await Mock.makeClient();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        try {
+            await cacheRefresher._safeCallAndRefresh();
+        } catch (e) {
+            fail('exception is not expected');
+         }
+    });
+
+    it('Catch error in soap call GetModifiedEntities and display a warning', async () => {
+        const client = await Mock.makeClient();
+        client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+        await client.NLWS.xtkSession.logon();
+        const cache = new Cache();
+        const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
+
+        client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_ERROR_RESPONSE);
+        try {
+          jest.useFakeTimers();
+          cacheRefresher.startAutoRefresh(5000);
+          jest.advanceTimersByTime(6000);
+          jest.useRealTimers();
+
+          // to allow soap call to finish
+          await new Promise(process.nextTick);
+        } catch (e) {
+            fail('exception is not expected');
+        }
+
+        cacheRefresher.stopAutoRefresh();
+        client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+        await client.NLWS.xtkSession.logoff();
+    });
+});

package/test/caches.test.js

@@ -54,7 +54,22 @@ describe('Caches', function() {
             cache.clear();
             expect(cache.get("Hello")).toBeUndefined();
         })
-    })
+
+        it("Should remove key in cache", () => {
+            const cache = new Cache();
+            cache.put("Hello", "World");
+            cache.put("Hi", "A");
+            expect(cache.get("Hello")).toBe("World");
+            expect(cache.get("Hi")).toBe("A");
+            cache.remove("Hello");
+            expect(cache.get("Hello")).toBeUndefined();
+            expect(cache.get("Hi")).toBe("A");
+            // should support removing a key which has already been removed
+            cache.remove("Hello");
+            expect(cache.get("Hello")).toBeUndefined();
+            expect(cache.get("Hi")).toBe("A");
+        })
+    });
 
     describe("Entity cache", function() {
         it("Should cache value", function() {

package/test/client.test.js

@@ -64,10 +64,10 @@ describe('ACC Client', function () {
 
         it('Should logon and logoff with traces', async () => {
             const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
             const logs = await Mock.withMockConsole(async () => {
                 client.traceAPICalls(true);
-                client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
-                client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
                 await client.NLWS.xtkSession.logon();
                 expect(client.isLogged()).toBe(true);
                 var sessionInfoXml = client.getSessionInfo("xml");
@@ -2242,6 +2242,8 @@ describe('ACC Client', function () {
             }
             const client = await Mock.makeClient({ storage: storage });
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_RESPONSE);
             client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
             await client.NLWS.xtkSession.logon();
             storage.getItem.mockReturnValueOnce(JSON.stringify({value: { value: "Hello", type: 6 }, cachedAt: 1633715996021 }));
@@ -2351,6 +2353,140 @@ describe('ACC Client', function () {
             expect(schema["namespace"]).toBe("nms");
             expect(schema["name"]).toBe("extAccount");
         });
+
+        it("Should get schema from the cache", async () => {
+            const client = await Mock.makeClient();
+            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");
+
+            client._transport.mockReturnValue(Promise.resolve(Mock.GETMODIFIEDENTITIES_RESPONSE));
+
+            jest.useFakeTimers();
+            client.startRefreshCaches(5000); // autorefresh every 5000 ms
+            jest.advanceTimersByTime(6000);
+            jest.useRealTimers();
+
+            schema = await client.getSchema("nms:extAccount");
+            expect(schema["namespace"]).toBe("nms");
+            expect(schema["name"]).toBe("extAccount");
+
+            client.stopRefreshCaches();
+        });
+
+        it("Should get schema from server when removed from cache", async () => {
+            const client = await Mock.makeClient();
+            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");
+
+            client._transport.mockReturnValueOnce(Promise.resolve(Mock.GETMODIFIEDENTITIES_SCHEMA_RESPONSE));
+            client._transport.mockReturnValueOnce(Promise.resolve(Mock.GETMODIFIEDENTITIES_SCHEMA_RESPONSE));
+
+            client._transport.mockReturnValue(Promise.resolve(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE));
+            jest.useFakeTimers();
+            client.startRefreshCaches(5000); // autorefresh every 5000 ms
+            jest.advanceTimersByTime(6000);
+            jest.useRealTimers();
+
+            schema = await client.getSchema("nms:extAccount");
+            expect(schema["namespace"]).toBe("nms");
+            expect(schema["name"]).toBe("extAccount");
+            client.stopRefreshCaches();
+        });
+
+        it("Should stop refresh", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            jest.useFakeTimers();
+            client.startRefreshCaches();
+            jest.advanceTimersByTime(6000); // autorefresh for xtk:schema should be started after 5000 ms
+            jest.useRealTimers();
+            expect(client._optionCacheRefresher._intervalId).not.toBeNull();
+            expect(client._entityCacheRefresher._intervalId).not.toBeNull();
+            client.stopRefreshCaches();
+            expect(client._optionCacheRefresher._intervalId).toBeNull();
+            expect(client._entityCacheRefresher._intervalId).toBeNull();
+        });
+
+        it("Should stop refresh when logoff", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            jest.useFakeTimers();
+            client.startRefreshCaches();
+            jest.advanceTimersByTime(6000); // autorefresh for xtk:schema should be started after 5000 ms
+            jest.useRealTimers();
+            expect(client._optionCacheRefresher._intervalId).not.toBeNull();
+            expect(client._entityCacheRefresher._intervalId).not.toBeNull();
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.logoff();
+            expect(client._optionCacheRefresher._intervalId).toBeNull();
+            expect(client._entityCacheRefresher._intervalId).toBeNull();
+        });
+
+        it("Expired session and refresh cache", async () => {
+            let refreshClient = async () => {
+                const connectionParameters = sdk.ConnectionParameters.ofSecurityToken("http://acc-sdk:8080",
+                                                        "$security_token$", {refreshClient: refreshClient});
+                const newClient = await sdk.init(connectionParameters);
+                newClient._transport = jest.fn();
+                newClient._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+                await newClient.logon();
+                return newClient;
+            }
+            const connectionParameters = sdk.ConnectionParameters.ofBearerToken("http://acc-sdk:8080", 
+                                                    "$token$", {refreshClient: refreshClient});
+            const client = await sdk.init(connectionParameters);
+            jest.useFakeTimers();
+            client.startRefreshCaches();
+            client._entityCacheRefresher._safeCallAndRefresh = jest.fn();
+            client._optionCacheRefresher._safeCallAndRefresh = jest.fn();
+            jest.advanceTimersByTime(18000);
+            expect(client._entityCacheRefresher._safeCallAndRefresh.mock.calls.length).toBe(1);
+            expect(client._optionCacheRefresher._safeCallAndRefresh.mock.calls.length).toBe(1);
+            client.traceAPICalls(true);
+            client._transport = jest.fn();
+            client._transport.mockReturnValueOnce(Mock.BEARER_LOGON_RESPONSE);
+            client._transport.mockReturnValueOnce(Promise.resolve(`XSV-350008 Session has expired or is invalid. Please reconnect.`));
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            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>`));
+            await client.logon();
+            var queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            var query = client.NLWS.xtkQueryDef.create(queryDef);
+            var extAccount = await query.executeQuery();
+            expect(extAccount).toEqual({ extAccount: [] });
+            jest.advanceTimersByTime(10000);
+            expect(client._entityCacheRefresher._safeCallAndRefresh.mock.calls.length).toBe(2);
+            expect(client._optionCacheRefresher._safeCallAndRefresh.mock.calls.length).toBe(2);
+            jest.useRealTimers();
+        });
     });
 
     describe("Calling SOAP method with parameters as a function", () => {
@@ -2826,7 +2962,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?xtk:queryDef:ExecuteQuery");
             expect(lastCall[1].charset).toBe("UTF-8");
             expect(lastCall[1].foo).toBe("bar");
         });
@@ -2851,7 +2987,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?xtk:queryDef:ExecuteQuery");
             expect(lastCall[1].charset).toBe("UTF-8");
             expect(lastCall[1].foo).toBe("bar");
             expect(lastCall[1].cnxDefault).toBe(3);
@@ -2878,11 +3014,101 @@ 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?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);
         });
     });
+    describe("Schema cache refresh", () => {
+        it("Should unregister listener", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            class Listener {
+                constructor() {
+                    this._schemas = {};
+                }
+
+                invalidateCacheItem(schemaId) {
+                    this._schemas[schemaId] = undefined;
+                }
+            }
+
+            client._unregisterAllCacheChangeListeners();
+            expect(client._cacheChangeListeners.length).toBe(0);
+            const listener = new Listener();
+
+            client._registerCacheChangeListener(listener);
+            expect(client._cacheChangeListeners.length).toBe(1);
+            client._unregisterCacheChangeListener(listener);
+            expect(client._cacheChangeListeners.length).toBe(0);
+        });
+
+        it("Should not unregister unknown listener", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            class Listener {
+                constructor() {
+                    this._schemas = {};
+                }
+
+                invalidateCacheItem(schemaId) {
+                    this._schemas[schemaId] = undefined;
+                }
+            }
+
+            client._unregisterAllCacheChangeListeners();
+            expect(client._cacheChangeListeners.length).toBe(0);
+            const listener = new Listener();
+
+            client._registerCacheChangeListener(listener);
+            expect(client._cacheChangeListeners.length).toBe(1);
+
+            const listener2 = new Listener();
+
+            client._unregisterCacheChangeListener(listener2);
+            expect(client._cacheChangeListeners.length).toBe(1);
+            client._unregisterAllCacheChangeListeners();
+        });
+
+        it("Should be notify when register", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            class Listener {
+                constructor() {
+                    this._schemas = {};
+                }
+                add(schemaId) {
+                    this._schemas[schemaId] = "1";
+                }
+
+                invalidateCacheItem(schemaId) {
+                    this._schemas[schemaId] = undefined;
+                }
+                getSchema(schemaId) {
+                    return this._schemas[schemaId];
+                }
+            }
+
+            client._unregisterAllCacheChangeListeners();
+            
+            const listener = new Listener();
+            listener.add("nms:recipient");
+            listener.add("xtk:operator");
+
+            client._registerCacheChangeListener(listener);
+            client._notifyCacheChangeListeners("nms:recipient");
+            expect(listener.getSchema("nms:recipient")).toBeUndefined();
+            expect(listener.getSchema("xtk:operator")).toBe("1");
+
+            client._unregisterCacheChangeListener(listener);
+        });
+    });
 });