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

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);
-    });
-});

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

@@ -1,83 +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 { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import * as sinon from 'sinon';
-import * as mock from '../test/mock-util';
-import { Logger } from '../utils/logger';
-import { ClientSessionFactory } from './client-session-factory';
-import { DefaultClientSessionManager } from './client-session-manager';
-
-describe('test DefaultClientSessionManager', () => {
-    const testSession = mock.createClientSession('myId', 'myDiagram');
-    const testSessionListener = new mock.StubClientSessionListener();
-
-    const sessionFactory = new mock.StubClientSessionFactory();
-    sinon.stub(sessionFactory, 'create').returns(testSession);
-
-    const container = new Container();
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new mock.StubLogger());
-            bind(ClientSessionFactory).toConstantValue(sessionFactory);
-        })
-    );
-    const sessionManager = container.resolve(DefaultClientSessionManager);
-
-    it('add listener', () => {
-        expect(sessionManager.addListener(testSessionListener, testSession.id)).true;
-    });
-
-    it('add create client session', () => {
-        // Mock setup
-        const listener_create = sinon.spy(testSessionListener, 'sessionCreated');
-        // Test execution
-        const createdSession = sessionManager.getOrCreateClientSession({
-            clientSessionId: testSession.id,
-            diagramType: testSession.diagramType,
-            clientActionKinds: []
-        });
-        expect(createdSession).to.not.be.undefined;
-        expect(createdSession.id).to.be.equal(testSession.id);
-        expect(createdSession.diagramType).to.be.equal(testSession.diagramType);
-
-        const retrievedSession = sessionManager.getSession(testSession.id);
-        expect(retrievedSession).to.not.be.undefined;
-        expect(retrievedSession).to.be.equal(createdSession);
-        expect(listener_create.calledWith(testSession));
-    });
-
-    it('get sessions by type', () => {
-        const clientSessions = sessionManager.getSessionsByType(testSession.diagramType);
-        expect(clientSessions.length).to.be.equal(1);
-        expect(clientSessions[0]).to.be.equal(testSession);
-    });
-
-    it('get sessions by type that does no exist', async () => {
-        const clientSessions = sessionManager.getSessionsByType('wrongType');
-        expect(clientSessions.length).to.be.equal(0);
-    });
-
-    it('dispose client session', () => {
-        // Mock setup
-        const listener_dispose = sinon.spy(testSessionListener, 'sessionDisposed');
-        // Test execution
-        expect(sessionManager.disposeClientSession(testSession.id)).to.be.equal(true);
-        const session = sessionManager.getSession(testSession.id);
-        expect(session).to.be.undefined;
-        expect(listener_dispose.calledWith(testSession));
-    });
-});