@eclipse-glsp/server 1.1.0-next.3d7585d.42

package/src/common/operations/compound-operation-handler.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * 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, MaybePromise, Operation } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { OperationActionHandler } from './operation-action-handler';
+import { OperationHandler } from './operation-handler';
+import { OperationHandlerRegistry } from './operation-handler-registry';
+
+@injectable()
+export class CompoundOperationHandler implements OperationHandler {
+    operationType = CompoundOperation.KIND;
+
+    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
+
+    execute(operation: CompoundOperation): void {
+        operation.operationList.forEach(nestedOperation => this.executeNestedOperation(nestedOperation));
+    }
+
+    executeNestedOperation(operation: Operation): MaybePromise<void> {
+        const operationHandler = OperationActionHandler.getOperationHandler(operation, this.operationHandlerRegistry);
+        if (operationHandler) {
+            operationHandler.execute(operation);
+        }
+    }
+}

package/src/common/operations/create-operation-handler.ts

@@ -0,0 +1,106 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/graph';
+import {
+    CreateEdgeOperation,
+    CreateNodeOperation,
+    CreateOperation,
+    MaybePromise,
+    Operation,
+    Point,
+    TriggerEdgeCreationAction,
+    TriggerNodeCreationAction
+} from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ModelState } from '../features/model/model-state';
+import { getRelativeLocation } from '../utils/layout-util';
+import { OperationHandler } from './operation-handler';
+
+/**
+ * A special {@link OperationHandler} that is responsible for the handling of {@link CreateOperation}s. Depending on its
+ * operation type the triggered actions are {@link TriggerNodeCreationAction} or {@link TriggerEdgeCreationAction}s.
+ */
+@injectable()
+export abstract class CreateOperationHandler implements OperationHandler {
+    abstract operationType: string;
+    abstract readonly label: string;
+    abstract elementTypeIds: string[];
+
+    abstract execute(operation: Operation): MaybePromise<void>;
+
+    /**
+     * Returns a list of {@link TriggerElementCreationAction}s for registered element types.
+     *
+     * @returns A list of {@link TriggerElementCreationAction}s.
+     */
+    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[] {
+        if (this.operationType === CreateNodeOperation.KIND) {
+            return this.elementTypeIds.map(typeId => TriggerNodeCreationAction.create(typeId));
+        } else if (this.operationType === CreateEdgeOperation.KIND) {
+            return this.elementTypeIds.map(typeId => TriggerEdgeCreationAction.create(typeId));
+        }
+        return [];
+    }
+
+    handles(operation: CreateOperation): boolean {
+        return this.elementTypeIds.includes(operation.elementTypeId);
+    }
+}
+
+/**
+ * Abstract base implementation for {@link CreateOperationHandler} that
+ * create an element that is represented with a {@link GNode} in the graphical model.
+ */
+@injectable()
+export abstract class CreateNodeOperationHandler extends CreateOperationHandler {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    get operationType(): string {
+        return CreateNodeOperation.KIND;
+    }
+
+    /**
+     * Retrieve the graphical model element that should contain the newly created {@link GNode}.
+     * If `undefined` is returned the {@link GNode} should be added directly to the diagram root.
+     * @param operation The currently handled operation.
+     * @returns The container {@link GModeElement} or `undefined`.
+     */
+    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
+        const index = this.modelState.index;
+        return operation.containerId ? index.get(operation.containerId) : undefined;
+    }
+
+    getLocation(operation: CreateNodeOperation): Point | undefined {
+        return operation.location;
+    }
+
+    /**
+     * Retrieves the diagram absolute location and the target container from the given {@link CreateNodeOperation}
+     * and converts the absolute location to coordinates relative to the given container.
+     *  Relative coordinates can only be retrieved if the given container element is part of
+     * a hierarchy of {@link GBoundsAware} elements. This means each (recursive) parent element need to
+     * implement {@link GBoundsAware}. If that is not the case this method returns `undefined`.
+     * @param absoluteLocation The diagram absolute position.
+     * @param container The container element.
+     * @returns The relative position or `undefined`.
+     */
+    getRelativeLocation(operation: CreateNodeOperation): Point | undefined {
+        const container = this.getContainer(operation) ?? this.modelState.root;
+        const absoluteLocation = this.getLocation(operation) ?? Point.ORIGIN;
+        return getRelativeLocation(absoluteLocation, container);
+    }
+}

package/src/common/operations/cut-operation-handler.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * 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 { CutOperation, DeleteElementOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionDispatcher } from '../actions/action-dispatcher';
+import { OperationHandler } from './operation-handler';
+
+@injectable()
+export class CutOperationHandler implements OperationHandler {
+    operationType = CutOperation.KIND;
+
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    execute(operation: CutOperation): MaybePromise<void> {
+        const cutableElementIds = this.getElementToCut(operation);
+        if (cutableElementIds.length > 0) {
+            this.actionDispatcher.dispatch(DeleteElementOperation.create(cutableElementIds));
+        }
+    }
+
+    protected getElementToCut(cutOperation: CutOperation): string[] {
+        return cutOperation.editorContext.selectedElementIds;
+    }
+}

