@eclipse-glsp/server 2.8.0-next.5 → 2.8.0-next.6

package/src/common/features/directediting/request-edit-validation-handler.spec.ts

@@ -1,131 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { GNode } from '@eclipse-glsp/graph';
-import { RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-import { TestContextEditValidator, TestLabelEditValidator } from '../../test/mock-util';
-import { GModelIndex } from '../model/gmodel-index';
-import { DefaultModelState } from '../model/model-state';
-import { ContextEditValidator } from './context-edit-validator';
-import { DefaultContextEditValidatorRegistry } from './context-edit-validator-registry';
-import { LabelEditValidator } from './label-edit-validator';
-import { RequestEditValidationHandler } from './request-edit-validation-handler';
-
-describe('Test RequestEditValidationHandler', () => {
-    const contextEditValidators: ContextEditValidator[] = [new TestContextEditValidator()];
-    const modelState = new DefaultModelState();
-    Object.defineProperty(modelState, 'index', { value: new GModelIndex() });
-    sinon.stub(modelState.index, 'get').callsFake(() => new GNode());
-    const contextEditValidatorsRegistry = new DefaultContextEditValidatorRegistry(
-        modelState,
-        contextEditValidators,
-        new TestLabelEditValidator()
-    );
-
-    const requestEditValidationHandler = new RequestEditValidationHandler();
-    requestEditValidationHandler['contextEditValidatorRegistry'] = contextEditValidatorsRegistry;
-
-    it('requestContextEditValidation with ok result', async () => {
-        const actions = await requestEditValidationHandler.execute(
-            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'ok' })
-        );
-        expect(actions).to.have.length(1);
-        const action = actions[0];
-
-        expect(SetEditValidationResultAction.is(action)).to.be.true;
-        const setEditValidationResultAction = action as SetEditValidationResultAction;
-        const status = setEditValidationResultAction.status;
-
-        expect(status.severity).to.be.equal(ValidationStatus.Severity.OK);
-        expect(status.message).to.be.equal('ok');
-    });
-
-    it('requestContextEditValidation with warning result', async () => {
-        const actions = await requestEditValidationHandler.execute(
-            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'warning' })
-        );
-        expect(actions).to.have.length(1);
-        const action = actions[0];
-
-        expect(SetEditValidationResultAction.is(action)).to.be.true;
-        const setEditValidationResultAction = action as SetEditValidationResultAction;
-        const status = setEditValidationResultAction.status;
-
-        expect(status.severity).to.be.equal(ValidationStatus.Severity.WARNING);
-        expect(status.message).to.be.equal('warning');
-    });
-
-    it('requestContextEditValidation with error result', async () => {
-        const actions = await requestEditValidationHandler.execute(
-            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'error' })
-        );
-        expect(actions).to.have.length(1);
-        const action = actions[0];
-
-        expect(SetEditValidationResultAction.is(action)).to.be.true;
-        const setEditValidationResultAction = action as SetEditValidationResultAction;
-        const status = setEditValidationResultAction.status;
-
-        expect(status.severity).to.be.equal(ValidationStatus.Severity.ERROR);
-        expect(status.message).to.be.equal('error');
-    });
-
-    it('requestLabelEditValidation with ok result', async () => {
-        const actions = await requestEditValidationHandler.execute(
-            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'ok' })
-        );
-        expect(actions).to.have.length(1);
-        const action = actions[0];
-
-        expect(SetEditValidationResultAction.is(action)).to.be.true;
-        const setEditValidationResultAction = action as SetEditValidationResultAction;
-        const status = setEditValidationResultAction.status;
-
-        expect(status.severity).to.be.equal(ValidationStatus.Severity.OK);
-        expect(status.message).to.be.equal('ok');
-    });
-
-    it('requestLabelEditValidation with warning result', async () => {
-        const actions = await requestEditValidationHandler.execute(
-            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'warning' })
-        );
-        expect(actions).to.have.length(1);
-        const action = actions[0];
-
-        expect(SetEditValidationResultAction.is(action)).to.be.true;
-        const setEditValidationResultAction = action as SetEditValidationResultAction;
-        const status = setEditValidationResultAction.status;
-
-        expect(status.severity).to.be.equal(ValidationStatus.Severity.WARNING);
-        expect(status.message).to.be.equal('warning');
-    });
-
-    it('requestLabelEditValidation with error result', async () => {
-        const actions = await requestEditValidationHandler.execute(
-            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'error' })
-        );
-        expect(actions).to.have.length(1);
-        const action = actions[0];
-
-        expect(SetEditValidationResultAction.is(action)).to.be.true;
-        const setEditValidationResultAction = action as SetEditValidationResultAction;
-        const status = setEditValidationResultAction.status;
-
-        expect(status.severity).to.be.equal(ValidationStatus.Severity.ERROR);
-        expect(status.message).to.be.equal('error');
-    });
-});

