94207: Update DeleteDate to use buildFromRequestUUIDAndAwait

Author: ybnd

src/app/core/data/base/delete-data.spec.ts

@@ -22,7 +22,7 @@ import { RequestEntryState } from '../request-entry-state.model';
 import { DeleteData, DeleteDataImpl } from './delete-data';
 import { NotificationsService } from '../../../shared/notifications/notifications.service';
 import { createFailedRemoteDataObject, createSuccessfulRemoteDataObject, createSuccessfulRemoteDataObject$ } from '../../../shared/remote-data.utils';
-import { fakeAsync, tick } from '@angular/core/testing';
+import { RestRequestMethod } from '../rest-request-method';
 
 /**
  * Tests whether calls to `DeleteData` methods are correctly patched through in a concrete data service that implements it
@@ -63,8 +63,6 @@ export function testDeleteDataImplementation(serviceFactory: () => DeleteData<an
 
 const endpoint = 'https://rest.api/core';
 
-const BOOLEAN = { f: false, t: true };
-
 class TestService extends DeleteDataImpl<any> {
   constructor(
     protected requestService: RequestService,
@@ -155,13 +153,13 @@ describe('DeleteDataImpl', () => {
     let MOCK_FAILED_RD;
 
     let invalidateByHrefSpy: jasmine.Spy;
-    let buildFromRequestUUIDSpy: jasmine.Spy;
+    let buildFromRequestUUIDAndAwaitSpy: jasmine.Spy;
     let getIDHrefObsSpy: jasmine.Spy;
     let deleteByHrefSpy: jasmine.Spy;
 
     beforeEach(() => {
       invalidateByHrefSpy = spyOn(service, 'invalidateByHref').and.returnValue(observableOf(true));
-      buildFromRequestUUIDSpy = spyOn(rdbService, 'buildFromRequestUUID').and.callThrough();
+      buildFromRequestUUIDAndAwaitSpy = spyOn(rdbService, 'buildFromRequestUUIDAndAwait').and.callThrough();
       getIDHrefObsSpy = spyOn(service, 'getIDHrefObs').and.callThrough();
       deleteByHrefSpy = spyOn(service, 'deleteByHref').and.callThrough();
 
@@ -171,7 +169,7 @@ describe('DeleteDataImpl', () => {
 
     it('should retrieve href by ID and call deleteByHref', () => {
       getIDHrefObsSpy.and.returnValue(observableOf('some-href'));
-      buildFromRequestUUIDSpy.and.returnValue(createSuccessfulRemoteDataObject$({}));
+      buildFromRequestUUIDAndAwaitSpy.and.returnValue(createSuccessfulRemoteDataObject$({}));
 
       service.delete('some-id', ['a', 'b', 'c']).subscribe(rd => {
         expect(getIDHrefObsSpy).toHaveBeenCalledWith('some-id');
@@ -180,64 +178,51 @@ describe('DeleteDataImpl', () => {
     });
 
     describe('deleteByHref', () => {
-      it('should call invalidateByHref if the DELETE request succeeds', (done) => {
-        buildFromRequestUUIDSpy.and.returnValue(observableOf(MOCK_SUCCEEDED_RD));
-
-        service.deleteByHref('some-href').subscribe(rd => {
-          expect(rd).toBe(MOCK_SUCCEEDED_RD);
-          expect(invalidateByHrefSpy).toHaveBeenCalled();
+      it('should send a DELETE request', (done) => {
+        buildFromRequestUUIDAndAwaitSpy.and.returnValue(observableOf(MOCK_SUCCEEDED_RD));
+
+        service.deleteByHref('some-href').subscribe(() => {
+          expect(requestService.send).toHaveBeenCalledWith(jasmine.objectContaining({
+            method: RestRequestMethod.DELETE,
+            href: 'some-href',
+          }));
           done();
         });
       });
 
-      it('should call invalidateByHref even if not subscribing to returned Observable', fakeAsync(() => {
-        buildFromRequestUUIDSpy.and.returnValue(observableOf(MOCK_SUCCEEDED_RD));
-
-        service.deleteByHref('some-href');
-        tick();
+      it('should include the virtual metadata to be copied in the DELETE request', (done) => {
+        buildFromRequestUUIDAndAwaitSpy.and.returnValue(observableOf(MOCK_SUCCEEDED_RD));
 
-        expect(invalidateByHrefSpy).toHaveBeenCalled();
-      }));
-
-      it('should not call invalidateByHref if the DELETE request fails', (done) => {
-        buildFromRequestUUIDSpy.and.returnValue(observableOf(MOCK_FAILED_RD));
-
-        service.deleteByHref('some-href').subscribe(rd => {
-          expect(rd).toBe(MOCK_FAILED_RD);
-          expect(invalidateByHrefSpy).not.toHaveBeenCalled();
+        service.deleteByHref('some-href', ['a', 'b', 'c']).subscribe(() => {
+          expect(requestService.send).toHaveBeenCalledWith(jasmine.objectContaining({
+            method: RestRequestMethod.DELETE,
+            href: 'some-href?copyVirtualMetadata=a&copyVirtualMetadata=b&copyVirtualMetadata=c',
+          }));
           done();
         });
       });
 
-      it('should wait for invalidateByHref before emitting', () => {
-        testScheduler.run(({ cold, expectObservable }) => {
-          buildFromRequestUUIDSpy.and.returnValue(
-            cold('(r|)', { r: MOCK_SUCCEEDED_RD})      // RD emits right away
-          );
-          invalidateByHrefSpy.and.returnValue(
-            cold('----(t|)', BOOLEAN)                  // but we pretend that setting requests to stale takes longer
+      it('should invalidate the currently cached object', (done) => {
+        service.deleteByHref('some-href').subscribe(() => {
+          expect(buildFromRequestUUIDAndAwaitSpy).toHaveBeenCalledWith(
+            requestService.generateRequestId(),
+            jasmine.anything(),
           );
 
-          const done$ = service.deleteByHref('some-href');
-          expectObservable(done$).toBe(
-            '----(r|)', { r: MOCK_SUCCEEDED_RD}        // ...and expect the returned Observable to wait until that's done
-          );
+          const callback = (rdbService.buildFromRequestUUIDAndAwait as jasmine.Spy).calls.argsFor(0)[1];
+          callback();
+          expect(service.invalidateByHref).toHaveBeenCalledWith('some-href');
+
+          done();
         });
       });
 
-      it('should wait for the DELETE request to resolve before emitting', () => {
-        testScheduler.run(({ cold, expectObservable }) => {
-          buildFromRequestUUIDSpy.and.returnValue(
-            cold('----(r|)', { r: MOCK_SUCCEEDED_RD})   // the request takes a while
-          );
-          invalidateByHrefSpy.and.returnValue(
-            cold('(t|)', BOOLEAN)                       // but we pretend that setting to stale happens sooner
-          );                                            // e.g.: maybe already stale before this call?
+      it('should return the RemoteData of the response', (done) => {
+        buildFromRequestUUIDAndAwaitSpy.and.returnValue(observableOf(MOCK_SUCCEEDED_RD));
 
-          const done$ = service.deleteByHref('some-href');
-          expectObservable(done$).toBe(
-            '----(r|)', { r: MOCK_SUCCEEDED_RD}         // ...and expect the returned Observable to wait for the request
-          );
+        service.deleteByHref('some-href').subscribe(rd => {
+          expect(rd).toBe(MOCK_SUCCEEDED_RD);
+          done();
         });
       });
     });

src/app/core/data/base/delete-data.ts

@@ -6,13 +6,12 @@
  * http://www.dspace.org/license/
  */
 import { CacheableObject } from '../../cache/cacheable-object.model';