package/src/common/operations/operation-action-handler.ts

@@ -0,0 +1,69 @@
+/********************************************************************************
+ * 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 { Action, CreateOperation, MaybePromise, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../actions/action-handler';
+import { Operations } from '../di/service-identifiers';
+import { ModelState } from '../features/model/model-state';
+import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
+import { OperationHandler } from './operation-handler';
+import { OperationHandlerRegistry } from './operation-handler-registry';
+
+@injectable()
+export class OperationActionHandler implements ActionHandler {
+    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
+    @inject(ModelSubmissionHandler) protected modelSubmissionHandler: ModelSubmissionHandler;
+    @inject(ModelState) protected modelState: ModelState;
+
+    constructor(@inject(Operations) readonly actionKinds: string[]) {}
+
+    execute(action: Operation): MaybePromise<Action[]> {
+        if (this.handles(action)) {
+            if (this.modelState.isReadonly) {
+                return [
+                    ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
+                        severity: 'WARNING'
+                    })
+                ];
+            }
+            const operationHandler = OperationActionHandler.getOperationHandler(action, this.operationHandlerRegistry);
+            if (operationHandler) {
+                return this.executeHandler(action, operationHandler);
+            }
+        }
+        return [];
+    }
+
+    async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
+        // TODO: Create GModelRecordingCommand;
+        await handler.execute(operation);
+        this.modelState.index.indexRoot(this.modelState.root);
+        this.modelState.isDirty = true;
+        // TODO: this.modelState.execute(command)
+        return this.modelSubmissionHandler.submitModel('operation');
+    }
+
+    handles(action: Action): boolean {
+        if (this.actionKinds.includes(action.kind)) {
+            return true;
+        }
+        return false;
+    }
+
+    static getOperationHandler(operation: Operation, registry: OperationHandlerRegistry): OperationHandler | undefined {
+        return CreateOperation.is(operation) ? registry.get(`${operation.kind}_${operation.elementTypeId}`) : registry.get(operation.kind);
+    }
+}

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

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * 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/operations/operation-handler-registry.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * 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 { Args } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ClientSessionInitializer } from '../session/client-session-initializer';
+import { Registry } from '../utils/registry';
+import { CreateOperationHandler } from './create-operation-handler';
+import { OperationHandler, OperationHandlerConstructor, OperationHandlerFactory } from './operation-handler';
+
+@injectable()
+export class OperationHandlerRegistry extends Registry<string, OperationHandler> {
+    registerHandler(handler: OperationHandler): boolean {
+        if (handler instanceof CreateOperationHandler) {
+            handler.elementTypeIds.forEach(typeId => this.register(`${handler.operationType}_${typeId}`, handler));
+            return true;
+        } else {
+            return this.register(handler.operationType, handler);
+        }
+    }
+}
+
+@injectable()
+export class OperationHandlerRegistryInitializer implements ClientSessionInitializer {
+    @inject(OperationHandlerFactory)
+    protected factory: OperationHandlerFactory;
+
+    @inject(OperationHandlerConstructor)
+    @optional()
+    protected handlerConstructors: OperationHandlerConstructor[] = [];
+
+    @inject(OperationHandlerRegistry)
+    protected registry: OperationHandlerRegistry;
+
+    initialize(args?: Args): void {
+        const handlers = this.handlerConstructors.map(constructor => this.factory(constructor));
+        handlers.forEach(handler => this.registry.registerHandler(handler));
+    }
+}

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

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * 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 { MaybePromise, Operation } from '@eclipse-glsp/protocol';
+import { interfaces } from 'inversify';
+
+export const OperationHandler = Symbol('OperationHandler');
+
+/**
+ * An operation handler can execute {@link Operation}s of a certain type (subclass).
+ * The operation handler processes the operation in the {@link OperationHandler.execute()} method. The result
+ * of the execution is an update of the `ModelState` state.
+ * This update is reversible (undo) and can be reapplied (redo). For basic diagram languages these updates are typically
+ * applied directly on the `ModelState` using EMF `Command`s and the
+ * `ModelState.execute()` method. For more complex diagram languages the
+ * GModel state might be updated indirectly and the operation handler manipulates a custom model representation.
+ *
+ * The `OperationActionHandler` is responsible for retrieving all available (valid) operation handlers for an
+ * operation that is dispatched via `ActionDispatcher`.
+ */
+export interface OperationHandler {
+    /**
+     * Returns the operation type that can be handled by this operation handler.
+     *
+     * @returns the operation type that can be handled.
+     */
+    readonly operationType: string;
+
+    readonly label?: string;
+
+    /**
+     * Executes the operation handler for the given {@link Operation}.
+     *
+     * @param operation The operation that should be executed.
+     */
+    execute(operation: Operation): MaybePromise<void>;
+}
+
+export const OperationHandlerConstructor = Symbol('OperationHandlerConstructor');
+
+export type OperationHandlerConstructor = interfaces.Newable<OperationHandler>;
+
+export const OperationHandlerFactory = Symbol('OperationHandlerFactory');
+
+export type OperationHandlerFactory = (constructor: OperationHandlerConstructor) => OperationHandler;