package/src/common/features/model/gmodel-serializer.spec.ts

@@ -1,141 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { GEdge, getDefaultMapping, GGraph, GNode } from '@eclipse-glsp/graph';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { DiagramConfiguration } from '../../diagram/diagram-configuration';
-import * as mock from '../../test/mock-util';
-import { GLSPServerError } from '../../utils/glsp-server-error';
-import { Logger } from '../../utils/logger';
-import { DefaultGModelSerializer } from './gmodel-serializer';
-
-class TestNode extends GNode {
-    foo(): void {
-        // should not be serialized to schema
-    }
-}
-
-let testRootSchema: any;
-
-let testNodeSchema: any;
-
-let testNodeSchemaWithParent: any;
-
-describe('test DefaultGModelSerializer', () => {
-    const container = new Container();
-    const diagramConfiguration = new mock.StubDiagramConfiguration();
-    diagramConfiguration['typeMapping'] = getDefaultMapping();
-    diagramConfiguration.typeMapping.set('node', TestNode);
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new mock.StubLogger());
-            bind(DiagramConfiguration).toConstantValue(diagramConfiguration);
-        })
-    );
-
-    const serializer = container.resolve(DefaultGModelSerializer);
-
-    beforeEach(() => {
-        testRootSchema = {
-            id: 'graph',
-            type: 'graph',
-            children: [
-                { id: 'node1', type: 'node', position: { x: 5, y: 10 } },
-                { id: 'node2', type: 'node', position: { x: 15, y: 5 } },
-                { id: 'edge1', type: 'edge', sourceId: 'node1', targetId: 'node2' }
-            ]
-        };
-        testNodeSchema = { id: 'node1', type: 'node', position: { x: 5, y: 10 }, children: [], cssClasses: [] };
-        testNodeSchemaWithParent = {
-            id: 'node1',
-            type: 'node',
-            position: { x: 5, y: 10 },
-            children: [],
-            cssClasses: [],
-            parent: new GNode()
-        };
-    });
-
-    it('createElement - unregistered type', () => {
-        testNodeSchema['type'] = 'notRegistered';
-        expect(() => serializer.createElement(testNodeSchema)).to.throw(GLSPServerError);
-    });
-
-    it('createElement - with root schema', () => {
-        expect(() => serializer.createElement(testRootSchema)).to.throw(GLSPServerError);
-    });
-
-    it('createElement - with node schema', () => {
-        const node = serializer.createElement(testNodeSchema);
-        expect(node).to.be.an.instanceOf(TestNode);
-        expect(node).to.be.deep.include(testNodeSchema);
-        expect((node as TestNode).foo).to.not.be.undefined;
-    });
-
-    it('createElement- with sub type of registered schema', () => {
-        testNodeSchema.type = 'node:rectangular';
-        const node = serializer.createElement(testNodeSchema);
-        expect(node).to.be.an.instanceOf(TestNode);
-        expect(node).to.be.deep.include(testNodeSchema);
-        expect((node as TestNode).foo).to.not.be.undefined;
-    });
-
-    it('createElement - with parent', () => {
-        const parent = new GNode();
-        const child = serializer.createElement(testNodeSchema, parent);
-        expect(child).to.be.an.instanceOf(TestNode);
-        expect(child).to.be.deep.include(testNodeSchemaWithParent);
-        expect(child.parent).to.be.equal(parent);
-    });
-
-    it('createRoot - unregistered type', () => {
-        testRootSchema['type'] = 'notRegistered';
-        expect(() => serializer.createRoot(testNodeSchema)).to.throw(GLSPServerError);
-    });
-
-    it('createRoot - with child schema ', () => {
-        expect(() => serializer.createRoot(testNodeSchema)).to.throw(GLSPServerError);
-    });
-
-    it('createRoot - with registered root schema', () => {
-        const root = serializer.createRoot(testRootSchema);
-        expect(root).to.be.an.instanceOf(GGraph);
-        expect(root.children.length).to.be.equal(3);
-        const node1 = root.children[0];
-        expect(node1).to.be.an.instanceOf(TestNode);
-        const node2 = root.children[1];
-        expect(node2).to.be.an.instanceOf(TestNode);
-        expect(root.children[2]).to.be.an.instanceOf(GEdge);
-        const edge = root.children[2] as GEdge;
-        expect(edge.sourceId).to.be.equal(node1.id);
-        expect(edge.targetId).to.be.equal(node2.id);
-    });
-
-    it('createSchema- unregistered type', () => {
-        expect(() => serializer.createRoot({ id: 'id', type: 'unregistered' })).to.throw(GLSPServerError);
-    });
-
-    it('createSchema- with node', () => {
-        const testNode = new TestNode();
-        testNode.position = { x: 5, y: 10 };
-        testNode.size = { width: 10, height: 100 };
-        testNode.layoutOptions = { ['my']: 'Options' };
-        const schema = serializer.createSchema(testNode);
-        delete (testNode as Partial<TestNode>).foo;
-        expect(schema).to.be.deep.include(testNode);
-    });
-});

