added some tests

src/app/core/data/relationship-type.service.spec.ts

+import { RequestService } from './request.service';
+import { HALEndpointServiceStub } from '../../shared/testing/hal-endpoint-service-stub';
+import { getMockRemoteDataBuildService } from '../../shared/mocks/mock-remote-data-build.service';
+import { RelationshipType } from '../shared/item-relationships/relationship-type.model';
+import { getMockRequestService } from '../../shared/mocks/mock-request.service';
+import { PaginatedList } from './paginated-list';
+import { PageInfo } from '../shared/page-info.model';
+import { createSuccessfulRemoteDataObject, createSuccessfulRemoteDataObject$ } from '../../shared/testing/utils';
+import { RelationshipTypeService } from './relationship-type.service';
+import { of as observableOf } from 'rxjs';
+import { ItemType } from '../shared/item-relationships/item-type.model';
+
+fdescribe('RelationshipTypeService', () => {
+  let service: RelationshipTypeService;
+  let requestService: RequestService;
+
+  const restEndpointURL = 'https://rest.api/relationshiptypes';
+  const halService: any = new HALEndpointServiceStub(restEndpointURL);
+  const publicationTypeString = 'Publication';
+  const personTypeString = 'Person';
+  const orgUnitTypeString = 'OrgUnit';
+  const publicationType = Object.assign(new ItemType(), {label: publicationTypeString});
+  const personType = Object.assign(new ItemType(), {label: personTypeString});
+  const orgUnitType = Object.assign(new ItemType(), {label: orgUnitTypeString});
+
+  const relationshipType1 = Object.assign(new RelationshipType(), {
+    id: '1',
+    uuid: '1',
+    leftwardType: 'isAuthorOfPublication',
+    rightwardType: 'isPublicationOfAuthor',
+    leftType: createSuccessfulRemoteDataObject$(publicationType),
+    rightType: createSuccessfulRemoteDataObject$(personType)
+  });
+
+
+  const relationshipType2 = Object.assign(new RelationshipType(), {
+    id: '2',
+    uuid: '2',
+    leftwardType: 'isOrgUnitOfPublication',
+    rightwardType: 'isPublicationOfOrgUnit',
+    leftType: createSuccessfulRemoteDataObject$(publicationType),
+    rightType: createSuccessfulRemoteDataObject$(orgUnitType)
+  });
+
+  const buildList = createSuccessfulRemoteDataObject(new PaginatedList(new PageInfo(), [relationshipType1, relationshipType2]));
+  const rdbService = getMockRemoteDataBuildService(undefined, observableOf(buildList));
+
+  function initTestService() {
+    return new RelationshipTypeService(
+      requestService,
+      halService,
+      rdbService
+    );
+  }
+
+  beforeEach(() => {
+    requestService = getMockRequestService();
+    service = initTestService();
+  });
+
+  describe('getAllRelationshipTypes', () => {
+
+    it('should return all relationshipTypes', (done) => {
+      const expected = service.getAllRelationshipTypes({});
+      expected.subscribe((e) => {
+        expect(e).toBe(buildList);
+        done();
+      })
+    });
+  });
+
+  describe('getRelationshipTypeByLabelAndTypes', () => {
+
+    it('should return the type filtered by label and type strings', (done) => {
+      const expected = service.getRelationshipTypeByLabelAndTypes(relationshipType1.leftwardType, publicationTypeString, personTypeString);
+      expected.subscribe((e) => {
+        expect(e).toBe(relationshipType1);
+        done();
+      })
+    });
+  });
+
+});

src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.spec.ts