package/src/common/protocol/glsp-client-proxy.ts

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * 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 { ActionMessage, JsonrpcGLSPClient } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import * as jsonrpc from 'vscode-jsonrpc';
+import { Logger } from '../utils/logger';
+
+export const GLSPClientProxyFactory = Symbol('GLSPClientProxyFactory');
+
+export type GLSPClientProxyFactory = (connection: jsonrpc.MessageConnection) => GLSPClientProxy;
+
+export const GLSPClientProxy = Symbol('GLSPClientProxy');
+
+/**
+ * Json-rpc client proxy interface to hide the underlying json-rpc logic.
+ */
+export interface GLSPClientProxy {
+    /**
+     * A `process` notification is sent from the server to server to the client when the client should handle i.e.
+     * process a specific {@link ActionMessage}. Any communication that is performed between initialization and shutdown
+     * is handled by sending action messages, either from the client to the server or from the server to the client. This
+     * is the core part of the Graphical Language Server Protocol.
+     *
+     * @param message The {@link ActionMessage} that should be processed.
+     */
+    process(message: ActionMessage): void;
+}
+
+export const JsonRpcGLSPClientProxy = Symbol('JsonRpcGLSPClientProxy');
+
+export interface JsonRpcGLSPClientProxy extends GLSPClientProxy {
+    connect(connection: jsonrpc.MessageConnection): void;
+}
+
+@injectable()
+export class DefaultGLSPClientProxy implements JsonRpcGLSPClientProxy {
+    @inject(Logger)
+    private logger: Logger;
+
+    protected connection: jsonrpc.MessageConnection;
+
+    connect(connection: jsonrpc.MessageConnection): void {
+        if (!this.connection) {
+            this.connection = connection;
+        }
+    }
+
+    process(message: ActionMessage): void {
+        this.logger.debug(`Send action '${message.action.kind}' to client '${message.clientId}'`);
+        this.connection.sendNotification(JsonrpcGLSPClient.ActionMessageNotification, message);
+    }
+}

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

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * 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 { GLSPServer } from './glsp-server';
+
+export const GLSPServerListener = Symbol('GLSPServerListener');
+
+/**
+ * A listener to track the connection status of {@link GLSPClient}s (i.e. client applications).
+ * Gets notified when a new GLSP client connects or disconnects.
+ */
+export interface GLSPServerListener {
+    /**
+     * Triggered after a GLSPServer has been initialized via the {@link GLSPServer.initialize()}
+     * method.
+     *
+     * @param server The GLSPServer which has been initialized.
+     */
+    serverInitialized?(server: GLSPServer): void;
+
+    /**
+     * Triggered after the {@link GLSPServer.shutdown()} method has been invoked.
+     *
+     * @param glspServer The glspServer which has been shut down.
+     */
+    serverShutDown?(server: GLSPServer): void;
+}

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

@@ -0,0 +1,150 @@
+/********************************************************************************
+ * 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, InitializeClientSessionParameters, InitializeParameters } from '@eclipse-glsp/protocol';
+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 { GLSPClientProxy, JsonRpcGLSPClientProxy } from './glsp-client-proxy';
+import { DefaultGLSPServer } from './glsp-server';
+import { GLSPServerListener } from './glsp-server-listener';
+import assert = require('assert');
+
+describe('test DefaultGLSPServer', () => {
+    const container = new Container();
+    const clientSessionId = 'myClientSession';
+    const diagramType = 'myDiagram';
+    const applicationId = 'Test';
+    const protocolVersion = '1.0.0';
+    const serverActionKinds = new Map<string, string[]>();
+    serverActionKinds.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(JsonRpcGLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
+            bind(ClientSessionManager).toConstantValue(sessionManager);
+            bind(GlobalActionProvider).toConstantValue({ clientActionKinds: new Map<string, string[]>(), serverActionKinds });
+            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' }));
+        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(serverActionKinds.get(diagramType));
+        expect(result.serverActions[diagramType]).to.be.equal(serverActionKinds.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(serverActionKinds.get(diagramType));
+        expect(result.serverActions[diagramType]).to.be.equal(serverActionKinds.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
+        };
+        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);
+    });
+});