inteligr8/alfresco-ng2-components
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-ng2-components.git synced 2025-05-26 17:24:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AAE-12127] Test: The aspect added in config is displayed even if inc… (#8158)

Browse Source 
* [AAE-12127] Test: The aspect added in config is displayed even if includeAll is set to false

* [AAE-12128][AAE-12129][AAE-12131] content metadata tests

* [AAE-12132][AAE-12133] content metadata exif tests

* [AAE-12130] Test: The aspects excluded in config are not displayed when includeAll is set to true
This commit is contained in:
Kasia Biernat 2023-01-25 10:11:37 +01:00 committed by GitHub
parent facc4f6b03
commit 61a3e30c31
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 564 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

267
lib/content-services/src/lib/content-metadata/components/content-metadata/content-metadata.component.spec.ts
View File

@ -18,18 +18,20 @@
import { ComponentFixture, TestBed, tick, fakeAsync } from '@angular/core/testing';
import { SimpleChange } from '@angular/core';
import { By } from '@angular/platform-browser';
import { MinimalNode, Node } from '@alfresco/js-api';
import { ClassesApi, MinimalNode, Node } from '@alfresco/js-api';
import { ContentMetadataComponent } from './content-metadata.component';
import { ContentMetadataService } from '../../services/content-metadata.service';
import {
CardViewBaseItemModel, CardViewComponent, NodesApiService,
LogService, setupTestBed
LogService, setupTestBed, AppConfigService
} from '@alfresco/adf-core';
import { throwError, of } from 'rxjs';
import { ContentTestingModule } from '../../../testing/content.testing.module';
import { mockGroupProperties } from './mock-data';
import { TranslateModule } from '@ngx-translate/core';
import { CardViewContentUpdateService } from '../../../common/services/card-view-content-update.service';
import { PropertyGroup } from '../../interfaces/property-group.interface';
import { PropertyDescriptorsService } from '../../services/property-descriptors.service';
describe('ContentMetadataComponent', () => {
let component: ContentMetadataComponent;
@ -417,6 +419,267 @@ describe('ContentMetadataComponent', () => {
});
});
describe('Display properties with aspect oriented config', () => {
let appConfig: AppConfigService;
let classesApi: ClassesApi;
let expectedNode: MinimalNode;
const versionableResponse: PropertyGroup = {
name: 'cm:versionable',
title: 'Versionable',
properties: {
'cm:autoVersion': {
title: 'Auto Version',
name: 'cm:autoVersion',
dataType: 'd:boolean',
mandatory: false,
multiValued: false
},
'cm:initialVersion': {
title: 'Initial Version',
name: 'cm:initialVersion',
dataType: 'd:boolean',
mandatory: false,
multiValued: false
},
'cm:versionType': {
title: 'Version Type',
name: 'cm:versionType',
dataType: 'd:text',
mandatory: false,
multiValued: false
}
}
};
const exifResponse: PropertyGroup = {
name: 'exif:exif',
title: 'Exif',
properties: {
'exif:1': {
title: 'exif:1:id',
name: 'exif:1',
dataType: '',
mandatory: false,
multiValued: false
},
'exif:2': {
title: 'exif:2:id',
name: 'exif:2',
dataType: '',
mandatory: false,
multiValued: false
},
'exif:pixelXDimension': {
title: 'Image Width',
name: 'exif:pixelXDimension',
dataType: 'd:int',
mandatory: false,
multiValued: false
},
'exif:pixelYDimension': {
title: 'Image Height',
name: 'exif:pixelYDimension',
dataType: 'd:int',
mandatory: false,
multiValued: false
}
}
};
const setContentMetadataConfig = (presetName, presetConfig) => {
appConfig.config['content-metadata'] = {
presets: {
[presetName]: presetConfig
}
};
};
beforeEach(() => {
appConfig = TestBed.inject(AppConfigService);
const propertyDescriptorsService = TestBed.inject(
PropertyDescriptorsService
);
classesApi = propertyDescriptorsService['classesApi'];
expectedNode = {
...node,
aspectNames: [
'rn:renditioned',
'cm:versionable',
'cm:titled',
'cm:auditable',
'cm:author',
'cm:thumbnailModification',
'exif:exif'
],
name: 'some-modified-value',
properties: {
'exif:pixelXDimension': 1024,
'exif:pixelYDimension': 1024
}
};
component.expanded = true;
component.preset = 'default';
});
it('should show Versionable with given content-metadata config', async () => {
setContentMetadataConfig('default', {
includeAll: false,
'cm:versionable': '*'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const versionableProp = queryDom(fixture, 'Versionable');
expect(versionableProp).toBeTruthy();
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should show Versionable twice with given content-metadata config', async () => {
setContentMetadataConfig('default', {
includeAll: true,
'cm:versionable': '*'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const versionableProps = fixture.debugElement.queryAll(By.css('[data-automation-id="adf-metadata-group-Versionable"]'));
expect(versionableProps.length).toEqual(2);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should not show Versionable with given content-metadata config', async () => {
setContentMetadataConfig('default', {
includeAll: true,
exclude: 'cm:versionable'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const versionableProp = queryDom(fixture, 'Versionable');
expect(versionableProp).toBeNull();
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should not show Versionable when excluded and included set in content-metadata config', async () => {
setContentMetadataConfig('default', {
includeAll: true,
exclude: 'cm:versionable',
'cm:versionable': '*'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const versionableProp = queryDom(fixture, 'Versionable');
expect(versionableProp).toBeTruthy();
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should not show aspects excluded in content-metadata config', async () => {
setContentMetadataConfig('default', {
includeAll: true,
exclude: ['cm:versionable', 'cm:auditable']
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const versionableProp = queryDom(fixture, 'Versionable');
expect(versionableProp).toBeNull();
const auditableProp = queryDom(fixture, 'Auditable');
expect(auditableProp).toBeNull();
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
expect(classesApi.getClass).toHaveBeenCalledWith('cm_auditable');
});
it('should show Exif even when includeAll is set to false', async () => {
setContentMetadataConfig('default', {
includeAll: false,
'exif:exif': ['exif:pixelXDimension', 'exif:pixelYDimension']
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(exifResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const exifProp = queryDom(fixture, 'Exif');
expect(exifProp).toBeTruthy();
expect(classesApi.getClass).toHaveBeenCalledWith('exif_exif');
exifProp.nativeElement.click();
const pixelXDimentionElement = fixture.debugElement.query(By.css('[data-automation-id="card-textitem-label-properties.exif:pixelXDimension"]'));
expect(pixelXDimentionElement).toBeTruthy();
expect(pixelXDimentionElement.nativeElement.textContent.trim()).toEqual('Image Width');
const pixelYDimentionElement = fixture.debugElement.query(By.css('[data-automation-id="card-textitem-label-properties.exif:pixelYDimension"]'));
expect(pixelYDimentionElement).toBeTruthy();
expect(pixelYDimentionElement.nativeElement.textContent.trim()).toEqual('Image Height');
});
it('should show Exif twice when includeAll is set to true', async () => {
setContentMetadataConfig('default', {
includeAll: true,
'exif:exif': ['exif:pixelXDimension', 'exif:pixelYDimension']
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(exifResponse));
component.ngOnChanges({ node: new SimpleChange(node, expectedNode, false) });
fixture.detectChanges();
await component.groupedProperties$.toPromise();
fixture.detectChanges();
const exifProps = fixture.debugElement.queryAll(By.css('[data-automation-id="adf-metadata-group-Exif"]'));
expect(exifProps.length).toEqual(2);
expect(classesApi.getClass).toHaveBeenCalledWith('exif_exif');
});
});
describe('Expand the panel', () => {
let expectedNode: MinimalNode;

379
lib/content-services/src/lib/content-metadata/services/content-metadata.service.spec.ts
View File

@ -32,15 +32,30 @@ const fakeNode: Node = {
isFile: true,
aspectNames: ['exif:exif'],
nodeType: 'fn:fakenode',
createdByUser: {displayName: 'test-user'},
modifiedByUser: {displayName: 'test-user-modified'},
createdByUser: { displayName: 'test-user' },
modifiedByUser: { displayName: 'test-user-modified' },
properties: []
} as Node;
const fakeContentNode: Node = { name: 'Node Action', id: 'fake-id', nodeType: 'cm:content', isFile: true, aspectNames: [] } as Node;
const fakeContentNode: Node = {
name: 'Node Action',
id: 'fake-id',
nodeType: 'cm:content',
isFile: true,
aspectNames: [
'rn:renditioned',
'cm:versionable',
'cm:titled',
'cm:auditable',
'cm:author',
'cm:thumbnailModification'
],
createdByUser: { displayName: 'test-user' },
modifiedByUser: { displayName: 'test-user-modified' },
properties: []
} as Node;
describe('ContentMetaDataService', () => {
let service: ContentMetadataService;
let classesApi: ClassesApi;
let appConfig: AppConfigService;
@ -50,8 +65,34 @@ describe('ContentMetaDataService', () => {
name: 'exif:exif',
title: 'Exif',
properties: {
'exif:1': { title: 'exif:1:id', name: 'exif:1', dataType: '', mandatory: false, multiValued: false },
'exif:2': { title: 'exif:2:id', name: 'exif:2', dataType: '', mandatory: false, multiValued: false }
'exif:1': {
title: 'exif:1:id',
name: 'exif:1',
dataType: '',
mandatory: false,
multiValued: false
},
'exif:2': {
title: 'exif:2:id',
name: 'exif:2',
dataType: '',
mandatory: false,
multiValued: false
},
'exif:pixelXDimension': {
title: 'Image Width',
name: 'exif:pixelXDimension',
dataType: 'd:int',
mandatory: false,
multiValued: false
},
'exif:pixelYDimension': {
title: 'Image Height',
name: 'exif:pixelYDimension',
dataType: 'd:int',
mandatory: false,
multiValued: false
}
}
};
@ -59,15 +100,46 @@ describe('ContentMetaDataService', () => {
name: 'cm:content',
title: '',
properties: {
'cm:content': { title: 'cm:content:id', name: 'cm:content', dataType: '', mandatory: false, multiValued: false }
'cm:content': {
title: 'cm:content:id',
name: 'cm:content',
dataType: '',
mandatory: false,
multiValued: false
}
}
};
const versionableResponse: PropertyGroup = {
name: 'cm:versionable',
title: 'Versionable',
properties: {
'cm:autoVersion': {
title: 'Auto Version',
name: 'cm:autoVersion',
dataType: 'd:boolean',
mandatory: false,
multiValued: false
},
'cm:initialVersion': {
title: 'Initial Version',
name: 'cm:initialVersion',
dataType: 'd:boolean',
mandatory: false,
multiValued: false
},
'cm:versionType': {
title: 'Version Type',
name: 'cm:versionType',
dataType: 'd:text',
mandatory: false,
multiValued: false
}
}
};
setupTestBed({
imports: [
TranslateModule.forRoot(),
ContentTestingModule
]
imports: [TranslateModule.forRoot(), ContentTestingModule]
});
const setConfig = (presetName, presetConfig) => {
@ -81,83 +153,217 @@ describe('ContentMetaDataService', () => {
beforeEach(() => {
service = TestBed.inject(ContentMetadataService);
contentPropertyService = TestBed.inject(ContentTypePropertiesService);
const propertyDescriptorsService = TestBed.inject(PropertyDescriptorsService);
const propertyDescriptorsService = TestBed.inject(
PropertyDescriptorsService
);
classesApi = propertyDescriptorsService['classesApi'];
appConfig = TestBed.inject(AppConfigService);
});
it('should return all the properties of the node', () => {
service.getBasicProperties(fakeNode).subscribe(
(res) => {
expect(res.length).toEqual(10);
expect(res[0].value).toEqual('Node');
expect(res[1].value).toBeFalsy();
expect(res[2].value).toBe('test-user');
}
);
service.getBasicProperties(fakeNode).subscribe((res) => {
expect(res.length).toEqual(10);
expect(res[0].value).toEqual('Node');
expect(res[1].value).toBeFalsy();
expect(res[2].value).toBe('test-user');
});
});
it('should return the content type property', () => {
spyOn(contentPropertyService, 'getContentTypeCardItem').and.returnValue(of({ label: 'hello i am a weird content type'} as any));
service.getContentTypeProperty(fakeNode).subscribe(
(res: any) => {
expect(res).toBeDefined();
expect(res).not.toBeNull();
expect(res.label).toBe('hello i am a weird content type');
}
spyOn(contentPropertyService, 'getContentTypeCardItem').and.returnValue(
of({ label: 'hello i am a weird content type' } as any)
);
service.getContentTypeProperty(fakeNode).subscribe((res: any) => {
expect(res).toBeDefined();
expect(res).not.toBeNull();
expect(res.label).toBe('hello i am a weird content type');
});
});
it('should trigger the opening of the content type dialog', () => {
spyOn(contentPropertyService, 'openContentTypeDialogConfirm').and.returnValue(of(true));
spyOn(
contentPropertyService,
'openContentTypeDialogConfirm'
).and.returnValue(of(true));
service.openConfirmDialog(fakeNode).subscribe(
() => {
expect(contentPropertyService.openContentTypeDialogConfirm).toHaveBeenCalledWith('fn:fakenode');
}
);
service.openConfirmDialog(fakeNode).subscribe(() => {
expect(
contentPropertyService.openContentTypeDialogConfirm
).toHaveBeenCalledWith('fn:fakenode');
});
});
describe('AspectOriented preset', () => {
it('should return response with exif property', (done) => {
it('should return response with exif property', async () => {
setConfig('default', { 'exif:exif': '*' });
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(exifResponse));
service.getGroupedProperties(fakeNode).subscribe(
(res) => {
expect(res.length).toEqual(1);
expect(res[0].title).toEqual('Exif');
done();
}
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(exifResponse)
);
const groupedProperties = await service.getGroupedProperties(fakeNode).toPromise();
expect(groupedProperties.length).toEqual(1);
expect(groupedProperties[0].title).toEqual('Exif');
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('exif_exif');
});
it('should filter the record options for node ', (done) => {
it('should filter the record options for node ', async () => {
setConfig('default', { 'exif:exif': '*', 'rma:record': '*' });
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(exifResponse));
service.getGroupedProperties(fakeNode).subscribe(
(res) => {
expect(res.length).toEqual(1);
expect(res[0].title).toEqual('Exif');
done();
}
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(exifResponse)
);
const groupedProperties = await service.getGroupedProperties(fakeNode).toPromise();
expect(groupedProperties.length).toEqual(1);
expect(groupedProperties[0].title).toEqual('Exif');
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('exif_exif');
});
});
it('should return response with versionable property', async () => {
setConfig('default', {
includeAll: false,
'cm:versionable': '*'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
const groupedProperties = await service.getGroupedProperties(fakeContentNode).toPromise();
expect(groupedProperties.length).toEqual(1);
expect(groupedProperties[0].title).toEqual('Versionable');
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should return response with versionable property twice', async () => {
setConfig('default', {
includeAll: true,
'cm:versionable': '*'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
const groupedProperties = await service.getGroupedProperties(fakeContentNode).toPromise();
expect(groupedProperties.length).toEqual(2);
expect(groupedProperties[0].title).toEqual('Versionable');
expect(groupedProperties[1].title).toEqual('Versionable');
expect(classesApi.getClass).toHaveBeenCalledTimes(1 + fakeContentNode.aspectNames.length);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should return response with versionable excluded', async () => {
setConfig('default', {
includeAll: true,
exclude: 'cm:versionable'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
const groupedProperties = await service.getGroupedProperties(fakeContentNode).toPromise();
expect(groupedProperties.length).toEqual(0);
expect(classesApi.getClass).toHaveBeenCalledTimes(1 + fakeContentNode.aspectNames.length);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should return response with versionable visible when excluded and included set', async () => {
setConfig('default', {
includeAll: true,
exclude: 'cm:versionable',
'cm:versionable': '*'
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
const groupedProperties = await service.getGroupedProperties(fakeContentNode).toPromise();
expect(groupedProperties.length).toEqual(1);
expect(groupedProperties[0].title).toEqual('Versionable');
expect(classesApi.getClass).toHaveBeenCalledTimes(1 + fakeContentNode.aspectNames.length);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
});
it('should not show aspects excluded in content-metadata config', async () => {
setConfig('default', {
includeAll: true,
exclude: ['cm:versionable', 'cm:auditable']
});
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(versionableResponse));
const groupedProperties = await service.getGroupedProperties(fakeContentNode).toPromise();
expect(groupedProperties.length).toEqual(0);
expect(classesApi.getClass).toHaveBeenCalledTimes(1 + fakeContentNode.aspectNames.length);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_versionable');
expect(classesApi.getClass).toHaveBeenCalledWith('cm_auditable');
});
it('should return response with exif visible even when includeAll is set to false', async () => {
setConfig('default', {
includeAll: false,
'exif:exif': ['exif:pixelXDimension', 'exif:pixelYDimension']
});
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(exifResponse)
);
const groupedProperties = await service.getGroupedProperties(fakeNode).toPromise();
expect(groupedProperties.length).toEqual(1);
expect(groupedProperties[0].title).toEqual('Exif');
expect(groupedProperties[0].properties.length).toEqual(2);
expect(groupedProperties[0].properties[0].label).toEqual('Image Width');
expect(groupedProperties[0].properties[1].label).toEqual('Image Height');
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('exif_exif');
});
it('should return response with exif visible twice when includeAll is set to true', async () => {
setConfig('default', {
includeAll: true,
'exif:exif': ['exif:pixelXDimension', 'exif:pixelYDimension']
});
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(exifResponse)
);
const groupedProperties = await service.getGroupedProperties(fakeNode).toPromise();
expect(groupedProperties.length).toEqual(2);
expect(groupedProperties[0].title).toEqual('Exif');
expect(groupedProperties[1].title).toEqual('Exif');
expect(groupedProperties[0].properties.length).toEqual(4);
expect(groupedProperties[1].properties.length).toEqual(2);
expect(groupedProperties[0].properties[0].label).toEqual('exif:1:id');
expect(groupedProperties[0].properties[1].label).toEqual('exif:2:id');
expect(groupedProperties[0].properties[2].label).toEqual('Image Width');
expect(groupedProperties[0].properties[3].label).toEqual('Image Height');
expect(groupedProperties[1].properties[0].label).toEqual('Image Width');
expect(groupedProperties[1].properties[1].label).toEqual('Image Height');
expect(classesApi.getClass).toHaveBeenCalledTimes(2);
expect(classesApi.getClass).toHaveBeenCalledWith('exif_exif');
});
});
describe('LayoutOriented preset', () => {
it('should return the node property', (done) => {
const customLayoutOrientedScheme = [
{
@ -174,15 +380,17 @@ describe('ContentMetaDataService', () => {
];
setConfig('custom', customLayoutOrientedScheme);
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(contentResponse));
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(contentResponse)
);
service.getGroupedProperties(fakeContentNode, 'custom').subscribe(
(res) => {
service
.getGroupedProperties(fakeContentNode, 'custom')
.subscribe((res) => {
expect(res.length).toEqual(1);
expect(res[0].title).toEqual('Properties');
done();
}
);
});
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_content');
@ -215,15 +423,17 @@ describe('ContentMetaDataService', () => {
];
setConfig('custom', customLayoutOrientedScheme);
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(contentResponse));
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(contentResponse)
);
service.getGroupedProperties(fakeContentNode, 'custom').subscribe(
(res) => {
service
.getGroupedProperties(fakeContentNode, 'custom')
.subscribe((res) => {
expect(res.length).toEqual(1);
expect(res[0].title).toEqual('Properties');
done();
}
);
});
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_content');
@ -247,22 +457,24 @@ describe('ContentMetaDataService', () => {
];
setConfig('custom', customLayoutOrientedScheme);
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(contentResponse));
service.getGroupedProperties(fakeContentNode, 'custom').subscribe(
(res) => {
expect(res.length).toEqual(0);
done();
}
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(contentResponse)
);
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
service
.getGroupedProperties(fakeContentNode, 'custom')
.subscribe((res) => {
expect(res.length).toEqual(0);
done();
});
expect(classesApi.getClass).toHaveBeenCalledTimes(1 + fakeContentNode.aspectNames.length);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_content');
});
});
describe('Provided preset config', () => {
it('should create the metadata config on the fly when preset config is provided', (done) => {
it('should create the metadata config on the fly when preset config is provided', (done) => {
const customLayoutOrientedScheme = [
{
id: 'app.content.metadata.customGroup',
@ -288,17 +500,24 @@ describe('ContentMetaDataService', () => {
}
];
spyOn(classesApi, 'getClass').and.returnValue(Promise.resolve(contentResponse));
spyOn(classesApi, 'getClass').and.returnValue(
Promise.resolve(contentResponse)
);
service.getGroupedProperties(fakeContentNode, customLayoutOrientedScheme).subscribe(
(res) => {
service
.getGroupedProperties(
fakeContentNode,
customLayoutOrientedScheme
)
.subscribe((res) => {
expect(res.length).toEqual(1);
expect(res[0].title).toEqual('Properties');
expect(classesApi.getClass).toHaveBeenCalledTimes(1);
expect(classesApi.getClass).toHaveBeenCalledWith('cm_content');
expect(classesApi.getClass).toHaveBeenCalledWith(
'cm_content'
);
done();
}
);
});
});
});
});