@sap/open.fe 1.98.0 → 1.99.0

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

@@ -0,0 +1,899 @@
+import CacheHandlerServiceFactory from "sap/fe/core/services/CacheHandlerServiceFactory";
+import Cache from "sap/ui/core/cache/CacheManager";
+import Device from "sap/ui/Device";
+// Override to make the CacheManager works for some tests
+(Device as any).browser.name = "cr";
+(Device as any).browser.version = 80;
+
+describe("CacheHandlerFactory", () => {
+	const oFakeMetaModel: any = {
+		fetchEntityContainer: function() {
+			return Promise.resolve();
+		},
+		getId: function() {
+			return "fakeModelId";
+		}
+	};
+	const oFakeComponent = {
+		getViewData: function() {
+			return { dummySetting: "dummy" };
+		}
+	};
+	const oFakeAppComponent = {
+		getManifest: function() {
+			return {
+				"sap.app": { dummySetting: "dummy" }
+			};
+		}
+	};
+
+	test("can be initialized", function() {
+		expect(CacheHandlerServiceFactory).not.toEqual(null); // "Library has been loaded");
+		const oTestFactory = new CacheHandlerServiceFactory();
+		expect(oTestFactory).not.toEqual(null);
+	});
+
+	let oFactory!: CacheHandlerServiceFactory;
+	describe("CacheHandler instance creation", () => {
+		beforeEach(() => {
+			oFactory = new CacheHandlerServiceFactory();
+		});
+
+		test("cannot be initialized without a metamodel", function() {
+			const createFn = () => oFactory.createInstance({ settings: {} } as any);
+			expect(createFn).toThrow();
+		});
+
+		test("cannot be initialized with a failing metamodel", function() {
+			try {
+				const oOriginFn = oFakeMetaModel.fetchEntityContainer;
+				oFakeMetaModel.fetchEntityContainer = function() {
+					return Promise.reject("Nope");
+				};
+				const oInstance = oFactory.createInstance({
+					settings: { metaModel: oFakeMetaModel, component: oFakeComponent, appComponent: oFakeAppComponent }
+				} as any);
+				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() {
+			let oCurrentInstance: any;
+			const sFakeMetaModelId = oFakeMetaModel.getId();
+			const oFetchEntityContainerSpy = jest.spyOn(oFakeMetaModel, "fetchEntityContainer");
+			expect(oFactory._oInstanceRegistry[sFakeMetaModelId]).toBe(undefined); //, "No global instance exists");
+
+			const oInstance = oFactory.createInstance({
+				settings: { metaModel: oFakeMetaModel, component: oFakeComponent, appComponent: oFakeAppComponent }
+			} as any);
+			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");
+					const oNewInstance = oFactory.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any);
+					// 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 as any);
+				})
+				.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
+						}
+					} as any);
+				})
+				.then(function(oThirdInstanceLoaded) {
+					expect(oThirdInstanceLoaded).toBeDefined(); // != null, "Third instance can be created");
+				});
+		});
+
+		describe("CacheHandler checks", () => {
+			beforeEach(() => {
+				return Cache.del("myCacheKey");
+			});
+
+			test("Case #1a- can validate a basic cache key", function() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag"
+					};
+				};
+
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": new Date("2019-08-31")
+					};
+				};
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": null
+					};
+				};
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": null
+					};
+				};
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.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() {
+				const oCacheManagerSpy = jest.spyOn(Cache, "set");
+				const 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
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const 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
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const 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
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				const jQueryAjaxStub = function() {
+					let fnDoneCb: Function;
+					setTimeout(function() {
+						fnDoneCb(null, null, {
+							getResponseHeader: function(param: string) {
+								if (param === "ETag") {
+									return "Yolo";
+								}
+							}
+						});
+					}, 100);
+					return {
+						done: function(doneCb: Function) {
+							fnDoneCb = doneCb;
+							return {
+								fail: function() {}
+							};
+						}
+					};
+				};
+
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				const origAjax = jQuery.ajax;
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				const jQueryAjaxStub = function() {
+					let fnDoneCb: Function;
+					setTimeout(function() {
+						fnDoneCb(null, null, {
+							getResponseHeader: function(param: any) {
+								if (param === "Last-Modified") {
+									return "2019-08-29T00:00:00.000Z";
+								}
+							}
+						});
+					}, 100);
+					return {
+						done: function(doneCb: Function) {
+							fnDoneCb = doneCb;
+							return {
+								fail: function() {}
+							};
+						}
+					};
+				};
+
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				const origAjax = jQuery.ajax;
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				const jQueryAjaxStub = function() {
+					let fnDoneCb: Function;
+					setTimeout(function() {
+						fnDoneCb(null, null, {
+							getResponseHeader: function(param: string) {
+								if (param === "ETag") {
+									return "NotYolo";
+								}
+							}
+						});
+					}, 100);
+					return {
+						done: function(doneCb: Function) {
+							fnDoneCb = doneCb;
+							return {
+								fail: function() {}
+							};
+						}
+					};
+				};
+
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				const origAjax = jQuery.ajax;
+				return oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				const jQueryAjaxStub = function() {
+					let fnDoneCb: Function;
+					setTimeout(function() {
+						fnDoneCb(null, null, {
+							getResponseHeader: function(param: string) {
+								if (param === "Last-Modified") {
+									return "2019-08-28T00:00:00.000Z";
+								}
+							}
+						});
+					}, 100);
+					return {
+						done: function(doneCb: Function) {
+							fnDoneCb = doneCb;
+							return {
+								fail: function() {}
+							};
+						}
+					};
+				};
+
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				const origAjax = jQuery.ajax;
+				oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const 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
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const oFactory = new CacheHandlerServiceFactory();
+				oFakeMetaModel.getETags = function() {
+					return {
+						"myRootService": "MyETag",
+						"myOtherService": new Date("2019-08-31")
+					};
+				};
+				oFactory
+					.createInstance({
+						settings: {
+							metaModel: oFakeMetaModel,
+							component: oFakeComponent,
+							appComponent: oFakeAppComponent
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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() {
+				const 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
+						}
+					} as any)
+					.then(function(oCacheHandlerInstance) {
+						let sFirstCacheKey: string;
+						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 "
+								});
+							});
+					});
+			});
+			//}
+		});
+	});
+});