@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.core/test/sap/fe/core/jest/services/CacheHandlerTest.spec.js

@@ -0,0 +1,871 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/services/CacheHandlerServiceFactory", "sap/ui/core/cache/CacheManager", "sap/ui/Device"], function (CacheHandlerServiceFactory, Cache, Device) {
+  "use strict";
+
+  // Override to make the CacheManager works for some tests
+  Device.browser.name = "cr";
+  Device.browser.version = 80;
+  describe("CacheHandlerFactory", function () {
+    var oFakeMetaModel = {
+      fetchEntityContainer: function () {
+        return Promise.resolve();
+      },
+      getId: function () {
+        return "fakeModelId";
+      }
+    };
+    var oFakeComponent = {
+      getViewData: function () {
+        return {
+          dummySetting: "dummy"
+        };
+      }
+    };
+    var oFakeAppComponent = {
+      getManifest: function () {
+        return {
+          "sap.app": {
+            dummySetting: "dummy"
+          }
+        };
+      }
+    };
+    test("can be initialized", function () {
+      expect(CacheHandlerServiceFactory).not.toEqual(null); // "Library has been loaded");
+
+      var oTestFactory = new CacheHandlerServiceFactory();
+      expect(oTestFactory).not.toEqual(null);
+    });
+    var oFactory;
+    describe("CacheHandler instance creation", function () {
+      beforeEach(function () {
+        oFactory = new CacheHandlerServiceFactory();
+      });
+      test("cannot be initialized without a metamodel", function () {
+        var createFn = function () {
+          return oFactory.createInstance({
+            settings: {}
+          });
+        };
+
+        expect(createFn).toThrow();
+      });
+      test("cannot be initialized with a failing metamodel", function () {
+        try {
+          var oOriginFn = oFakeMetaModel.fetchEntityContainer;
+
+          oFakeMetaModel.fetchEntityContainer = function () {
+            return Promise.reject("Nope");
+          };
+
+          var oInstance = oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          });
+          expect(oInstance).toBeDefined();
+          return oInstance.then(function (oInstanceLoaded) {
+            expect(true).toBe(false);
+          }).catch(function () {
+            oFakeMetaModel.fetchEntityContainer = oOriginFn;
+          });
+        } catch (e) {
+          expect(true).toBe(false);
+        }
+      });
+      test("is initialized as a global instance", function () {
+        var oCurrentInstance;
+        var sFakeMetaModelId = oFakeMetaModel.getId();
+        var oFetchEntityContainerSpy = jest.spyOn(oFakeMetaModel, "fetchEntityContainer");
+        expect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toBe(undefined); //, "No global instance exists");
+
+        var oInstance = oFactory.createInstance({
+          settings: {
+            metaModel: oFakeMetaModel,
+            component: oFakeComponent,
+            appComponent: oFakeAppComponent
+          }
+        });
+        expect(oInstance).toBeDefined(); // "Instance promise is created");
+
+        expect(oFetchEntityContainerSpy).toHaveBeenCalledTimes(1);
+        return oInstance.then(function (oInstanceLoaded) {
+          oCurrentInstance = oInstanceLoaded;
+          expect(oInstanceLoaded).toBeDefined(); //assert.ok(oInstanceLoaded != null, "Instance promise is resolved");
+
+          expect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toBeDefined(); // "Global instance exists");
+
+          var oNewInstance = oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }); // Init should not have been called again since the instance is global to the factory
+
+          expect(oFetchEntityContainerSpy).toHaveBeenCalledTimes(1);
+          return oNewInstance;
+        }).then(function (oNewInstanceLoaded) {
+          expect(oNewInstanceLoaded).toEqual(oCurrentInstance); //, "Both instance are the same");
+
+          return oFactory.getInstance(oFakeMetaModel);
+        }).then(function (oGlobalInstance) {
+          expect(oCurrentInstance).toEqual(oGlobalInstance); //, "Retrieving the global instance returns the same");
+
+          oCurrentInstance.exit();
+          expect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toEqual(null); // "Global instance is removed");
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          });
+        }).then(function (oThirdInstanceLoaded) {
+          expect(oThirdInstanceLoaded).toBeDefined(); // != null, "Third instance can be created");
+        });
+      });
+      describe("CacheHandler checks", function () {
+        beforeEach(function () {
+          return Cache.del("myCacheKey");
+        });
+        test("Case #1a- can validate a basic cache key", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag"
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              expect(sValidatedKey).toBeDefined(); // "ValidatedKey exists"
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","manifest":-1335850414}'); //, "ValidatedKey is correct");
+            });
+          });
+        });
+        test("Case #1a - can validate a date based cache key", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": new Date("2019-08-31")
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); // "ValidatedKey is correct"
+            });
+          });
+        });
+        test("Case #1-b cannot validate a cache key if no metadata include ETags", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": null
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              expect(sValidatedKey).toEqual(null); //.toBeDefined(); // == null, "Validated key is null");
+            });
+          });
+        });
+        test("Case #1-b cannot validate a cache key if one metadata does not include ETags", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": null
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              expect(sValidatedKey).toEqual(null); // == null, "Validated key is null");
+            });
+          });
+        }); //if ((Device as any).browser.msie || (Device as any).browser.chrome) {
+
+        test("Case #2a - can validate a basic cache key and revalidate if the ETags have not changed", function () {
+          var oCacheManagerSpy = jest.spyOn(Cache, "set");
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+
+              expect(oCacheManagerSpy).not.toHaveBeenCalled();
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey");
+            }).then(function (sSecondValidatedKey) {
+              expect(oCacheManagerSpy).toHaveBeenCalledTimes(1);
+              expect(sSecondValidatedKey).toEqual(sFirstCacheKey); // "Validated Key is the same as the second validated key");
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sSecondValidatedKey, "myCacheKey");
+            }).then(function () {
+              expect(oCacheManagerSpy).toHaveBeenCalledTimes(1);
+              oCacheManagerSpy.mockRestore();
+            }).catch(function () {
+              oCacheManagerSpy.mockRestore();
+            });
+          });
+        });
+        test("Case #2b - can deal with an ETag enhancement in a given session", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+              // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": "Yolo"
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).toEqual(sFirstCacheKey); //"Validated Key is the same as the second validated key"
+              });
+            });
+          });
+        });
+        test("Case #2b + 2z - will request ETag that were added and which are now missing", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey; // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": "Yolo"
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31")
+                };
+              };
+
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // "Validated Key is not the same as the second validated key"
+
+                expect(sSecondValidatedKey).toEqual(null); // == null, "No more cache");
+              });
+            });
+          });
+        });
+        test("Case #2b + 2a - will request ETag that were added and which are the same", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          var jQueryAjaxStub = function () {
+            var fnDoneCb;
+            setTimeout(function () {
+              fnDoneCb(null, null, {
+                getResponseHeader: function (param) {
+                  if (param === "ETag") {
+                    return "Yolo";
+                  }
+                }
+              });
+            }, 100);
+            return {
+              done: function (doneCb) {
+                fnDoneCb = doneCb;
+                return {
+                  fail: function () {}
+                };
+              }
+            };
+          };
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          var origAjax = jQuery.ajax;
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey; // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": "Yolo"
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31")
+                };
+              }; // @ts-ignore
+
+
+              jQuery.ajax = jQueryAjaxStub;
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey");
+            }).then(function (sSecondValidatedKey) {
+              expect(sSecondValidatedKey).toEqual(sFirstCacheKey); // "Validated Key is the same as the second validated key " + sSecondValidatedKey
+
+              jQuery.ajax = origAjax;
+            }).catch(function () {
+              jQuery.ajax = origAjax;
+            });
+          });
+        });
+        test("Case #2b + 2a - will request ETag that were added and which are the same - Date version", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          var jQueryAjaxStub = function () {
+            var fnDoneCb;
+            setTimeout(function () {
+              fnDoneCb(null, null, {
+                getResponseHeader: function (param) {
+                  if (param === "Last-Modified") {
+                    return "2019-08-29T00:00:00.000Z";
+                  }
+                }
+              });
+            }, 100);
+            return {
+              done: function (doneCb) {
+                fnDoneCb = doneCb;
+                return {
+                  fail: function () {}
+                };
+              }
+            };
+          };
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          var origAjax = jQuery.ajax;
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey; // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": new Date("2019-08-29")
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31")
+                };
+              }; // @ts-ignore
+
+
+              jQuery.ajax = jQueryAjaxStub;
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey");
+            }).then(function (sSecondValidatedKey) {
+              expect(sSecondValidatedKey).toEqual(sFirstCacheKey); //"Validated Key is the same as the second validated key " + sSecondValidatedKey
+
+              jQuery.ajax = origAjax;
+            }).catch(function () {
+              jQuery.ajax = origAjax;
+            });
+          });
+        });
+        test("Case #2b + 2d - will request ETag that were added and which are different", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          var jQueryAjaxStub = function () {
+            var fnDoneCb;
+            setTimeout(function () {
+              fnDoneCb(null, null, {
+                getResponseHeader: function (param) {
+                  if (param === "ETag") {
+                    return "NotYolo";
+                  }
+                }
+              });
+            }, 100);
+            return {
+              done: function (doneCb) {
+                fnDoneCb = doneCb;
+                return {
+                  fail: function () {}
+                };
+              }
+            };
+          };
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          var origAjax = jQuery.ajax;
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey; // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": "Yolo"
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31")
+                };
+              }; // @ts-ignore
+
+
+              jQuery.ajax = jQueryAjaxStub;
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey");
+            }).then(function (sSecondValidatedKey) {
+              expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //"Validated Key is the same as the second validated key " + sSecondValidatedKey
+
+              expect(sSecondValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414,"myThirdService":"NotYolo"}'); //"Validated Key is correct"
+
+              jQuery.ajax = origAjax;
+            }).catch(function (fDone) {
+              jQuery.ajax = origAjax;
+            });
+          });
+        });
+        test("Case #2b + 2d - will request ETag that were added and which are different - Date version", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          var jQueryAjaxStub = function () {
+            var fnDoneCb;
+            setTimeout(function () {
+              fnDoneCb(null, null, {
+                getResponseHeader: function (param) {
+                  if (param === "Last-Modified") {
+                    return "2019-08-28T00:00:00.000Z";
+                  }
+                }
+              });
+            }, 100);
+            return {
+              done: function (doneCb) {
+                fnDoneCb = doneCb;
+                return {
+                  fail: function () {}
+                };
+              }
+            };
+          };
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          var origAjax = jQuery.ajax;
+          oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey; // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": new Date("2019-08-29")
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31")
+                };
+              }; // @ts-ignore
+
+
+              jQuery.ajax = jQueryAjaxStub;
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey");
+            }).then(function (sSecondValidatedKey) {
+              expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //"Validated Key is the same as the second validated key " + sSecondValidatedKey
+
+              expect(sSecondValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414,"myThirdService":"2019-08-28T00:00:00.000Z"}'); //"Validated Key is correct"
+
+              jQuery.ajax = origAjax;
+            }).catch(function (fDone) {
+              jQuery.ajax = origAjax;
+            });
+          });
+        });
+        test("Case #2c - can deal with an ETag change", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              // Simulate ETag change
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "NotMyETag",
+                  "myOtherService": new Date("2019-08-31")
+                };
+              };
+
+              oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // "Validated Key is the not the same as the second validated key"
+
+                expect(sSecondValidatedKey).toEqual('{"myRootService":"NotMyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+              });
+            });
+          });
+        });
+        test("Case #2d - can deal with an ETag enhancement and a change", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+              // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": "Yolo"
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-30"),
+                  "myThirdService": "Yolo"
+                };
+              };
+
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //"Validated Key is not the same as the second validated key"
+
+                expect(sSecondValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-30T00:00:00.000Z","myThirdService":"Yolo","manifest":-1335850414}'); //"ValidatedKey is correct " + sSecondValidatedKe
+              });
+            });
+          });
+        });
+        test("Case #2z - can deal with an invalid ETag enhancement", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+              // Simulate model enhancement
+
+              oFakeMetaModel.getETags = function () {
+                return {
+                  "myRootService": "MyETag",
+                  "myOtherService": new Date("2019-08-31"),
+                  "myThirdService": null
+                };
+              };
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // "Validated Key is not the same as the second validated key"
+
+                expect(sSecondValidatedKey).toEqual(null); //, "ValidatedKey is null since it doesn't have an ETag");
+              });
+            });
+          });
+        });
+        test("Case #xx - can deal with an error thrown while validating the cache", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); // != null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              // Simulate error
+              oFakeMetaModel.getETags = function () {
+                throw new Error("nope");
+              };
+
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // "Validated Key is not the same as the second validated key"
+
+                expect(sSecondValidatedKey).toEqual(null); //, "ValidatedKey is null since it doesn't have an ETag");
+              });
+            });
+          });
+        });
+        test("Case #3 - can deal with a Manifest change", function () {
+          var oFactory = new CacheHandlerServiceFactory();
+
+          oFakeMetaModel.getETags = function () {
+            return {
+              "myRootService": "MyETag",
+              "myOtherService": new Date("2019-08-31")
+            };
+          };
+
+          return oFactory.createInstance({
+            settings: {
+              metaModel: oFakeMetaModel,
+              component: oFakeComponent,
+              appComponent: oFakeAppComponent
+            }
+          }).then(function (oCacheHandlerInstance) {
+            var sFirstCacheKey;
+            return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sValidatedKey) {
+              sFirstCacheKey = sValidatedKey;
+              expect(sValidatedKey).toBeDefined(); //null, "ValidatedKey exists");
+
+              expect(sValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1335850414}'); //"ValidatedKey is correct "
+
+              return oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, "myCacheKey");
+            }).then(function () {
+              // Simulate Manifest Change
+              oFakeAppComponent.getManifest = function () {
+                return {
+                  "sap.app": {
+                    dummySetting: "Changed"
+                  }
+                };
+              };
+
+              return oCacheHandlerInstance.validateCacheKey("myCacheKey").then(function (sSecondValidatedKey) {
+                expect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //"Validated Key is the not the same as the second validated key"
+
+                expect(sSecondValidatedKey).toEqual('{"myRootService":"MyETag","myOtherService":"2019-08-31T00:00:00.000Z","manifest":-1956011802}'); //"ValidatedKey is correct "
+              });
+            });
+          });
+        }); //}
+      });
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CacheHandlerTest.spec.ts"],"names":["Device","browser","name","version","describe","oFakeMetaModel","fetchEntityContainer","Promise","resolve","getId","oFakeComponent","getViewData","dummySetting","oFakeAppComponent","getManifest","test","expect","CacheHandlerServiceFactory","not","toEqual","oTestFactory","oFactory","beforeEach","createFn","createInstance","settings","toThrow","oOriginFn","reject","oInstance","metaModel","component","appComponent","toBeDefined","then","oInstanceLoaded","toBe","catch","e","oCurrentInstance","sFakeMetaModelId","oFetchEntityContainerSpy","jest","spyOn","_oInstanceRegistry","undefined","toHaveBeenCalledTimes","oNewInstance","oNewInstanceLoaded","getInstance","oGlobalInstance","exit","oThirdInstanceLoaded","Cache","del","getETags","oCacheHandlerInstance","validateCacheKey","sValidatedKey","Date","oCacheManagerSpy","sFirstCacheKey","toHaveBeenCalled","invalidateIfNeeded","sSecondValidatedKey","mockRestore","jQueryAjaxStub","fnDoneCb","setTimeout","getResponseHeader","param","done","doneCb","fail","origAjax","jQuery","ajax","fDone","Error"],"mappings":"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","sourceRoot":".","sourcesContent":["import CacheHandlerServiceFactory from \"sap/fe/core/services/CacheHandlerServiceFactory\";\nimport Cache from \"sap/ui/core/cache/CacheManager\";\nimport Device from \"sap/ui/Device\";\n// Override to make the CacheManager works for some tests\n(Device as any).browser.name = \"cr\";\n(Device as any).browser.version = 80;\n\ndescribe(\"CacheHandlerFactory\", () => {\n\tconst oFakeMetaModel: any = {\n\t\tfetchEntityContainer: function() {\n\t\t\treturn Promise.resolve();\n\t\t},\n\t\tgetId: function() {\n\t\t\treturn \"fakeModelId\";\n\t\t}\n\t};\n\tconst oFakeComponent = {\n\t\tgetViewData: function() {\n\t\t\treturn { dummySetting: \"dummy\" };\n\t\t}\n\t};\n\tconst oFakeAppComponent = {\n\t\tgetManifest: function() {\n\t\t\treturn {\n\t\t\t\t\"sap.app\": { dummySetting: \"dummy\" }\n\t\t\t};\n\t\t}\n\t};\n\n\ttest(\"can be initialized\", function() {\n\t\texpect(CacheHandlerServiceFactory).not.toEqual(null); // \"Library has been loaded\");\n\t\tconst oTestFactory = new CacheHandlerServiceFactory();\n\t\texpect(oTestFactory).not.toEqual(null);\n\t});\n\n\tlet oFactory!: CacheHandlerServiceFactory;\n\tdescribe(\"CacheHandler instance creation\", () => {\n\t\tbeforeEach(() => {\n\t\t\toFactory = new CacheHandlerServiceFactory();\n\t\t});\n\n\t\ttest(\"cannot be initialized without a metamodel\", function() {\n\t\t\tconst createFn = () => oFactory.createInstance({ settings: {} } as any);\n\t\t\texpect(createFn).toThrow();\n\t\t});\n\n\t\ttest(\"cannot be initialized with a failing metamodel\", function() {\n\t\t\ttry {\n\t\t\t\tconst oOriginFn = oFakeMetaModel.fetchEntityContainer;\n\t\t\t\toFakeMetaModel.fetchEntityContainer = function() {\n\t\t\t\t\treturn Promise.reject(\"Nope\");\n\t\t\t\t};\n\t\t\t\tconst oInstance = oFactory.createInstance({\n\t\t\t\t\tsettings: { metaModel: oFakeMetaModel, component: oFakeComponent, appComponent: oFakeAppComponent }\n\t\t\t\t} as any);\n\t\t\t\texpect(oInstance).toBeDefined();\n\t\t\t\treturn oInstance\n\t\t\t\t\t.then(function(oInstanceLoaded) {\n\t\t\t\t\t\texpect(true).toBe(false);\n\t\t\t\t\t})\n\t\t\t\t\t.catch(function() {\n\t\t\t\t\t\toFakeMetaModel.fetchEntityContainer = oOriginFn;\n\t\t\t\t\t});\n\t\t\t} catch (e) {\n\t\t\t\texpect(true).toBe(false);\n\t\t\t}\n\t\t});\n\n\t\ttest(\"is initialized as a global instance\", function() {\n\t\t\tlet oCurrentInstance: any;\n\t\t\tconst sFakeMetaModelId = oFakeMetaModel.getId();\n\t\t\tconst oFetchEntityContainerSpy = jest.spyOn(oFakeMetaModel, \"fetchEntityContainer\");\n\t\t\texpect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toBe(undefined); //, \"No global instance exists\");\n\n\t\t\tconst oInstance = oFactory.createInstance({\n\t\t\t\tsettings: { metaModel: oFakeMetaModel, component: oFakeComponent, appComponent: oFakeAppComponent }\n\t\t\t} as any);\n\t\t\texpect(oInstance).toBeDefined(); // \"Instance promise is created\");\n\t\t\texpect(oFetchEntityContainerSpy).toHaveBeenCalledTimes(1);\n\n\t\t\treturn oInstance\n\t\t\t\t.then(function(oInstanceLoaded) {\n\t\t\t\t\toCurrentInstance = oInstanceLoaded;\n\t\t\t\t\texpect(oInstanceLoaded).toBeDefined(); //assert.ok(oInstanceLoaded != null, \"Instance promise is resolved\");\n\t\t\t\t\texpect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toBeDefined(); // \"Global instance exists\");\n\t\t\t\t\tconst oNewInstance = oFactory.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any);\n\t\t\t\t\t// Init should not have been called again since the instance is global to the factory\n\t\t\t\t\texpect(oFetchEntityContainerSpy).toHaveBeenCalledTimes(1);\n\t\t\t\t\treturn oNewInstance;\n\t\t\t\t})\n\t\t\t\t.then(function(oNewInstanceLoaded) {\n\t\t\t\t\texpect(oNewInstanceLoaded).toEqual(oCurrentInstance); //, \"Both instance are the same\");\n\t\t\t\t\treturn oFactory.getInstance(oFakeMetaModel as any);\n\t\t\t\t})\n\t\t\t\t.then(function(oGlobalInstance) {\n\t\t\t\t\texpect(oCurrentInstance).toEqual(oGlobalInstance); //, \"Retrieving the global instance returns the same\");\n\t\t\t\t\toCurrentInstance.exit();\n\t\t\t\t\texpect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toEqual(null); // \"Global instance is removed\");\n\t\t\t\t\treturn oFactory.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any);\n\t\t\t\t})\n\t\t\t\t.then(function(oThirdInstanceLoaded) {\n\t\t\t\t\texpect(oThirdInstanceLoaded).toBeDefined(); // != null, \"Third instance can be created\");\n\t\t\t\t});\n\t\t});\n\n\t\tdescribe(\"CacheHandler checks\", () => {\n\t\t\tbeforeEach(() => {\n\t\t\t\treturn Cache.del(\"myCacheKey\");\n\t\t\t});\n\n\t\t\ttest(\"Case #1a- can validate a basic cache key\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\"\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\toCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sValidatedKey) {\n\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // \"ValidatedKey exists\"\n\t\t\t\t\t\t\texpect(sValidatedKey).toEqual('{\"myRootService\":\"MyETag\",\"manifest\":-1335850414}'); //, \"ValidatedKey is correct\");\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #1a - can validate a date based cache key\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\toCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sValidatedKey) {\n\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\texpect(sValidatedKey).toEqual('{\"myRootService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'); // \"ValidatedKey is correct\"\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #1-b cannot validate a cache key if no metadata include ETags\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": null\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sValidatedKey) {\n\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(null); //.toBeDefined(); // == null, \"Validated key is null\");\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #1-b cannot validate a cache key if one metadata does not include ETags\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": null\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\toCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sValidatedKey) {\n\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(null); // == null, \"Validated key is null\");\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\t//if ((Device as any).browser.msie || (Device as any).browser.chrome) {\n\t\t\ttest(\"Case #2a - can validate a basic cache key and revalidate if the ETags have not changed\", function() {\n\t\t\t\tconst oCacheManagerSpy = jest.spyOn(Cache, \"set\");\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\texpect(oCacheManagerSpy).not.toHaveBeenCalled();\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\texpect(oCacheManagerSpy).toHaveBeenCalledTimes(1);\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(sFirstCacheKey); // \"Validated Key is the same as the second validated key\");\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sSecondValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\texpect(oCacheManagerSpy).toHaveBeenCalledTimes(1);\n\t\t\t\t\t\t\t\toCacheManagerSpy.mockRestore();\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function() {\n\t\t\t\t\t\t\t\toCacheManagerSpy.mockRestore();\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2b - can deal with an ETag enhancement in a given session\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": \"Yolo\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(sFirstCacheKey); //\"Validated Key is the same as the second validated key\"\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2b + 2z - will request ETag that were added and which are now missing\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": \"Yolo\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // \"Validated Key is not the same as the second validated key\"\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(null); // == null, \"No more cache\");\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2b + 2a - will request ETag that were added and which are the same\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\tconst jQueryAjaxStub = function() {\n\t\t\t\t\tlet fnDoneCb: Function;\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tfnDoneCb(null, null, {\n\t\t\t\t\t\t\tgetResponseHeader: function(param: string) {\n\t\t\t\t\t\t\t\tif (param === \"ETag\") {\n\t\t\t\t\t\t\t\t\treturn \"Yolo\";\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}, 100);\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: function(doneCb: Function) {\n\t\t\t\t\t\t\tfnDoneCb = doneCb;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tfail: function() {}\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\tconst origAjax = jQuery.ajax;\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": \"Yolo\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\t\t\tjQuery.ajax = jQueryAjaxStub;\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(sFirstCacheKey); // \"Validated Key is the same as the second validated key \" + sSecondValidatedKey\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function() {\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2b + 2a - will request ETag that were added and which are the same - Date version\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\tconst jQueryAjaxStub = function() {\n\t\t\t\t\tlet fnDoneCb: Function;\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tfnDoneCb(null, null, {\n\t\t\t\t\t\t\tgetResponseHeader: function(param: any) {\n\t\t\t\t\t\t\t\tif (param === \"Last-Modified\") {\n\t\t\t\t\t\t\t\t\treturn \"2019-08-29T00:00:00.000Z\";\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}, 100);\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: function(doneCb: Function) {\n\t\t\t\t\t\t\tfnDoneCb = doneCb;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tfail: function() {}\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\tconst origAjax = jQuery.ajax;\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": new Date(\"2019-08-29\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\t\t\tjQuery.ajax = jQueryAjaxStub;\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(sFirstCacheKey); //\"Validated Key is the same as the second validated key \" + sSecondValidatedKey\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function() {\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2b + 2d - will request ETag that were added and which are different\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\tconst jQueryAjaxStub = function() {\n\t\t\t\t\tlet fnDoneCb: Function;\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tfnDoneCb(null, null, {\n\t\t\t\t\t\t\tgetResponseHeader: function(param: string) {\n\t\t\t\t\t\t\t\tif (param === \"ETag\") {\n\t\t\t\t\t\t\t\t\treturn \"NotYolo\";\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}, 100);\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: function(doneCb: Function) {\n\t\t\t\t\t\t\tfnDoneCb = doneCb;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tfail: function() {}\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\tconst origAjax = jQuery.ajax;\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": \"Yolo\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\t\t\tjQuery.ajax = jQueryAjaxStub;\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //\"Validated Key is the same as the second validated key \" + sSecondValidatedKey\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414,\"myThirdService\":\"NotYolo\"}'\n\t\t\t\t\t\t\t\t); //\"Validated Key is correct\"\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function(fDone) {\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2b + 2d - will request ETag that were added and which are different - Date version\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\tconst jQueryAjaxStub = function() {\n\t\t\t\t\tlet fnDoneCb: Function;\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tfnDoneCb(null, null, {\n\t\t\t\t\t\t\tgetResponseHeader: function(param: string) {\n\t\t\t\t\t\t\t\tif (param === \"Last-Modified\") {\n\t\t\t\t\t\t\t\t\treturn \"2019-08-28T00:00:00.000Z\";\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}, 100);\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: function(doneCb: Function) {\n\t\t\t\t\t\t\tfnDoneCb = doneCb;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tfail: function() {}\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\tconst origAjax = jQuery.ajax;\n\t\t\t\toFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": new Date(\"2019-08-29\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\t\t\tjQuery.ajax = jQueryAjaxStub;\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //\"Validated Key is the same as the second validated key \" + sSecondValidatedKey\n\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414,\"myThirdService\":\"2019-08-28T00:00:00.000Z\"}'\n\t\t\t\t\t\t\t\t); //\"Validated Key is correct\"\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function(fDone) {\n\t\t\t\t\t\t\t\tjQuery.ajax = origAjax;\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2c - can deal with an ETag change\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\toFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\t// Simulate ETag change\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"NotMyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\toCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // \"Validated Key is the not the same as the second validated key\"\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"NotMyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2d - can deal with an ETag enhancement and a change\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": \"Yolo\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-30\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": \"Yolo\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //\"Validated Key is not the same as the second validated key\"\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-30T00:00:00.000Z\",\"myThirdService\":\"Yolo\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \" + sSecondValidatedKe\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #2z - can deal with an invalid ETag enhancement\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\toFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\toCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\t// Simulate model enhancement\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\"),\n\t\t\t\t\t\t\t\t\t\t\"myThirdService\": null\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\toCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // \"Validated Key is not the same as the second validated key\"\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(null); //, \"ValidatedKey is null since it doesn't have an ETag\");\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #xx - can deal with an error thrown while validating the cache\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\toFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); // != null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\t// Simulate error\n\t\t\t\t\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\t\t\t\t\tthrow new Error(\"nope\");\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); // \"Validated Key is not the same as the second validated key\"\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(null); //, \"ValidatedKey is null since it doesn't have an ETag\");\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\n\t\t\ttest(\"Case #3 - can deal with a Manifest change\", function() {\n\t\t\t\tconst oFactory = new CacheHandlerServiceFactory();\n\t\t\t\toFakeMetaModel.getETags = function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t\"myRootService\": \"MyETag\",\n\t\t\t\t\t\t\"myOtherService\": new Date(\"2019-08-31\")\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t\treturn oFactory\n\t\t\t\t\t.createInstance({\n\t\t\t\t\t\tsettings: {\n\t\t\t\t\t\t\tmetaModel: oFakeMetaModel,\n\t\t\t\t\t\t\tcomponent: oFakeComponent,\n\t\t\t\t\t\t\tappComponent: oFakeAppComponent\n\t\t\t\t\t\t}\n\t\t\t\t\t} as any)\n\t\t\t\t\t.then(function(oCacheHandlerInstance) {\n\t\t\t\t\t\tlet sFirstCacheKey: string;\n\t\t\t\t\t\treturn oCacheHandlerInstance\n\t\t\t\t\t\t\t.validateCacheKey(\"myCacheKey\")\n\t\t\t\t\t\t\t.then(function(sValidatedKey) {\n\t\t\t\t\t\t\t\tsFirstCacheKey = sValidatedKey;\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toBeDefined(); //null, \"ValidatedKey exists\");\n\t\t\t\t\t\t\t\texpect(sValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1335850414}'\n\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.invalidateIfNeeded(sValidatedKey, \"myCacheKey\");\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.then(function() {\n\t\t\t\t\t\t\t\t// Simulate Manifest Change\n\t\t\t\t\t\t\t\toFakeAppComponent.getManifest = function() {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\"sap.app\": { dummySetting: \"Changed\" }\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\treturn oCacheHandlerInstance.validateCacheKey(\"myCacheKey\").then(function(sSecondValidatedKey) {\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).not.toEqual(sFirstCacheKey); //\"Validated Key is the not the same as the second validated key\"\n\t\t\t\t\t\t\t\t\texpect(sSecondValidatedKey).toEqual(\n\t\t\t\t\t\t\t\t\t\t'{\"myRootService\":\"MyETag\",\"myOtherService\":\"2019-08-31T00:00:00.000Z\",\"manifest\":-1956011802}'\n\t\t\t\t\t\t\t\t\t); //\"ValidatedKey is correct \"\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\t\t\t//}\n\t\t});\n\t});\n});\n"]}