package/src/common/features/type-hints/request-type-hints-action-handler.spec.ts

@@ -1,59 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { EdgeTypeHint, RequestTypeHintsAction, SetTypeHintsAction, ShapeTypeHint } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { DiagramConfiguration } from '../../diagram/diagram-configuration';
-import * as mock from '../../test/mock-util';
-import { RequestTypeHintsActionHandler } from './request-type-hints-action-handler';
-
-describe('test RequestTypeHintsActionHandler', () => {
-    const container = new Container();
-    const diagramConfiguration = new mock.StubDiagramConfiguration();
-    const shapeTypeHint: ShapeTypeHint = {
-        elementTypeId: 'test',
-        deletable: true,
-        resizable: true,
-        repositionable: true,
-        reparentable: true
-    };
-    const edgeTypeHint: EdgeTypeHint = {
-        elementTypeId: 'test',
-        deletable: true,
-        repositionable: true,
-        routable: true,
-        sourceElementTypeIds: [],
-        targetElementTypeIds: []
-    };
-    diagramConfiguration.shapeTypeHints = [shapeTypeHint];
-    diagramConfiguration.edgeTypeHints = [edgeTypeHint];
-    container.load(
-        new ContainerModule(bind => {
-            bind(DiagramConfiguration).toConstantValue(diagramConfiguration);
-        })
-    );
-    const handler = container.resolve(RequestTypeHintsActionHandler);
-
-    it('execute with correct action', async () => {
-        const result = await handler.execute(RequestTypeHintsAction.create());
-
-        expect(result).to.have.length(1);
-        expect(SetTypeHintsAction.is(result[0])).true;
-        expect(result).to.be.deep.equal([
-            { edgeHints: [edgeTypeHint], kind: 'setTypeHints', shapeHints: [shapeTypeHint], responseId: '' } as SetTypeHintsAction
-        ]);
-    });
-});

package/src/common/operations/operation-handler-registry.spec.ts

@@ -1,50 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { CompoundOperation, CreateEdgeOperation, CreateNodeOperation } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import * as mock from '../test/mock-util';
-import { CompoundOperationHandler } from './compound-operation-handler';
-import { OperationHandlerRegistry } from './operation-handler-registry';
-
-describe('Test OperationHandlerRegistry', () => {
-    const stubANode = new mock.StubCreateNodeOperationHandler('ANode');
-    const stubBNode = new mock.StubCreateNodeOperationHandler('BNode');
-    const stubAEdge = new mock.StubCreateEdgeOperationHandler('AEdge');
-    const stubBEdge = new mock.StubCreateEdgeOperationHandler('BEdge');
-    const operationHandlerRegistry = new OperationHandlerRegistry();
-
-    it('register OperationActionHandler', () => {
-        operationHandlerRegistry.registerHandler(new CompoundOperationHandler());
-        expect(operationHandlerRegistry.keys()).to.have.length(1);
-        expect(operationHandlerRegistry.keys()).to.contain(CompoundOperation.KIND);
-        expect(operationHandlerRegistry.get(CompoundOperation.KIND)).to.be.an.instanceOf(CompoundOperationHandler);
-    });
-
-    it('register CreateOperationActionHandlers', () => {
-        operationHandlerRegistry.registerHandler(stubANode);
-        operationHandlerRegistry.registerHandler(stubBNode);
-        operationHandlerRegistry.registerHandler(stubAEdge);
-        operationHandlerRegistry.registerHandler(stubBEdge);
-        expect(operationHandlerRegistry.keys()).to.contain(`${CreateNodeOperation.KIND}_ANode`);
-        expect(operationHandlerRegistry.get(`${CreateNodeOperation.KIND}_ANode`)).to.be.equal(stubANode);
-        expect(operationHandlerRegistry.keys()).to.contain(`${CreateNodeOperation.KIND}_BNode`);
-        expect(operationHandlerRegistry.get(`${CreateNodeOperation.KIND}_BNode`)).to.be.equal(stubBNode);
-        expect(operationHandlerRegistry.keys()).to.contain(`${CreateEdgeOperation.KIND}_AEdge`);
-        expect(operationHandlerRegistry.get(`${CreateEdgeOperation.KIND}_AEdge`)).to.be.equal(stubAEdge);
-        expect(operationHandlerRegistry.keys()).to.contain(`${CreateEdgeOperation.KIND}_BEdge`);
-        expect(operationHandlerRegistry.get(`${CreateEdgeOperation.KIND}_BEdge`)).to.be.equal(stubBEdge);
-    });
-});

