mirror of
https://github.com/DSpace/dspace-angular.git
synced 2025-10-07 01:54:15 +00:00
662 lines
23 KiB
TypeScript
662 lines
23 KiB
TypeScript
import { EditBitstreamPageComponent } from './edit-bitstream-page.component';
|
|
import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
|
|
import { TranslateModule } from '@ngx-translate/core';
|
|
import { RouterTestingModule } from '@angular/router/testing';
|
|
import { ActivatedRoute, Router } from '@angular/router';
|
|
import { of as observableOf } from 'rxjs';
|
|
import { DynamicFormControlModel, DynamicFormService } from '@ng-dynamic-forms/core';
|
|
import { NotificationsService } from '../../shared/notifications/notifications.service';
|
|
import { BitstreamDataService } from '../../core/data/bitstream-data.service';
|
|
import { ChangeDetectorRef, NO_ERRORS_SCHEMA } from '@angular/core';
|
|
import { BitstreamFormatDataService } from '../../core/data/bitstream-format-data.service';
|
|
import { Bitstream } from '../../core/shared/bitstream.model';
|
|
import { NotificationType } from '../../shared/notifications/models/notification-type';
|
|
import { INotification, Notification } from '../../shared/notifications/models/notification.model';
|
|
import { BitstreamFormat } from '../../core/shared/bitstream-format.model';
|
|
import { BitstreamFormatSupportLevel } from '../../core/shared/bitstream-format-support-level';
|
|
import { hasValue } from '../../shared/empty.util';
|
|
import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
|
|
import { FileSizePipe } from '../../shared/utils/file-size-pipe';
|
|
import { VarDirective } from '../../shared/utils/var.directive';
|
|
import { createSuccessfulRemoteDataObject, createSuccessfulRemoteDataObject$ } from '../../shared/remote-data.utils';
|
|
import { getEntityEditRoute } from '../../item-page/item-page-routing-paths';
|
|
import { createPaginatedList } from '../../shared/testing/utils.test';
|
|
import { Item } from '../../core/shared/item.model';
|
|
import { MetadataValueFilter } from '../../core/shared/metadata.models';
|
|
import { DSONameService } from '../../core/breadcrumbs/dso-name.service';
|
|
import { PrimaryBitstreamService } from '../../core/data/primary-bitstream.service';
|
|
|
|
const infoNotification: INotification = new Notification('id', NotificationType.Info, 'info');
|
|
const warningNotification: INotification = new Notification('id', NotificationType.Warning, 'warning');
|
|
const successNotification: INotification = new Notification('id', NotificationType.Success, 'success');
|
|
|
|
let notificationsService: NotificationsService;
|
|
let formService: DynamicFormService;
|
|
let bitstreamService: BitstreamDataService;
|
|
let primaryBitstreamService: PrimaryBitstreamService;
|
|
let bitstreamFormatService: BitstreamFormatDataService;
|
|
let dsoNameService: DSONameService;
|
|
let bitstream: Bitstream;
|
|
let bitstreamID: string;
|
|
let selectedFormat: BitstreamFormat;
|
|
let allFormats: BitstreamFormat[];
|
|
let router: Router;
|
|
let currentPrimary: string;
|
|
let differentPrimary: string;
|
|
let bundle;
|
|
let comp: EditBitstreamPageComponent;
|
|
let fixture: ComponentFixture<EditBitstreamPageComponent>;
|
|
|
|
describe('EditBitstreamPageComponent', () => {
|
|
|
|
beforeEach(() => {
|
|
bitstreamID = 'current-bitstream-id';
|
|
currentPrimary = bitstreamID;
|
|
differentPrimary = '12345-abcde-54321-edcba';
|
|
|
|
allFormats = [
|
|
Object.assign({
|
|
id: '1',
|
|
shortDescription: 'Unknown',
|
|
description: 'Unknown format',
|
|
supportLevel: BitstreamFormatSupportLevel.Unknown,
|
|
mimetype: 'application/octet-stream',
|
|
_links: {
|
|
self: { href: 'format-selflink-1' }
|
|
}
|
|
}),
|
|
Object.assign({
|
|
id: '2',
|
|
shortDescription: 'PNG',
|
|
description: 'Portable Network Graphics',
|
|
supportLevel: BitstreamFormatSupportLevel.Known,
|
|
mimetype: 'image/png',
|
|
_links: {
|
|
self: { href: 'format-selflink-2' }
|
|
}
|
|
}),
|
|
Object.assign({
|
|
id: '3',
|
|
shortDescription: 'GIF',
|
|
description: 'Graphics Interchange Format',
|
|
supportLevel: BitstreamFormatSupportLevel.Known,
|
|
mimetype: 'image/gif',
|
|
_links: {
|
|
self: { href: 'format-selflink-3' }
|
|
}
|
|
})
|
|
] as BitstreamFormat[];
|
|
selectedFormat = allFormats[1];
|
|
|
|
formService = Object.assign({
|
|
createFormGroup: (fModel: DynamicFormControlModel[]) => {
|
|
const controls = {};
|
|
if (hasValue(fModel)) {
|
|
fModel.forEach((controlModel) => {
|
|
controls[controlModel.id] = new UntypedFormControl((controlModel as any).value);
|
|
});
|
|
return new UntypedFormGroup(controls);
|
|
}
|
|
return undefined;
|
|
}
|
|
});
|
|
|
|
bitstreamFormatService = jasmine.createSpyObj('bitstreamFormatService', {
|
|
findAll: createSuccessfulRemoteDataObject$(createPaginatedList(allFormats))
|
|
});
|
|
|
|
notificationsService = jasmine.createSpyObj('notificationsService',
|
|
{
|
|
info: infoNotification,
|
|
warning: warningNotification,
|
|
success: successNotification
|
|
}
|
|
);
|
|
|
|
bundle = {
|
|
_links: {
|
|
primaryBitstream: {
|
|
href: 'bundle-selflink'
|
|
}
|
|
},
|
|
item: createSuccessfulRemoteDataObject$(Object.assign(new Item(), {
|
|
uuid: 'some-uuid',
|
|
firstMetadataValue(keyOrKeys: string | string[], valueFilter?: MetadataValueFilter): string {
|
|
return undefined;
|
|
},
|
|
}))
|
|
};
|
|
|
|
const result = createSuccessfulRemoteDataObject$(bundle);
|
|
primaryBitstreamService = jasmine.createSpyObj('PrimaryBitstreamService',
|
|
{
|
|
put: result,
|
|
create: result,
|
|
delete: result,
|
|
});
|
|
|
|
});
|
|
|
|
describe('EditBitstreamPageComponent no IIIF fields', () => {
|
|
|
|
beforeEach(waitForAsync(() => {
|
|
bundle = {
|
|
_links: {
|
|
primaryBitstream: {
|
|
href: 'bundle-selflink'
|
|
}
|
|
},
|
|
item: createSuccessfulRemoteDataObject$(Object.assign(new Item(), {
|
|
uuid: 'some-uuid',
|
|
firstMetadataValue(keyOrKeys: string | string[], valueFilter?: MetadataValueFilter): string {
|
|
return undefined;
|
|
},
|
|
}))
|
|
};
|
|
const bundleName = 'ORIGINAL';
|
|
|
|
bitstream = Object.assign(new Bitstream(), {
|
|
uuid: bitstreamID,
|
|
id: bitstreamID,
|
|
metadata: {
|
|
'dc.description': [
|
|
{
|
|
value: 'Bitstream description'
|
|
}
|
|
],
|
|
'dc.title': [
|
|
{
|
|
value: 'Bitstream title'
|
|
}
|
|
]
|
|
},
|
|
format: createSuccessfulRemoteDataObject$(selectedFormat),
|
|
_links: {
|
|
self: 'bitstream-selflink'
|
|
},
|
|
bundle: createSuccessfulRemoteDataObject$(bundle)
|
|
});
|
|
bitstreamService = jasmine.createSpyObj('bitstreamService', {
|
|
findById: createSuccessfulRemoteDataObject$(bitstream),
|
|
findByHref: createSuccessfulRemoteDataObject$(bitstream),
|
|
update: createSuccessfulRemoteDataObject$(bitstream),
|
|
updateFormat: createSuccessfulRemoteDataObject$(bitstream),
|
|
commitUpdates: {},
|
|
patch: {}
|
|
});
|
|
bitstreamFormatService = jasmine.createSpyObj('bitstreamFormatService', {
|
|
findAll: createSuccessfulRemoteDataObject$(createPaginatedList(allFormats))
|
|
});
|
|
dsoNameService = jasmine.createSpyObj('dsoNameService', {
|
|
getName: bundleName
|
|
});
|
|
|
|
TestBed.configureTestingModule({
|
|
imports: [TranslateModule.forRoot(), RouterTestingModule],
|
|
declarations: [EditBitstreamPageComponent, FileSizePipe, VarDirective],
|
|
providers: [
|
|
{ provide: NotificationsService, useValue: notificationsService },
|
|
{ provide: DynamicFormService, useValue: formService },
|
|
{
|
|
provide: ActivatedRoute,
|
|
useValue: {
|
|
data: observableOf({ bitstream: createSuccessfulRemoteDataObject(bitstream) }),
|
|
snapshot: { queryParams: {} }
|
|
}
|
|
},
|
|
{ provide: BitstreamDataService, useValue: bitstreamService },
|
|
{ provide: DSONameService, useValue: dsoNameService },
|
|
{ provide: BitstreamFormatDataService, useValue: bitstreamFormatService },
|
|
{ provide: PrimaryBitstreamService, useValue: primaryBitstreamService },
|
|
ChangeDetectorRef
|
|
],
|
|
schemas: [NO_ERRORS_SCHEMA]
|
|
}).compileComponents();
|
|
|
|
}));
|
|
|
|
beforeEach(() => {
|
|
fixture = TestBed.createComponent(EditBitstreamPageComponent);
|
|
comp = fixture.componentInstance;
|
|
fixture.detectChanges();
|
|
router = TestBed.inject(Router);
|
|
spyOn(router, 'navigate');
|
|
});
|
|
|
|
describe('on startup', () => {
|
|
let rawForm;
|
|
|
|
beforeEach(() => {
|
|
rawForm = comp.formGroup.getRawValue();
|
|
});
|
|
|
|
it('should fill in the bitstream\'s title', () => {
|
|
expect(rawForm.fileNamePrimaryContainer.fileName).toEqual(bitstream.name);
|
|
});
|
|
|
|
it('should fill in the bitstream\'s description', () => {
|
|
expect(rawForm.descriptionContainer.description).toEqual(bitstream.firstMetadataValue('dc.description'));
|
|
});
|
|
|
|
it('should select the correct format', () => {
|
|
expect(rawForm.formatContainer.selectedFormat).toEqual(selectedFormat.shortDescription);
|
|
});
|
|
|
|
it('should put the \"New Format\" input on invisible', () => {
|
|
expect(comp.formLayout.newFormat.grid.host).toContain('invisible');
|
|
});
|
|
describe('when the bitstream is the primary bitstream on the bundle', () => {
|
|
beforeEach(() => {
|
|
(comp as any).primaryBitstreamUUID = currentPrimary;
|
|
comp.setForm();
|
|
rawForm = comp.formGroup.getRawValue();
|
|
|
|
});
|
|
it('should enable the primary bitstream toggle', () => {
|
|
expect(rawForm.fileNamePrimaryContainer.primaryBitstream).toEqual(true);
|
|
});
|
|
});
|
|
describe('when the bitstream is not the primary bitstream on the bundle', () => {
|
|
beforeEach(() => {
|
|
(comp as any).primaryBitstreamUUID = differentPrimary;
|
|
comp.setForm();
|
|
rawForm = comp.formGroup.getRawValue();
|
|
});
|
|
it('should disable the primary bitstream toggle', () => {
|
|
expect(rawForm.fileNamePrimaryContainer.primaryBitstream).toEqual(false);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when an unknown format is selected', () => {
|
|
beforeEach(() => {
|
|
comp.onChange({
|
|
model: {
|
|
id: 'selectedFormat',
|
|
value: allFormats[0],
|
|
},
|
|
});
|
|
comp.updateNewFormatLayout();
|
|
});
|
|
|
|
it('should remove the invisible class from the \"New Format\" input', () => {
|
|
expect(comp.formLayout.newFormat.grid.host).not.toContain('invisible');
|
|
});
|
|
});
|
|
|
|
describe('onSubmit', () => {
|
|
describe('when the primaryBitstream changed', () => {
|
|
describe('to the current bitstream', () => {
|
|
beforeEach(() => {
|
|
const rawValue = Object.assign(comp.formGroup.getRawValue(), { fileNamePrimaryContainer: { primaryBitstream: true } });
|
|
spyOn(comp.formGroup, 'getRawValue').and.returnValue(rawValue);
|
|
});
|
|
|
|
describe('from a different primary bitstream', () => {
|
|
beforeEach(() => {
|
|
(comp as any).primaryBitstreamUUID = differentPrimary;
|
|
comp.onSubmit();
|
|
});
|
|
|
|
it('should call put with the correct bitstream on the PrimaryBitstreamService', () => {
|
|
expect(primaryBitstreamService.put).toHaveBeenCalledWith(jasmine.objectContaining({uuid: currentPrimary}), bundle);
|
|
});
|
|
});
|
|
|
|
describe('from no primary bitstream', () => {
|
|
beforeEach(() => {
|
|
(comp as any).primaryBitstreamUUID = null;
|
|
comp.onSubmit();
|
|
});
|
|
|
|
it('should call create with the correct bitstream on the PrimaryBitstreamService', () => {
|
|
expect(primaryBitstreamService.create).toHaveBeenCalledWith(jasmine.objectContaining({uuid: currentPrimary}), bundle);
|
|
});
|
|
});
|
|
});
|
|
describe('to no primary bitstream', () => {
|
|
beforeEach(() => {
|
|
const rawValue = Object.assign(comp.formGroup.getRawValue(), { fileNamePrimaryContainer: { primaryBitstream: false } });
|
|
spyOn(comp.formGroup, 'getRawValue').and.returnValue(rawValue);
|
|
});
|
|
|
|
describe('from the current bitstream', () => {
|
|
beforeEach(() => {
|
|
(comp as any).primaryBitstreamUUID = currentPrimary;
|
|
comp.onSubmit();
|
|
});
|
|
|
|
it('should call delete on the PrimaryBitstreamService', () => {
|
|
expect(primaryBitstreamService.delete).toHaveBeenCalledWith(jasmine.objectContaining(bundle));
|
|
});
|
|
});
|
|
});
|
|
});
|
|
describe('when the primaryBitstream did not change', () => {
|
|
describe('the current bitstream stayed the primary bitstream', () => {
|
|
beforeEach(() => {
|
|
const rawValue = Object.assign(comp.formGroup.getRawValue(), { fileNamePrimaryContainer: { primaryBitstream: true } });
|
|
spyOn(comp.formGroup, 'getRawValue').and.returnValue(rawValue);
|
|
(comp as any).primaryBitstreamUUID = currentPrimary;
|
|
comp.onSubmit();
|
|
});
|
|
it('should not call anything on the PrimaryBitstreamService', () => {
|
|
expect(primaryBitstreamService.put).not.toHaveBeenCalled();
|
|
expect(primaryBitstreamService.delete).not.toHaveBeenCalled();
|
|
expect(primaryBitstreamService.create).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('the bitstream was not and did not become the primary bitstream', () => {
|
|
beforeEach(() => {
|
|
const rawValue = Object.assign(comp.formGroup.getRawValue(), { fileNamePrimaryContainer: { primaryBitstream: false } });
|
|
spyOn(comp.formGroup, 'getRawValue').and.returnValue(rawValue);
|
|
(comp as any).primaryBitstreamUUID = differentPrimary;
|
|
comp.onSubmit();
|
|
});
|
|
it('should not call anything on the PrimaryBitstreamService', () => {
|
|
expect(primaryBitstreamService.put).not.toHaveBeenCalled();
|
|
expect(primaryBitstreamService.delete).not.toHaveBeenCalled();
|
|
expect(primaryBitstreamService.create).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when selected format hasn\'t changed', () => {
|
|
beforeEach(() => {
|
|
comp.onSubmit();
|
|
});
|
|
|
|
it('should call update', () => {
|
|
expect(bitstreamService.update).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should commit the updates', () => {
|
|
expect(bitstreamService.commitUpdates).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('when selected format has changed', () => {
|
|
beforeEach(() => {
|
|
comp.onChange({
|
|
model: {
|
|
id: 'selectedFormat',
|
|
value: allFormats[2],
|
|
},
|
|
});
|
|
fixture.detectChanges();
|
|
comp.onSubmit();
|
|
});
|
|
|
|
it('should call update', () => {
|
|
expect(bitstreamService.update).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should call updateFormat', () => {
|
|
expect(bitstreamService.updateFormat).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should commit the updates', () => {
|
|
expect(bitstreamService.commitUpdates).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|
|
describe('when the cancel button is clicked', () => {
|
|
it('should call navigateToItemEditBitstreams method', () => {
|
|
spyOn(comp, 'navigateToItemEditBitstreams');
|
|
comp.onCancel();
|
|
expect(comp.navigateToItemEditBitstreams).toHaveBeenCalled();
|
|
});
|
|
});
|
|
describe('when navigateToItemEditBitstreams is called', () => {
|
|
it('should redirect to the item edit page on the bitstreams tab with the itemId from the component', () => {
|
|
comp.itemId = 'some-uuid1';
|
|
comp.navigateToItemEditBitstreams();
|
|
expect(router.navigate).toHaveBeenCalledWith([getEntityEditRoute(null, 'some-uuid1'), 'bitstreams']);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('EditBitstreamPageComponent with IIIF fields', () => {
|
|
|
|
const bundleName = 'ORIGINAL';
|
|
|
|
beforeEach(waitForAsync(() => {
|
|
|
|
bitstream = Object.assign(new Bitstream(), {
|
|
metadata: {
|
|
'dc.description': [
|
|
{
|
|
value: 'Bitstream description'
|
|
}
|
|
],
|
|
'dc.title': [
|
|
{
|
|
value: 'Bitstream title'
|
|
}
|
|
],
|
|
'iiif.label': [
|
|
{
|
|
value: 'chapter one'
|
|
}
|
|
],
|
|
'iiif.toc': [
|
|
{
|
|
value: 'chapter one'
|
|
}
|
|
],
|
|
'iiif.image.width': [
|
|
{
|
|
value: '2400'
|
|
}
|
|
],
|
|
'iiif.image.height': [
|
|
{
|
|
value: '2800'
|
|
}
|
|
],
|
|
},
|
|
format: createSuccessfulRemoteDataObject$(allFormats[1]),
|
|
_links: {
|
|
self: 'bitstream-selflink'
|
|
},
|
|
bundle: createSuccessfulRemoteDataObject$({
|
|
_links: {
|
|
primaryBitstream: {
|
|
href: 'bundle-selflink'
|
|
}
|
|
},
|
|
item: createSuccessfulRemoteDataObject$(Object.assign(new Item(), {
|
|
uuid: 'some-uuid',
|
|
firstMetadataValue(keyOrKeys: string | string[], valueFilter?: MetadataValueFilter): string {
|
|
return 'True';
|
|
}
|
|
}))
|
|
}),
|
|
});
|
|
bitstreamService = jasmine.createSpyObj('bitstreamService', {
|
|
findById: createSuccessfulRemoteDataObject$(bitstream),
|
|
findByHref: createSuccessfulRemoteDataObject$(bitstream),
|
|
update: createSuccessfulRemoteDataObject$(bitstream),
|
|
updateFormat: createSuccessfulRemoteDataObject$(bitstream),
|
|
commitUpdates: {},
|
|
patch: {}
|
|
});
|
|
|
|
dsoNameService = jasmine.createSpyObj('dsoNameService', {
|
|
getName: bundleName
|
|
});
|
|
|
|
TestBed.configureTestingModule({
|
|
imports: [TranslateModule.forRoot(), RouterTestingModule],
|
|
declarations: [EditBitstreamPageComponent, FileSizePipe, VarDirective],
|
|
providers: [
|
|
{provide: NotificationsService, useValue: notificationsService},
|
|
{provide: DynamicFormService, useValue: formService},
|
|
{
|
|
provide: ActivatedRoute,
|
|
useValue: {
|
|
data: observableOf({bitstream: createSuccessfulRemoteDataObject(bitstream)}),
|
|
snapshot: {queryParams: {}}
|
|
}
|
|
},
|
|
{provide: BitstreamDataService, useValue: bitstreamService},
|
|
{provide: DSONameService, useValue: dsoNameService},
|
|
{provide: BitstreamFormatDataService, useValue: bitstreamFormatService},
|
|
{ provide: PrimaryBitstreamService, useValue: primaryBitstreamService },
|
|
ChangeDetectorRef
|
|
],
|
|
schemas: [NO_ERRORS_SCHEMA]
|
|
}).compileComponents();
|
|
}));
|
|
|
|
beforeEach(() => {
|
|
fixture = TestBed.createComponent(EditBitstreamPageComponent);
|
|
comp = fixture.componentInstance;
|
|
fixture.detectChanges();
|
|
router = TestBed.inject(Router);
|
|
spyOn(router, 'navigate');
|
|
});
|
|
|
|
describe('on startup', () => {
|
|
let rawForm;
|
|
|
|
beforeEach(() => {
|
|
rawForm = comp.formGroup.getRawValue();
|
|
});
|
|
it('should set isIIIF to true', () => {
|
|
expect(comp.isIIIF).toBeTrue();
|
|
});
|
|
it('should fill in the iiif label', () => {
|
|
expect(rawForm.iiifLabelContainer.iiifLabel).toEqual('chapter one');
|
|
});
|
|
it('should fill in the iiif toc', () => {
|
|
expect(rawForm.iiifTocContainer.iiifToc).toEqual('chapter one');
|
|
});
|
|
it('should fill in the iiif width', () => {
|
|
expect(rawForm.iiifWidthContainer.iiifWidth).toEqual('2400');
|
|
});
|
|
it('should fill in the iiif height', () => {
|
|
expect(rawForm.iiifHeightContainer.iiifHeight).toEqual('2800');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('ignore OTHERCONTENT bundle', () => {
|
|
|
|
const bundleName = 'OTHERCONTENT';
|
|
|
|
beforeEach(waitForAsync(() => {
|
|
|
|
bitstream = Object.assign(new Bitstream(), {
|
|
metadata: {
|
|
'dc.description': [
|
|
{
|
|
value: 'Bitstream description'
|
|
}
|
|
],
|
|
'dc.title': [
|
|
{
|
|
value: 'Bitstream title'
|
|
}
|
|
],
|
|
'iiif.label': [
|
|
{
|
|
value: 'chapter one'
|
|
}
|
|
],
|
|
'iiif.toc': [
|
|
{
|
|
value: 'chapter one'
|
|
}
|
|
],
|
|
'iiif.image.width': [
|
|
{
|
|
value: '2400'
|
|
}
|
|
],
|
|
'iiif.image.height': [
|
|
{
|
|
value: '2800'
|
|
}
|
|
],
|
|
},
|
|
format: createSuccessfulRemoteDataObject$(allFormats[2]),
|
|
_links: {
|
|
self: 'bitstream-selflink'
|
|
},
|
|
bundle: createSuccessfulRemoteDataObject$({
|
|
_links: {
|
|
primaryBitstream: {
|
|
href: 'bundle-selflink'
|
|
}
|
|
},
|
|
item: createSuccessfulRemoteDataObject$(Object.assign(new Item(), {
|
|
uuid: 'some-uuid',
|
|
firstMetadataValue(keyOrKeys: string | string[], valueFilter?: MetadataValueFilter): string {
|
|
return 'True';
|
|
}
|
|
}))
|
|
}),
|
|
});
|
|
bitstreamService = jasmine.createSpyObj('bitstreamService', {
|
|
findById: createSuccessfulRemoteDataObject$(bitstream),
|
|
findByHref: createSuccessfulRemoteDataObject$(bitstream),
|
|
update: createSuccessfulRemoteDataObject$(bitstream),
|
|
updateFormat: createSuccessfulRemoteDataObject$(bitstream),
|
|
commitUpdates: {},
|
|
patch: {}
|
|
});
|
|
|
|
dsoNameService = jasmine.createSpyObj('dsoNameService', {
|
|
getName: bundleName
|
|
});
|
|
|
|
TestBed.configureTestingModule({
|
|
imports: [TranslateModule.forRoot(), RouterTestingModule],
|
|
declarations: [EditBitstreamPageComponent, FileSizePipe, VarDirective],
|
|
providers: [
|
|
{provide: NotificationsService, useValue: notificationsService},
|
|
{provide: DynamicFormService, useValue: formService},
|
|
{provide: ActivatedRoute,
|
|
useValue: {
|
|
data: observableOf({bitstream: createSuccessfulRemoteDataObject(bitstream)}),
|
|
snapshot: {queryParams: {}}
|
|
}
|
|
},
|
|
{provide: BitstreamDataService, useValue: bitstreamService},
|
|
{provide: DSONameService, useValue: dsoNameService},
|
|
{provide: BitstreamFormatDataService, useValue: bitstreamFormatService},
|
|
{ provide: PrimaryBitstreamService, useValue: primaryBitstreamService },
|
|
ChangeDetectorRef
|
|
],
|
|
schemas: [NO_ERRORS_SCHEMA]
|
|
}).compileComponents();
|
|
}));
|
|
|
|
beforeEach(() => {
|
|
fixture = TestBed.createComponent(EditBitstreamPageComponent);
|
|
comp = fixture.componentInstance;
|
|
fixture.detectChanges();
|
|
router = TestBed.inject(Router);
|
|
spyOn(router, 'navigate');
|
|
});
|
|
|
|
describe('EditBitstreamPageComponent with IIIF fields', () => {
|
|
let rawForm;
|
|
|
|
beforeEach(() => {
|
|
rawForm = comp.formGroup.getRawValue();
|
|
});
|
|
|
|
it('should NOT set is IIIF to true', () => {
|
|
expect(comp.isIIIF).toBeFalse();
|
|
});
|
|
it('should put the \"IIIF Label\" input not to be shown', () => {
|
|
expect(rawForm.iiifLabelContainer).toBeFalsy();
|
|
});
|
|
});
|
|
});
|
|
|
|
});
|