-import { AsyncSubject, combineLatest, Observable } from 'rxjs';
+import { Observable } from 'rxjs';
 import { RemoteData } from '../remote-data';
 import { NoContent } from '../../shared/NoContent.model';
-import { filter, map, switchMap } from 'rxjs/operators';
+import { switchMap } from 'rxjs/operators';
 import { DeleteRequest } from '../request.models';
 import { hasNoValue, hasValue } from '../../../shared/empty.util';
-import { getFirstCompletedRemoteData } from '../../shared/operators';
 import { RequestService } from '../request.service';
 import { RemoteDataBuildService } from '../../cache/builders/remote-data-build.service';
 import { HALEndpointService } from '../../shared/hal-endpoint.service';
@@ -83,26 +82,6 @@ export class DeleteDataImpl<T extends CacheableObject> extends IdentifiableDataS
     }
     this.requestService.send(request);
 
-    const response$ = this.rdbService.buildFromRequestUUID(requestId);
-
-    const invalidated$ = new AsyncSubject<boolean>();
-    response$.pipe(
-      getFirstCompletedRemoteData(),
-      switchMap((rd: RemoteData<NoContent>) => {
-        if (rd.hasSucceeded) {
-          return this.invalidateByHref(href);
-        } else {
-          return [true];
-        }
-      })
-    ).subscribe(() => {
-      invalidated$.next(true);
-      invalidated$.complete();
-    });
-
-    return combineLatest([response$, invalidated$]).pipe(
-      filter(([_, invalidated]) => invalidated),
-      map(([response, _]) => response),
-    );
+    return this.rdbService.buildFromRequestUUIDAndAwait(requestId, () => this.invalidateByHref(href));
   }
 }