package/src/common/protocol/glsp-server.spec.ts

@@ -1,154 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import {
-    DisposeClientSessionParameters,
-    GLSPClientProxy,
-    GLSPServerListener,
-    InitializeClientSessionParameters,
-    InitializeParameters
-} from '@eclipse-glsp/protocol';
-import * as assert from 'assert';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import * as sinon from 'sinon';
-import { GlobalActionProvider } from '../actions/global-action-provider';
-import { ClientSessionManager } from '../session/client-session-manager';
-import * as mock from '../test/mock-util';
-import { Logger } from '../utils/logger';
-import { DefaultGLSPServer } from './glsp-server';
-
-describe('test DefaultGLSPServer', () => {
-    const container = new Container();
-    const clientSessionId = 'myClientSession';
-    const diagramType = 'myDiagram';
-    const applicationId = 'Test';
-    const protocolVersion = '1.0.0';
-    const actionKinds = new Map<string, string[]>();
-    actionKinds.set(diagramType, ['A1', 'A2']);
-    const sessionManager = new mock.StubClientSessionManager();
-    const spy_sessionManager_getOrCreate = sinon.spy(sessionManager, 'getOrCreateClientSession');
-    const spy_sessionManager_dispose = sinon.spy(sessionManager, 'disposeClientSession');
-    const listener1 = new mock.StubGLSPServerListener();
-    const spy_listener1_initialize = sinon.spy(listener1, 'serverInitialized');
-    const spy_listener1_shutdown = sinon.spy(listener1, 'serverShutDown');
-    const listener2 = new mock.StubGLSPServerListener();
-    const spy_listener2_initialize = sinon.spy(listener2, 'serverInitialized');
-    const spy_listener2_shutdown = sinon.spy(listener2, 'serverShutDown');
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new mock.StubLogger());
-            bind(GLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
-            bind(ClientSessionManager).toConstantValue(sessionManager);
-            bind(GlobalActionProvider).toConstantValue(<GlobalActionProvider>{ actionKinds });
-            bind(GLSPServerListener).toConstantValue(listener1);
-        })
-    );
-
-    const glspServer = container.resolve(DefaultGLSPServer);
-
-    beforeEach(() => {
-        spy_sessionManager_getOrCreate.restore();
-        spy_sessionManager_dispose.restore();
-        spy_listener1_initialize.restore();
-        spy_listener1_shutdown.restore();
-        spy_listener2_initialize.restore();
-        spy_listener2_shutdown.restore();
-    });
-
-    it('Test calls before server initialization (should throw errors)', async () => {
-        assert.rejects(() => glspServer.initializeClientSession({ clientSessionId: 'id', diagramType: 'type', clientActionKinds: [] }));
-        assert.rejects(() => glspServer.disposeClientSession({ clientSessionId: 'id' }));
-        assert.throws(() => glspServer.process({ clientId: 'id', action: { kind: 'action' } }));
-    });
-
-    it('addListener - add existing listener', () => {
-        const originalSize = glspServer['serverListeners'].length;
-        glspServer.addListener(listener1);
-        expect(glspServer['serverListeners'].length).to.be.equal(originalSize);
-    });
-
-    it('addListener - add new listener', () => {
-        const originalSize = glspServer['serverListeners'].length;
-        glspServer.addListener(listener2);
-        expect(glspServer['serverListeners']).to.include(listener2);
-        expect(glspServer['serverListeners'].length).to.be.equal(originalSize + 1);
-    });
-
-    it('removeListener - remove non-existing listener', () => {
-        const originalSize = glspServer['serverListeners'].length;
-        glspServer.removeListener({});
-        expect(glspServer['serverListeners'].length).to.be.equal(originalSize);
-    });
-
-    it('removeListener - remove existing listener', () => {
-        const originalSize = glspServer['serverListeners'].length;
-        glspServer.removeListener(listener2);
-        expect(glspServer['serverListeners'].length).to.be.equal(originalSize - 1);
-    });
-
-    it('initialize - with wrong protocol version', async () => {
-        const initializeParameters: InitializeParameters = { applicationId, protocolVersion: 'abc' };
-        assert.rejects(glspServer.initialize(initializeParameters));
-    });
-
-    it('initialize - with correct parameters', async () => {
-        const initializeParameters: InitializeParameters = { applicationId, protocolVersion };
-        const result = await glspServer.initialize(initializeParameters);
-        expect(result.protocolVersion).to.be.equal(protocolVersion);
-        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
-        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
-        expect(spy_listener1_initialize.calledWith(glspServer));
-        expect(spy_listener2_initialize.notCalled);
-    });
-
-    it('initialize - subsequent call with same parameters', async () => {
-        const initializeParameters: InitializeParameters = { applicationId, protocolVersion };
-        const result = await glspServer.initialize(initializeParameters);
-        expect(result.protocolVersion).to.be.equal(protocolVersion);
-        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
-        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
-    });
-
-    it('initialize -  subsequent call with other parameters', async () => {
-        const initializeParameters = { applicationId: 'someOtherApp', protocolVersion: 'AnotherProtocolVersion' };
-        await assert.rejects(() => glspServer.initialize(initializeParameters));
-    });
-
-    it('initialize client session', async () => {
-        const initializeClientSessionParameters: InitializeClientSessionParameters = {
-            clientSessionId,
-            diagramType,
-            clientActionKinds: []
-        };
-        await glspServer.initializeClientSession(initializeClientSessionParameters);
-        expect(spy_sessionManager_getOrCreate.calledWith(initializeClientSessionParameters));
-    });
-
-    it('dispose client session', async () => {
-        const disposeClientSessionParameters: DisposeClientSessionParameters = {
-            clientSessionId
-        };
-        await glspServer.disposeClientSession(disposeClientSessionParameters);
-        expect(spy_sessionManager_dispose.calledWith(clientSessionId));
-    });
-
-    it('shutdown server', async () => {
-        glspServer.shutdown();
-        expect(spy_listener1_shutdown.calledWith(glspServer));
-        expect(spy_listener2_shutdown.notCalled);
-    });
-});

