From 60d2f386df6c0d1df1e974797962ade236f3ac66 Mon Sep 17 00:00:00 2001
From: Kristof De Langhe <kristof.delanghe@atmire.com>
Date: Fri, 6 Mar 2020 13:16:15 +0100
Subject: [PATCH] 69314: BaseResponseParsingService test cases for cache and
 process

---
 .../base-response-parsing.service.spec.ts     | 104 ++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 src/app/core/data/base-response-parsing.service.spec.ts

diff --git a/src/app/core/data/base-response-parsing.service.spec.ts b/src/app/core/data/base-response-parsing.service.spec.ts
new file mode 100644
index 0000000000..a1d602dc65
--- /dev/null
+++ b/src/app/core/data/base-response-parsing.service.spec.ts
@@ -0,0 +1,104 @@
+import { BaseResponseParsingService } from './base-response-parsing.service';
+import { GlobalConfig } from '../../../config/global-config.interface';
+import { ObjectCacheService } from '../cache/object-cache.service';
+import { CacheableObject } from '../cache/object-cache.reducer';
+import { GetRequest, RestRequest } from './request.models';
+import { DSpaceObject } from '../shared/dspace-object.model';
+
+/* tslint:disable:max-classes-per-file */
+class TestService extends BaseResponseParsingService {
+  toCache = true;
+
+  constructor(protected EnvConfig: GlobalConfig,
+              protected objectCache: ObjectCacheService) {
+    super();
+  }
+
+  // Overwrite methods to make them public for testing
+  public process<ObjectDomain>(data: any, request: RestRequest): any {
+    super.process(data, request);
+  }
+
+  public cache<ObjectDomain>(obj, request: RestRequest, data: any) {
+    super.cache(obj, request, data);
+  }
+}
+
+describe('BaseResponseParsingService', () => {
+  let service: TestService;
+  let config: GlobalConfig;
+  let objectCache: ObjectCacheService;
+
+  const requestUUID = 'request-uuid';
+  const requestHref = 'request-href';
+  const request = new GetRequest(requestUUID, requestHref);
+
+  beforeEach(() => {
+    config = Object.assign({});
+    objectCache = jasmine.createSpyObj('objectCache', {
+      add: {}
+    });
+    service = new TestService(config, objectCache);
+  });
+
+  describe('cache', () => {
+    let obj: CacheableObject;
+
+    describe('when the object is undefined', () => {
+      it('should not throw an error', () => {
+        expect(() => { service.cache(obj, request, {}) }).not.toThrow();
+      });
+
+      it('should not call objectCache add', () => {
+        service.cache(obj, request, {});
+        expect(objectCache.add).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when the object has a self link', () => {
+      beforeEach(() => {
+        obj = Object.assign(new DSpaceObject(), {
+          _links: {
+            self: { href: 'obj-selflink' }
+          }
+        });
+      });
+
+      it('should call objectCache add', () => {
+        service.cache(obj, request, {});
+        expect(objectCache.add).toHaveBeenCalledWith(obj, request.responseMsToLive, request.uuid);
+      });
+    });
+  });
+
+  describe('process', () => {
+    let data: any;
+    let result: any;
+
+    describe('when data is valid, but not a real type', () => {
+      beforeEach(() => {
+        data = {
+          type: 'NotARealType',
+          _links: {
+            self: { href: 'data-selflink' }
+          }
+        };
+      });
+
+      it('should not throw an error', () => {
+        expect(() => { result = service.process(data, request) }).not.toThrow();
+      });
+
+      it('should return undefined', () => {
+        result = service.process(data, request);
+        expect(result).toBeUndefined();
+      });
+
+      it('should not call objectCache add', () => {
+        result = service.process(data, request);
+        expect(objectCache.add).not.toHaveBeenCalled();
+      });
+    });
+  });
+});
+/* tslint:enable:max-classes-per-file */