+import { BehaviorSubject, Observable, of as observableOf } from 'rxjs';
+import { RelationshipEffects } from './relationship.effects';
+import { async, TestBed } from '@angular/core/testing';
+import { provideMockActions } from '@ngrx/effects/testing';
+import { AddRelationshipAction, RelationshipActionTypes, RemoveRelationshipAction } from './relationship.actions';
+import { Item } from '../../../../../core/shared/item.model';
+import { MetadataValue } from '../../../../../core/shared/metadata.models';
+import { RelationshipTypeService } from '../../../../../core/data/relationship-type.service';
+import { RelationshipService } from '../../../../../core/data/relationship.service';
+import { Relationship } from '../../../../../core/shared/item-relationships/relationship.model';
+import { createSuccessfulRemoteDataObject$, spyOnOperator } from '../../../../testing/utils';
+import { RelationshipType } from '../../../../../core/shared/item-relationships/relationship-type.model';
+import { cold, hot } from 'jasmine-marbles';
+import * as operators from 'rxjs/operators';
+import { last } from 'rxjs/operators';
+import { ItemType } from '../../../../../core/shared/item-relationships/item-type.model';
+
+describe('RelationshipEffects', () => {
+  let relationEffects: RelationshipEffects;
+  let actions: Observable<any>;
+
+  const testUUID1 = '20e24c2f-a00a-467c-bdee-c929e79bf08d';
+  const testUUID2 = '7f66a4d0-8557-4e77-8b1e-19930895f10a';
+  const leftTypeString = 'Publication';
+  const rightTypeString = 'Person';
+  const leftType = Object.assign(new ItemType(), {label: leftTypeString});
+  const rightType = Object.assign(new ItemType(), {label: rightTypeString});
+  const leftTypeMD = Object.assign(new MetadataValue(), { value: leftTypeString });
+  const rightTypeMD = Object.assign(new MetadataValue(), { value: rightTypeString });
+  const relationshipID = '1234';
+  let identifier;
+
+  let leftItem = Object.assign(new Item(), {
+    uuid: testUUID1,
+    metadata: { 'relationship.type': [leftTypeMD] }
+  });
+
+  let rightItem = Object.assign(new Item(), {
+    uuid: testUUID2,
+    metadata: { 'relationship.type': [rightTypeMD] }
+  });
+
+  let relationshipType: RelationshipType = Object.assign(new RelationshipType(), {
+    leftwardType: 'isAuthorOfPublication',
+    rightwardType: 'isPublicationOfAuthor',
+    leftType: createSuccessfulRemoteDataObject$(leftType),
+    rightType: createSuccessfulRemoteDataObject$(rightType)
+  });
+
+  let relationship = Object.assign(new Relationship(),
+    {
+      uuid: relationshipID,
+      leftItem: createSuccessfulRemoteDataObject$(leftItem),
+      rightItem: createSuccessfulRemoteDataObject$(rightItem),
+      relationshipType: createSuccessfulRemoteDataObject$(relationshipType)
+    });
+  const mockRelationshipService = {
+    getRelationshipByItemsAndLabel:
+      () => observableOf(relationship),
+    deleteRelationship: () => {
+      /* Do nothing */
+    },
+    addRelationship: () => {
+      /* Do nothing */
+    }
+  };
+  const mockRelationshipTypeService = {
+    getRelationshipTypeByLabelAndTypes:
+      () => observableOf(relationshipType)
+  };
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        RelationshipEffects,
+        provideMockActions(() => actions),
+        { provide: RelationshipTypeService, useValue: mockRelationshipTypeService },
+        { provide: RelationshipService, useValue: mockRelationshipService }
+      ],
+    });
+  }));
+
+  beforeEach(() => {
+    relationEffects = TestBed.get(RelationshipEffects);
+    identifier = (relationEffects as any).createIdentifier(leftItem, rightItem, relationshipType.leftwardType);
+  });
+
+  describe('mapLastActions$', () => {
+    describe('When an ADD_RELATIONSHIP action is triggered', () => {
+      describe('When it\'s the first time for this identifier', () => {
+        let action;
+        it('should set the current value debounceMap and the value of the initialActionMap to ADD_RELATIONSHIP', () => {
+          action = new AddRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+          actions = hot('--a-', { a: action });
+          const expected = cold('--b-', { b: undefined });
+          expect(relationEffects.mapLastActions$).toBeObservable(expected);
+
+          expect((relationEffects as any).initialActionMap[identifier]).toBe(action.type);
+          expect((relationEffects as any).debounceMap[identifier].value).toBe(action.type);
+        });
+      });
+
+      describe('When it\'s not the first time for this identifier', () => {
+        let action;
+        let testActionType = "TEST_TYPE";
+        beforeEach(() => {
+          (relationEffects as any).initialActionMap[identifier] = testActionType;
+          (relationEffects as any).debounceMap[identifier] = new BehaviorSubject<string>(testActionType);
+        });
+
+        it('should set the current value debounceMap to ADD_RELATIONSHIP but not change the value of the initialActionMap', () => {
+          action = new AddRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+          actions = hot('--a-', { a: action });
+          const expected = cold('--b-', { b: undefined });
+          expect(relationEffects.mapLastActions$).toBeObservable(expected);
+
+          expect((relationEffects as any).initialActionMap[identifier]).toBe(testActionType);
+          expect((relationEffects as any).debounceMap[identifier].value).toBe(action.type);
+        });
+      });
+
+      describe('When the initialActionMap contains an ADD_RELATIONSHIP action', () => {
+        let action;
+        describe('When the last value in the debounceMap is also an ADD_RELATIONSHIP action', () => {
+          beforeEach(() => {
+            (relationEffects as any).initialActionMap[identifier] = RelationshipActionTypes.ADD_RELATIONSHIP;
+            spyOnOperator(operators, 'debounceTime').and.returnValue((v) => v);
+            spyOn((relationEffects as any), 'addRelationship');
+          });
+          it('should call addRelationship on the effect', () => {
+            action = new AddRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+            actions = hot('--a-', { a: action });
+            const expected = cold('--b-', { b: undefined });
+            expect(relationEffects.mapLastActions$).toBeObservable(expected);
+            expect((relationEffects as any).addRelationship).toHaveBeenCalledWith(leftItem, rightItem, relationshipType.leftwardType, undefined)
+          });
+        });
+
+        describe('When the last value in the debounceMap is instead a REMOVE_RELATIONSHIP action', () => {
+          beforeEach(() => {
+            /**
+             * Change debounceTime to last so there's no need to fire a certain amount of actions in the debounce time frame
+             */
+            spyOnOperator(operators, 'debounceTime').and.returnValue((v) => v.pipe(last()));
+            spyOn((relationEffects as any), 'addRelationship');
+            spyOn((relationEffects as any), 'removeRelationship');
+          });
+          it('should <b>not</b> call removeRelationship or addRelationship on the effect', () => {
+            const actiona = new AddRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+            const actionb = new RemoveRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+            actions = hot('--ab-', { a: actiona, b: actionb });
+            const expected = cold('--bb-', { b: undefined });
+            expect(relationEffects.mapLastActions$).toBeObservable(expected);
+            expect((relationEffects as any).addRelationship).not.toHaveBeenCalled();
+            expect((relationEffects as any).removeRelationship).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
+
+    describe('When an REMOVE_RELATIONSHIP action is triggered', () => {
+      describe('When it\'s the first time for this identifier', () => {
+        let action;
+        it('should set the current value debounceMap and the value of the initialActionMap to REMOVE_RELATIONSHIP', () => {
+          action = new RemoveRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+          actions = hot('--a-', { a: action });
+          const expected = cold('--b-', { b: undefined });
+          expect(relationEffects.mapLastActions$).toBeObservable(expected);
+
+          expect((relationEffects as any).initialActionMap[identifier]).toBe(action.type);
+          expect((relationEffects as any).debounceMap[identifier].value).toBe(action.type);
+        });
+      });
+
+      describe('When it\'s not the first time for this identifier', () => {
+        let action;
+        let testActionType = "TEST_TYPE";
+        beforeEach(() => {
+          (relationEffects as any).initialActionMap[identifier] = testActionType;
+          (relationEffects as any).debounceMap[identifier] = new BehaviorSubject<string>(testActionType);
+        });
+
+        it('should set the current value debounceMap to REMOVE_RELATIONSHIP but not change the value of the initialActionMap', () => {
+          action = new RemoveRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+          actions = hot('--a-', { a: action });
+          const expected = cold('--b-', { b: undefined });
+          expect(relationEffects.mapLastActions$).toBeObservable(expected);
+
+          expect((relationEffects as any).initialActionMap[identifier]).toBe(testActionType);
+          expect((relationEffects as any).debounceMap[identifier].value).toBe(action.type);
+        });
+      });
+
+      describe('When the initialActionMap contains an REMOVE_RELATIONSHIP action', () => {
+        let action;
+        describe('When the last value in the debounceMap is also an REMOVE_RELATIONSHIP action', () => {
+          beforeEach(() => {
+            (relationEffects as any).initialActionMap[identifier] = RelationshipActionTypes.REMOVE_RELATIONSHIP;
+            spyOnOperator(operators, 'debounceTime').and.returnValue((v) => v);
+            spyOn((relationEffects as any), 'removeRelationship');
+          });
+
+          it('should call removeRelationship on the effect', () => {
+            action = new RemoveRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+            actions = hot('--a-', { a: action });
+            const expected = cold('--b-', { b: undefined });
+            expect(relationEffects.mapLastActions$).toBeObservable(expected);
+            expect((relationEffects as any).removeRelationship).toHaveBeenCalledWith(leftItem, rightItem, relationshipType.leftwardType)
+          });
+        });
+
+        describe('When the last value in the debounceMap is instead a ADD_RELATIONSHIP action', () => {
+          beforeEach(() => {
+            /**
+             * Change debounceTime to last so there's no need to fire a certain amount of actions in the debounce time frame
+             */
+            spyOnOperator(operators, 'debounceTime').and.returnValue((v) => v.pipe(last()));
+            spyOn((relationEffects as any), 'addRelationship');
+            spyOn((relationEffects as any), 'removeRelationship');
+          });
+          it('should <b>not</b> call addRelationship or removeRelationship on the effect', () => {
+            const actionb = new RemoveRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+            const actiona = new AddRelationshipAction(leftItem, rightItem, relationshipType.leftwardType);
+            actions = hot('--ab-', { a: actiona, b: actionb });
+            const expected = cold('--bb-', { b: undefined });
+            expect(relationEffects.mapLastActions$).toBeObservable(expected);
+            expect((relationEffects as any).addRelationship).not.toHaveBeenCalled();
+            expect((relationEffects as any).removeRelationship).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
+  });
+});

src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.ts

@@ -9,7 +9,6 @@ import { hasNoValue, hasValue, hasValueOperator } from '../../../../empty.util';
 import { Relationship } from '../../../../../core/shared/item-relationships/relationship.model';
 import { RelationshipType } from '../../../../../core/shared/item-relationships/relationship-type.model';
 import { RelationshipTypeService } from '../../../../../core/data/relationship-type.service';
-import { getRemoteDataPayload, getSucceededRemoteData } from '../../../../../core/shared/operators';
 
 const DEBOUNCE_TIME = 5000;
 
@@ -36,7 +35,7 @@ export class RelationshipEffects {
 
 
   /**
-   * Effect that makes sure all last fired ObjectUpdatesActions are stored in the map of this service, with the url as their key
+   * Effect that makes sure all last fired RelationshipActions' types are stored in the map of this service, with the object uuid as their key
    */
   @Effect({ dispatch: false }) mapLastActions$ = this.actions$
     .pipe(
@@ -52,6 +51,7 @@ export class RelationshipEffects {
               take(1)
             ).subscribe(
               (type) => {
+                debugger;
                 if (this.initialActionMap[identifier] === type) {
                   if (type === RelationshipActionTypes.ADD_RELATIONSHIP) {
                     let nameVariant = (action as AddRelationshipAction).payload.nameVariant;