[PRODENG-211] integrate JS-API with monorepo (part 1) (#9081)

* integrate JS-API with monorepo

* [ci:force] fix token issue

[ci:force] migrate docs folder

[ci:force] clean personal tokens

* [ci:force] gha workflow support

* [ci:force] npm publish target

* fix js-api test linting

* [ci:force] fix test linting, mocks, https scheme

* [ci:force] fix https scheme

* [ci:force] typescript mappings

* [ci:force] update scripts

* lint fixes

* linting fixes

* fix linting

* [ci:force] linting fixes

* linting fixes

* [ci:force] remove js-api upstream and corresponding scripts

* [ci:force] jsdoc fixes

* fix jsdoc linting

* [ci:force] jsdoc fixes

* [ci:force] jsdoc fixes

* jsdoc fixes

* jsdoc fixes

* jsdoc fixes

* [ci:force] fix jsdoc

* [ci:force] reduce code duplication

* replace 'chai' expect with node.js assert

* replace 'chai' expect with node.js assert

* [ci:force] remove chai and chai-spies for js-api testing

* [ci:force] cleanup and fix imports

* [ci:force] fix linting

* [ci:force] fix unit test

* [ci:force] fix sonar linting findings

* [ci:force] switch activiti api models to interfaces (-2.5% reduction of bundle)

* [ci:force] switch activiti api models to interfaces

* [ci:force] switch AGS api models to interfaces

* [ci:force] switch AGS api models to interfaces

* [ci:force] switch search api models to interfaces

* [ci:force] switch content api models to interfaces where applicable
This commit is contained in:
Denys Vuika
2023-11-21 10:27:51 +00:00
committed by GitHub
parent 804fa2ffd4
commit ea2c0ce229
1334 changed files with 82605 additions and 1068 deletions

View File

@@ -0,0 +1,95 @@
/*!
* @license
* Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import assert from 'assert';
import { AlfrescoApi, NodeSecurityMarkBody, SecurityMarkEntry, SecurityMarkPaging, AuthorityClearanceApi } from '../../src';
import { AuthorityClearanceMock, EcmAuthMock } from '../mockObjects';
const DEFAULT_OPTS = {
skipCount: 0,
maxItems: 100
};
describe('Authority Clearance API test', () => {
let authResponseMock: EcmAuthMock;
let authorityClearanceMock: AuthorityClearanceMock;
let authorityClearanceApi: AuthorityClearanceApi;
const nodeSecurityMarkBodyList: Array<NodeSecurityMarkBody> = [
{
groupId: 'securityGroupFruits',
op: 'ADD',
id: 'fruitMarkId1'
},
{
groupId: 'securityGroupFruits',
op: 'ADD',
id: 'fruitMarkId1'
}
];
const nodeSecurityMarkBodySingle: Array<NodeSecurityMarkBody> = [
{
groupId: 'securityGroupFruits',
op: 'ADD',
id: 'fruitMarkId1'
}
];
beforeEach(async () => {
const hostEcm = 'https://127.0.0.1:8080';
authResponseMock = new EcmAuthMock(hostEcm);
authResponseMock.get201Response();
authorityClearanceMock = new AuthorityClearanceMock(hostEcm);
const alfrescoApi = new AlfrescoApi({
hostEcm
});
authorityClearanceApi = new AuthorityClearanceApi(alfrescoApi);
await alfrescoApi.login('admin', 'admin');
});
it('get authority clearances for an authority', async () => {
const nodeId = 'testAuthorityId';
authorityClearanceMock.get200AuthorityClearanceForAuthority(nodeId);
await authorityClearanceApi.getAuthorityClearanceForAuthority(nodeId, DEFAULT_OPTS).then((response) => {
assert.equal(response.list.entries[0].entry.id, 'securityGroupFruits');
assert.equal(response.list.entries[0].entry.displayLabel, 'Security Group FRUITS');
assert.equal(response.list.entries[0].entry.type, 'USER_REQUIRES_ALL');
assert.equal(response.list.entries[0].entry.marks.length, 3);
});
});
it('add single security marks to an authority', async () => {
const nodeId = 'testAuthorityId';
authorityClearanceMock.post200AuthorityClearanceWithSingleItem(nodeId);
await authorityClearanceApi.updateAuthorityClearance(nodeId, nodeSecurityMarkBodySingle).then((data) => {
const response = data as SecurityMarkEntry;
assert.equal(response.entry.id, 'fruitMarkId1');
assert.equal(response.entry.name, 'APPLES');
assert.equal(response.entry.groupId, 'securityGroupFruits');
});
});
it('add multiple security marks on an authority', async () => {
const nodeId = 'testAuthorityId';
authorityClearanceMock.post200AuthorityClearanceWithList(nodeId);
await authorityClearanceApi.updateAuthorityClearance(nodeId, nodeSecurityMarkBodyList).then((data) => {
const response = data as SecurityMarkPaging;
assert.equal(response.list.entries[0].entry.id, 'fruitMarkId1');
assert.equal(response.list.entries[0].entry.name, 'APPLES');
assert.equal(response.list.entries[0].entry.groupId, 'securityGroupFruits');
});
});
});

View File

@@ -0,0 +1,50 @@
/*!
* @license
* Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import assert from 'assert';
import { AlfrescoApi, GsSitesApi } from '../../src';
import { EcmAuthMock, GsSitesApiMock } from '../mockObjects';
describe('Governance API test', () => {
let authResponseMock: EcmAuthMock;
let gsSitesApiMock: GsSitesApiMock;
let gsSitesApi: GsSitesApi;
beforeEach(() => {
const hostEcm = 'https://127.0.0.1:8080';
authResponseMock = new EcmAuthMock(hostEcm);
authResponseMock.get201Response();
gsSitesApiMock = new GsSitesApiMock(hostEcm);
const alfrescoJsApi = new AlfrescoApi({
hostEcm
});
gsSitesApi = new GsSitesApi(alfrescoJsApi);
});
it('should getRMSite return the RM site', (done) => {
gsSitesApiMock.get200Response();
gsSitesApi.getRMSite().then((data) => {
assert.equal(data.entry.description, 'Records Management Description Test');
done();
});
});
});

View File

@@ -0,0 +1,70 @@
/*!
* @license
* Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import assert from 'assert';
import { AlfrescoApi, NodeSecurityMarksApi, NodeSecurityMarkBody } from '../../src';
import { EcmAuthMock, NodeSecurityMarksApiMock } from '../mockObjects';
describe('Node Security Mark API test', () => {
let authResponseMock: EcmAuthMock;
let nodeSecurityMarksMock: NodeSecurityMarksApiMock;
let nodeSecurityMarksApi: NodeSecurityMarksApi;
const nodeSecurityMarkBody: Array<NodeSecurityMarkBody> = [
{
groupId: 'securityGroupId1',
op: 'ADD',
id: 'Sh1G8vTQ'
},
{
groupId: 'securityGroupId2',
op: 'ADD',
id: 'Sh1G8vTR'
}
];
beforeEach(async () => {
const hostEcm = 'https://127.0.0.1:8080';
authResponseMock = new EcmAuthMock(hostEcm);
authResponseMock.get201Response();
nodeSecurityMarksMock = new NodeSecurityMarksApiMock(hostEcm);
const alfrescoApi = new AlfrescoApi({
hostEcm
});
nodeSecurityMarksApi = new NodeSecurityMarksApi(alfrescoApi);
await alfrescoApi.login('admin', 'admin');
});
it('add or remove security marks on a node', async () => {
const nodeId = 'h3bdk2knw2kn';
nodeSecurityMarksMock.post200manageSecurityMarkOnNode(nodeId);
await nodeSecurityMarksApi.manageSecurityMarksOnNode(nodeId, nodeSecurityMarkBody).then((data) => {
assert.equal(data.list.entries[0].entry.groupId, 'securityGroupId1');
assert.equal(data.list.entries[0].entry.id, 'Sh1G8vTQ');
assert.equal(data.list.entries[0].entry.name, 'SecurityMarkTest1');
});
});
it('get security marks on a node', async () => {
const nodeId = 'h3bdk2knw2kn';
nodeSecurityMarksMock.get200SecurityMarkOnNode(nodeId);
await nodeSecurityMarksApi.getSecurityMarksOnNode(nodeId).then((data) => {
assert.equal(data.list.entries[1].entry.groupId, 'securityGroupId2');
assert.equal(data.list.entries[1].entry.id, 'Sh1G8vTR');
assert.equal(data.list.entries[1].entry.name, 'SecurityMarkTest2');
});
});
});

View File

@@ -0,0 +1,93 @@
/*!
* @license
* Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { AlfrescoApi, SecurityGroupsApi, SecurityGroupBody } from '../../src';
import assert from 'assert';
import { EcmAuthMock, SecurityGroupApiMock } from '../mockObjects';
describe('Security Group API test', () => {
let authResponseMock: EcmAuthMock;
let securityGroupMock: SecurityGroupApiMock;
let securityGroupApi: SecurityGroupsApi;
const securityGroupBody: SecurityGroupBody = {
groupName: 'Alfresco',
groupType: 'HIERARCHICAL'
};
let securityGroupId: string;
beforeEach(async () => {
const hostEcm = 'https://127.0.0.1:8080';
authResponseMock = new EcmAuthMock(hostEcm);
authResponseMock.get201Response();
securityGroupMock = new SecurityGroupApiMock(hostEcm);
const alfrescoApi = new AlfrescoApi({
hostEcm
});
securityGroupApi = new SecurityGroupsApi(alfrescoApi);
await alfrescoApi.login('admin', 'admin');
});
it('create Security Group', async () => {
securityGroupMock.createSecurityGroup200Response();
await securityGroupApi.createSecurityGroup(securityGroupBody).then((data) => {
securityGroupId = data.entry.id;
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.groupName, 'Alfresco');
assert.equal(data.entry.groupType, 'HIERARCHICAL');
});
});
it('get All Security Groups', async () => {
securityGroupMock.getSecurityGroups200Response();
await securityGroupApi.getSecurityGroups().then((data) => {
assert.equal(data.list.entries.length > 0, true);
});
});
it('get Security Group Information', async () => {
securityGroupMock.getSecurityGroupInfo200Response(securityGroupId);
await securityGroupApi.getSecurityGroupInfo(securityGroupId).then((data) => {
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.groupName, 'Alfresco');
assert.equal(data.entry.groupType, 'HIERARCHICAL');
});
});
it('update Security Group', async () => {
securityGroupMock.updateSecurityGroup200Response(securityGroupId);
const updatedSecurityGroupBody: SecurityGroupBody = {
groupName: 'Nasa'
};
await securityGroupApi.updateSecurityGroup(securityGroupId, updatedSecurityGroupBody).then((data) => {
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.groupName, 'Nasa');
assert.equal(data.entry.groupType, 'HIERARCHICAL');
});
});
it('delete Security Group', async () => {
securityGroupMock.deleteSecurityGroup200Response(securityGroupId);
await securityGroupApi
.deleteSecurityGroup(securityGroupId)
.then((data) => {
Promise.resolve(data);
})
.catch((err) => {
Promise.reject(err);
});
});
});

View File

@@ -0,0 +1,130 @@
/*!
* @license
* Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import assert from 'assert';
import { AlfrescoApi, SecurityGroupBody, SecurityGroupsApi, SecurityMarkBody, SecurityMarksApi, SecurityMarksBody } from '../../src';
import { EcmAuthMock, SecurityGroupApiMock, SecurityMarkApiMock } from '../mockObjects';
describe('Security Mark API test', () => {
let authResponseMock: EcmAuthMock;
let securityMarkApiMock: SecurityMarkApiMock;
let securityGroupMock: SecurityGroupApiMock;
let securityGroupApi: SecurityGroupsApi;
let securityMarksApi: SecurityMarksApi;
let securityGroupId = 'a0a7b107-84ba-4c3d-b0b7-a8509e8c1c33';
let securityMarkId = 'Sh1G8vTQ';
const securityMarksBodySingle: SecurityMarksBody = [
{
name: 'SecurityMarkTest'
}
];
const securityGroupBody: SecurityGroupBody = {
groupName: 'Alfresco',
groupType: 'HIERARCHICAL'
};
const securityMarksBody: SecurityMarksBody = [
{
name: 'SecurityMark3'
},
{
name: 'SecurityMark4'
}
];
beforeEach(async () => {
const hostEcm = 'https://127.0.0.1:8080';
authResponseMock = new EcmAuthMock(hostEcm);
authResponseMock.get201Response();
securityGroupMock = new SecurityGroupApiMock(hostEcm);
securityMarkApiMock = new SecurityMarkApiMock(hostEcm);
const alfrescoApi = new AlfrescoApi({
hostEcm
});
securityGroupApi = new SecurityGroupsApi(alfrescoApi);
securityMarksApi = new SecurityMarksApi(alfrescoApi);
await alfrescoApi.login('admin', 'admin');
});
it('create Security Group', async () => {
securityGroupMock.createSecurityGroup200Response();
await securityGroupApi.createSecurityGroup(securityGroupBody).then((data) => {
securityGroupId = data.entry.id;
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.groupName, 'Alfresco');
assert.equal(data.entry.groupType, 'HIERARCHICAL');
});
});
it('create Security Mark', async () => {
securityMarkApiMock.createSecurityMark200Response(securityGroupId);
await securityMarksApi.createSecurityMarks(securityGroupId, securityMarksBodySingle).then((data: any) => {
securityMarkId = data.entry.id;
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.name, 'SecurityMarkTest');
assert.equal(data.entry.groupId, securityGroupId);
});
});
it('create multiple Security Mark', async () => {
securityMarkApiMock.createSecurityMarks200Response(securityGroupId);
await securityMarksApi.createSecurityMarks(securityGroupId, securityMarksBody).then((data: any) => {
assert.notEqual(data.list.entries[0].entry.id, null);
assert.equal(data.list.entries[0].entry.name, 'SecurityMark3');
assert.equal(data.list.entries[0].entry.groupId, securityGroupId);
});
});
it('get All Security Marks', async () => {
securityMarkApiMock.get200GetSecurityMark(securityGroupId);
await securityMarksApi.getSecurityMarks(securityGroupId).then((data) => {
assert.equal(data.list.entries.length > 0, true);
});
});
it('get Security Mark Information', async () => {
securityMarkApiMock.get200GetSingleSecurityMark(securityGroupId, securityMarkId);
await securityMarksApi.getSecurityMark(securityGroupId, securityMarkId).then((data) => {
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.name, 'SecurityMarkTest');
assert.equal(data.entry.groupId, securityGroupId);
});
});
it('update Security Mark', async () => {
const updatedSecurityMarkBody: SecurityMarkBody = {
name: 'AlfrescoSecurityMark'
};
securityMarkApiMock.put200UpdateSecurityMarkResponse(securityGroupId, securityMarkId);
await securityMarksApi.updateSecurityMark(securityGroupId, securityMarkId, updatedSecurityMarkBody).then((data) => {
assert.notEqual(data.entry.id, null);
assert.equal(data.entry.name, 'AlfrescoSecurityMark');
assert.equal(data.entry.groupId, securityGroupId);
});
});
it('delete Security Mark', async () => {
securityMarkApiMock.getDeleteSecurityMarkSuccessfulResponse(securityGroupId, securityMarkId);
await securityGroupApi
.deleteSecurityGroup(securityGroupId)
.then((data) => {
Promise.resolve(data);
})
.catch((err) => {
Promise.reject(err);
});
});
});