package/src/common/session/client-session-factory.spec.ts

@@ -1,60 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { GLSPClientProxy } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { ActionDispatcher } from '../actions/action-dispatcher';
-import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import * as mock from '../test/mock-util';
-import { GLSPServerError } from '../utils/glsp-server-error';
-import { Logger } from '../utils/logger';
-import { DefaultClientSessionFactory } from './client-session-factory';
-import { ClientSessionInitializer } from './client-session-initializer';
-
-describe('test DefaultClientSessionFactory', () => {
-    const clientSessionId = 'myClientId';
-    const diagramType = 'myDiagramType';
-    const container = new Container();
-    const diagramModule = new ContainerModule(bind => {
-        bind(ActionDispatcher).toConstantValue(new mock.StubActionDispatcher());
-        bind(ClientSessionInitializer).toConstantValue(new mock.StubClientSessionInitializer());
-    });
-
-    const diagramModules = new Map<string, ContainerModule[]>();
-    diagramModules.set(diagramType, [diagramModule]);
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new mock.StubLogger());
-            bind(InjectionContainer).toConstantValue(container);
-            bind(DiagramModules).toConstantValue(diagramModules);
-            bind(GLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
-        })
-    );
-    const factory = container.resolve(DefaultClientSessionFactory);
-
-    it('create - new client session', () => {
-        const session = factory.create({ clientSessionId, diagramType, clientActionKinds: [] });
-        expect(session.id).to.be.equal(clientSessionId);
-        expect(session.diagramType).to.be.equal(diagramType);
-        expect(session.container.parent).to.be.equal(container);
-        expect(session.actionDispatcher).to.be.an.instanceOf(mock.StubActionDispatcher);
-    });
-
-    it('create - unknown diagram type', () => {
-        expect(() => factory.create({ clientSessionId, diagramType: 'unknown-type', clientActionKinds: [] })).to.throw(GLSPServerError);
-    });
-});