hazza/dspace-angular
1
0
Fork 1
mirror of https://github.com/DSpace/dspace-angular.git synced 2025-10-18 15:33:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

71380: Fix tests

Browse Source
This commit is contained in:
Kristof De Langhe
2020-06-17 13:12:49 +02:00
parent c6ee46fdea
commit 752cf97787
4 changed files with 38 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.spec.ts
View File

@@ -188,8 +188,21 @@ describe('ItemBitstreamsComponent', () => {
it('should not call deleteAndReturnResponse on the bitstreamService for the unmarked field', () => {
expect(bitstreamService.deleteAndReturnResponse).not.toHaveBeenCalledWith(bitstream1.id);
});
});
it('should send out a patch for the move operations', () => {
describe('when dropBitstream is called', () => {
const event = {
fromIndex: 0,
toIndex: 50,
// tslint:disable-next-line:no-empty
finish: () => {}
};
beforeEach(() => {
comp.dropBitstream(bundle, event);
});
it('should send out a patch for the move operation', () => {
expect(bundleService.patch).toHaveBeenCalled();
});
});

74
src/app/core/data/object-updates/object-updates.reducer.spec.ts
View File

@@ -1,9 +1,9 @@
import * as deepFreeze from 'deep-freeze';
import {
AddFieldUpdateAction, AddPageToCustomOrderAction,
AddFieldUpdateAction,
DiscardObjectUpdatesAction,
FieldChangeType,
InitializeFieldsAction, MoveFieldUpdateAction,
InitializeFieldsAction,
ReinstateObjectUpdatesAction, RemoveAllObjectUpdatesAction,
RemoveFieldUpdateAction, RemoveObjectUpdatesAction, SelectVirtualMetadataAction,
SetEditableFieldUpdateAction, SetValidFieldUpdateAction
@@ -85,16 +85,6 @@ describe('objectUpdatesReducer', () => {
virtualMetadataSources: {
[relationship.uuid]: {[identifiable1.uuid]: true}
},
customOrder: {
initialOrderPages: [
{ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
],
newOrderPages: [
{ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
],
pageSize: 10,
changed: false
}
}
};
@@ -121,16 +111,6 @@ describe('objectUpdatesReducer', () => {
virtualMetadataSources: {
[relationship.uuid]: {[identifiable1.uuid]: true}
},
customOrder: {
initialOrderPages: [
{ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
],
newOrderPages: [
{ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
],
pageSize: 10,
changed: false
}
},
[url + OBJECT_UPDATES_TRASH_PATH]: {
fieldStates: {
@@ -165,16 +145,6 @@ describe('objectUpdatesReducer', () => {
virtualMetadataSources: {
[relationship.uuid]: {[identifiable1.uuid]: true}
},
customOrder: {
initialOrderPages: [
{ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
],
newOrderPages: [
{ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
],
pageSize: 10,
changed: false
}
}
};
@@ -243,7 +213,7 @@ describe('objectUpdatesReducer', () => {
});
it('should initialize all fields when the INITIALIZE action is dispatched, based on the payload', () => {
const action = new InitializeFieldsAction(url, [identifiable1, identifiable3], modDate, [identifiable1.uuid, identifiable3.uuid], 10, 0);
const action = new InitializeFieldsAction(url, [identifiable1, identifiable3], modDate);
const expectedState = {
[url]: {
@@ -261,17 +231,7 @@ describe('objectUpdatesReducer', () => {
},
fieldUpdates: {},
virtualMetadataSources: {},
lastModified: modDate,
customOrder: {
initialOrderPages: [
{ order: [identifiable1.uuid, identifiable3.uuid] }
],
newOrderPages: [
{ order: [identifiable1.uuid, identifiable3.uuid] }
],
pageSize: 10,
changed: false
}
lastModified: modDate
}
};
const newState = objectUpdatesReducer(testState, action);
@@ -337,30 +297,4 @@ describe('objectUpdatesReducer', () => {
const newState = objectUpdatesReducer(testState, action);
expect(newState[url].fieldUpdates[uuid]).toBeUndefined();
});
it('should move the custom order from the state when the MOVE action is dispatched', () => {
const action = new MoveFieldUpdateAction(url, 0, 1, 0, 0);
const newState = objectUpdatesReducer(testState, action);
expect(newState[url].customOrder.newOrderPages[0].order[0]).toEqual(testState[url].customOrder.newOrderPages[0].order[1]);
expect(newState[url].customOrder.newOrderPages[0].order[1]).toEqual(testState[url].customOrder.newOrderPages[0].order[0]);
expect(newState[url].customOrder.changed).toEqual(true);
});
it('should add a new page to the custom order and add empty pages in between when the ADD_PAGE_TO_CUSTOM_ORDER action is dispatched', () => {
const identifiable4 = {
uuid: 'a23eae5a-7857-4ef9-8e52-989436ad2955',
key: 'dc.description.abstract',
language: null,
value: 'Extra value'
};
const action = new AddPageToCustomOrderAction(url, [identifiable4], [identifiable4.uuid], 2);
const newState = objectUpdatesReducer(testState, action);
// Confirm the page in between the two pages (index 1) has been filled with 10 (page size) undefined values
expect(newState[url].customOrder.newOrderPages[1].order.length).toEqual(10);
expect(newState[url].customOrder.newOrderPages[1].order[0]).toBeUndefined();
// Verify the new page is correct
expect(newState[url].customOrder.newOrderPages[2].order[0]).toEqual(identifiable4.uuid);
});
});

113
src/app/core/data/object-updates/object-updates.service.spec.ts
View File

@@ -2,7 +2,6 @@ import { Store } from '@ngrx/store';
import { CoreState } from '../../core.reducers';
import { ObjectUpdatesService } from './object-updates.service';
import {
AddPageToCustomOrderAction,
DiscardObjectUpdatesAction,
FieldChangeType,
InitializeFieldsAction, ReinstateObjectUpdatesAction, RemoveFieldUpdateAction, SelectVirtualMetadataAction,
@@ -13,8 +12,6 @@ import { Notification } from '../../../shared/notifications/models/notification.
import { NotificationType } from '../../../shared/notifications/models/notification-type';
import { OBJECT_UPDATES_TRASH_PATH } from './object-updates.reducer';
import {Relationship} from '../../shared/item-relationships/relationship.model';
import { MoveOperation } from 'fast-json-patch/lib/core';
import { ArrayMoveChangeAnalyzer } from '../array-move-change-analyzer.service';
describe('ObjectUpdatesService', () => {
let service: ObjectUpdatesService;
@@ -47,7 +44,7 @@ describe('ObjectUpdatesService', () => {
};
store = new Store<CoreState>(undefined, undefined, undefined);
spyOn(store, 'dispatch');
service = new ObjectUpdatesService(store, new ArrayMoveChangeAnalyzer<string>());
service = new ObjectUpdatesService(store);
spyOn(service as any, 'getObjectEntry').and.returnValue(observableOf(objectEntry));
spyOn(service as any, 'getFieldState').and.callFake((uuid) => {
@@ -63,25 +60,6 @@ describe('ObjectUpdatesService', () => {
});
});
describe('initializeWithCustomOrder', () => {
const pageSize = 20;
const page = 0;
it('should dispatch an INITIALIZE action with the correct URL, initial identifiables, last modified , custom order, page size and page', () => {
service.initializeWithCustomOrder(url, identifiables, modDate, pageSize, page);
expect(store.dispatch).toHaveBeenCalledWith(new InitializeFieldsAction(url, identifiables, modDate, identifiables.map((identifiable) => identifiable.uuid), pageSize, page));
});
});
describe('addPageToCustomOrder', () => {
const page = 2;
it('should dispatch an ADD_PAGE_TO_CUSTOM_ORDER action with the correct URL, identifiables, custom order and page number to add', () => {
service.addPageToCustomOrder(url, identifiables, page);
expect(store.dispatch).toHaveBeenCalledWith(new AddPageToCustomOrderAction(url, identifiables, identifiables.map((identifiable) => identifiable.uuid), page));
});
});
describe('getFieldUpdates', () => {
it('should return the list of all fields, including their update if there is one', () => {
const result$ = service.getFieldUpdates(url, identifiables);
@@ -116,49 +94,6 @@ describe('ObjectUpdatesService', () => {
});
});
describe('getFieldUpdatesByCustomOrder', () => {
beforeEach(() => {
const fieldStates = {
[identifiable1.uuid]: { editable: false, isNew: false, isValid: true },
[identifiable2.uuid]: { editable: true, isNew: false, isValid: false },
[identifiable3.uuid]: { editable: true, isNew: true, isValid: true },
};
const customOrder = {
initialOrderPages: [{
order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid]
}],
newOrderPages: [{
order: [identifiable2.uuid, identifiable3.uuid, identifiable1.uuid]
}],
pageSize: 20,
changed: true
};
const objectEntry = {
fieldStates, fieldUpdates, lastModified: modDate, virtualMetadataSources: {}, customOrder
};
(service as any).getObjectEntry.and.returnValue(observableOf(objectEntry))
});
it('should return the list of all fields, including their update if there is one, ordered by their custom order', (done) => {
const result$ = service.getFieldUpdatesByCustomOrder(url, identifiables);
expect((service as any).getObjectEntry).toHaveBeenCalledWith(url);
const expectedResult = {
[identifiable2.uuid]: { field: identifiable2, changeType: undefined },
[identifiable3.uuid]: { field: identifiable3, changeType: FieldChangeType.ADD },
[identifiable1.uuid]: { field: identifiable1Updated, changeType: FieldChangeType.UPDATE }
};
result$.subscribe((result) => {
expect(result).toEqual(expectedResult);
done();
});
});
});
describe('isEditable', () => {
it('should return false if this identifiable is currently not editable in the store', () => {
const result$ = service.isEditable(url, identifiable1.uuid);
@@ -274,11 +209,7 @@ describe('ObjectUpdatesService', () => {
});
describe('when updates are emtpy', () => {
beforeEach(() => {
(service as any).getObjectEntry.and.returnValue(observableOf({
customOrder: {
changed: false
}
}))
(service as any).getObjectEntry.and.returnValue(observableOf({}))
});
it('should return false when there are no updates', () => {
@@ -346,44 +277,4 @@ describe('ObjectUpdatesService', () => {
});
});
describe('getMoveOperations', () => {
beforeEach(() => {
const fieldStates = {
[identifiable1.uuid]: { editable: false, isNew: false, isValid: true },
[identifiable2.uuid]: { editable: true, isNew: false, isValid: false },
[identifiable3.uuid]: { editable: true, isNew: true, isValid: true },
};
const customOrder = {
initialOrderPages: [{
order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid]
}],
newOrderPages: [{
order: [identifiable2.uuid, identifiable3.uuid, identifiable1.uuid]
}],
pageSize: 20,
changed: true
};
const objectEntry = {
fieldStates, fieldUpdates, lastModified: modDate, virtualMetadataSources: {}, customOrder
};
(service as any).getObjectEntry.and.returnValue(observableOf(objectEntry))
});
it('should return the expected move operations', (done) => {
const result$ = service.getMoveOperations(url);
const expectedResult = [
{ op: 'move', from: '/0', path: '/2' }
] as MoveOperation[];
result$.subscribe((result) => {
expect(result).toEqual(expectedResult);
done();
});
});
});
});

79
src/app/shared/pagination-drag-and-drop/abstract-paginated-drag-and-drop-list.component.spec.ts
View File

@@ -52,10 +52,8 @@ describe('AbstractPaginatedDragAndDropListComponent', () => {
beforeEach(() => {
objectUpdatesService = jasmine.createSpyObj('objectUpdatesService', {
initializeWithCustomOrder: {},
addPageToCustomOrder: {},
getFieldUpdatesByCustomOrder: observableOf(updates),
saveMoveFieldUpdate: {}
initialize: {},
getFieldUpdatesExclusive: observableOf(updates)
});
elRef = {
nativeElement: jasmine.createSpyObj('nativeElement', {
@@ -71,13 +69,8 @@ describe('AbstractPaginatedDragAndDropListComponent', () => {
component.ngOnInit();
});
it('should call initializeWithCustomOrder to initialize the first page and add it to initializedPages', (done) => {
expect(component.initializedPages.indexOf(0)).toBeLessThan(0);
component.updates$.pipe(take(1)).subscribe(() => {
expect(objectUpdatesService.initializeWithCustomOrder).toHaveBeenCalled();
expect(component.initializedPages.indexOf(0)).toBeGreaterThanOrEqual(0);
done();
});
it('should call initialize to initialize the objects in the store', () => {
expect(objectUpdatesService.initialize).toHaveBeenCalled();
});
it('should initialize the updates correctly', (done) => {
@@ -87,43 +80,6 @@ describe('AbstractPaginatedDragAndDropListComponent', () => {
});
});
describe('when a new page is loaded', () => {
const page = 5;
beforeEach((done) => {
component.updates$.pipe(take(1)).subscribe(() => {
component.currentPage$.next(page);
objectsRD$.next(objectsRD);
done();
});
});
it('should call addPageToCustomOrder to initialize the new page and add it to initializedPages', (done) => {
component.updates$.pipe(take(1)).subscribe(() => {
expect(objectUpdatesService.addPageToCustomOrder).toHaveBeenCalled();
expect(component.initializedPages.indexOf(page - 1)).toBeGreaterThanOrEqual(0);
done();
});
});
describe('twice', () => {
beforeEach((done) => {
component.updates$.pipe(take(1)).subscribe(() => {
component.currentPage$.next(page);
objectsRD$.next(objectsRD);
done();
});
});
it('shouldn\'t call addPageToCustomOrder again, as the page has already been initialized', (done) => {
component.updates$.pipe(take(1)).subscribe(() => {
expect(objectUpdatesService.addPageToCustomOrder).toHaveBeenCalledTimes(1);
done();
});
});
});
});
describe('switchPage', () => {
const page = 3;
@@ -149,30 +105,31 @@ describe('AbstractPaginatedDragAndDropListComponent', () => {
beforeEach(() => {
elRef.nativeElement.querySelector.and.returnValue(hoverElement);
component.initializedPages.push(hoverPage - 1);
spyOn(component.dropObject, 'emit');
component.drop(event);
});
it('should detect the page and set currentPage$ to its value', () => {
expect(component.currentPage$.value).toEqual(hoverPage);
});
it('should detect the page and update the pagination component with its value', () => {
expect(paginationComponent.doPageChange).toHaveBeenCalledWith(hoverPage);
});
it('should send out a saveMoveFieldUpdate with the correct values', () => {
expect(objectUpdatesService.saveMoveFieldUpdate).toHaveBeenCalledWith(url, event.previousIndex, 0, 0, hoverPage - 1, object1);
it('should send out a dropObject event with the expected processed paginated indexes', () => {
expect(component.dropObject.emit).toHaveBeenCalledWith(Object.assign({
fromIndex: ((component.currentPage$.value - 1) * component.pageSize) + event.previousIndex,
toIndex: ((hoverPage - 1) * component.pageSize),
finish: jasmine.anything()
}));
});
});
describe('when the user is not hovering over a new page', () => {
beforeEach(() => {
spyOn(component.dropObject, 'emit');
component.drop(event);
});
it('should send out a saveMoveFieldUpdate with the correct values', () => {
expect(objectUpdatesService.saveMoveFieldUpdate).toHaveBeenCalledWith(url, event.previousIndex, event.currentIndex, 0, 0);
it('should send out a dropObject event with the expected properties', () => {
expect(component.dropObject.emit).toHaveBeenCalledWith(Object.assign({
fromIndex: event.previousIndex,
toIndex: event.currentIndex,
finish: jasmine.anything()
}));
});
});
});