@eclipse-glsp/server 2.8.0-next.1 → 2.8.0-next.12

package/src/common/launch/glsp-server-launcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 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
@@ -42,11 +42,22 @@ export abstract class GLSPServerLauncher<T> implements Disposable {
     start(startParams: T): MaybePromise<void> {
         if (!this.running) {
             this.running = true;
+            this.registerDisposables();
             return this.run(startParams);
         }
         this.logger.warn('Could not start launcher. Launcher is already running!');
     }
 
+    /**
+     * Registers what {@link shutdown} has to release for the launch that is about to start.
+     *
+     * Called once per launch, because {@link dispose} empties the collection it registers into. A subclass that holds
+     * resources for the duration of a launch overrides this instead of registering them in its constructor.
+     */
+    protected registerDisposables(): void {
+        // nothing to release by default
+    }
+
     protected abstract run(startParams: T): MaybePromise<void>;
 
     shutdown(): MaybePromise<void> {

package/src/common/launch/jsonrpc-server-launcher.ts

@@ -15,6 +15,7 @@
  ********************************************************************************/
 
 import {
+    Deferred,
     Disposable,
     GLSPClientProxy,
     GLSPServer,
@@ -23,6 +24,7 @@ import {
     configureClientConnection
 } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable } from 'inversify';
+import * as net from 'net';
 import * as jsonrpc from 'vscode-jsonrpc';
 import { Logger } from '../utils/logger';
 import { GLSPServerLauncher } from './glsp-server-launcher';
@@ -43,8 +45,93 @@ export abstract class JsonRpcGLSPServerLauncher<T> extends GLSPServerLauncher<T>
     protected serverInstances = new Map<jsonrpc.MessageConnection, JsonRpcServerInstance>();
     protected startupCompleteMessage = START_UP_COMPLETE_MSG;
 
-    constructor() {
-        super();
+    protected listeningAddress = new Deferred<net.AddressInfo>();
+
+    /**
+     * Resolves with the address the server bound to once it is listening, and rejects if it never gets there.
+     *
+     * Launching with port `0` lets the operating system pick a free port, so the bound address is not necessarily the
+     * requested one. Settles once per launch and keeps that value, so use {@link port} for the current state. Reading
+     * this before {@link start} is fine, the promise handed out is the one that launch settles.
+     */
+    get listening(): Promise<net.AddressInfo> {
+        return this.listeningAddress.promise;
+    }
+
+    /**
+     * The port the server is currently listening on, or `undefined` if it is not.
+     *
+     * Await {@link listening} rather than polling this while the server is still starting up.
+     */
+    get port(): number | undefined {
+        const address = this.getServerSocket()?.address();
+        return address && typeof address !== 'string' ? address.port : undefined;
+    }
+
+    /**
+     * The socket that {@link port} reports on, or `undefined` before the first launch.
+     *
+     * A launcher that binds a socket overrides this, the default reports no address at all.
+     */
+    protected getServerSocket(): net.Server | undefined {
+        return undefined;
+    }
+
+    /**
+     * Arms {@link listening} for a launch.
+     *
+     * An unresolved promise is kept, so a caller that grabbed {@link listening} before {@link start} gets the one this
+     * launch settles. A settled one is replaced, so a restart is not handed the previous result.
+     */
+    protected resetListening(): void {
+        if (this.listeningAddress.state !== 'unresolved') {
+            this.listeningAddress = new Deferred<net.AddressInfo>();
+        }
+    }
+
+    /**
+     * Resolves {@link listening} with the address the given server bound to.
+     *
+     * @param server The server that reported itself as listening.
+     * @returns The bound address, or `undefined` if it cannot be used, in which case the launcher is shut down.
+     */
+    protected settleListening(server: net.Server): net.AddressInfo | undefined {
+        const addressInfo = server.address();
+        if (!addressInfo) {
+            this.failToListen('Could not resolve GLSP Server address info.');
+            return undefined;
+        }
+        if (typeof addressInfo === 'string') {
+            this.failToListen(`GLSP Server is unexpectedly listening to pipe or domain socket "${addressInfo}".`);
+            return undefined;
+        }
+        this.listeningAddress.resolve(addressInfo);
+        return addressInfo;
+    }
+
+    /**
+     * Invoked when the server socket fails, e.g. because the requested port is already in use.
+     *
+     * @param error The reason the socket failed.
+     */
+    protected handleError(error: Error): void {
+        this.failToListen(`GLSP server socket error. ${error.message}`, error);
+    }
+
+    /**
+     * Reports that the server will not accept requests, rejects {@link listening} and shuts the launcher down.
+     *
+     * @param message The reason the server is not usable.
+     * @param cause   The underlying error, if the reason was one.
+     */
+    protected failToListen(message: string, cause?: Error): void {
+        this.logger.error(`${message} Shutting down.`);
+        this.listeningAddress.reject(cause ?? new Error(message));
+        this.shutdown();
+    }
+
+    protected override registerDisposables(): void {
+        super.registerDisposables();
         this.toDispose.push(
             Disposable.create(() => {
                 this.serverInstances.forEach(instance => this.disposeServerInstance(instance));

package/src/common/utils/glsp-server-error.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 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
@@ -14,11 +14,9 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 export class GLSPServerError extends Error {
-    constructor(
-        message: string,
-        readonly cause?: unknown
-    ) {
+    constructor(message: string, cause?: unknown) {
         super(message);
+        this.cause = cause;
     }
 }
 

package/src/common/utils/layout-util.ts

@@ -25,11 +25,11 @@ import { GLSPServerError, getOrThrow } from './glsp-server-error';
  *
  * @param bounds The new bounds.
  * @param index  The model index.
- * @returns The changed element.
+ * @returns The changed element, or `undefined` if the bounds could not be applied to any element.
  */
 export function applyElementAndBounds(bounds: ElementAndBounds, index: GModelIndex): GBoundsAware | undefined {
-    const element = getOrThrow(index.get(bounds.elementId), 'Model element not found! ID: ' + bounds.elementId);
-    if (isGBoundsAware(element)) {
+    const element = index.find(bounds.elementId);
+    if (element && isGBoundsAware(element)) {
         if (bounds.newPosition !== undefined) {
             element.position = bounds.newPosition;
         }
@@ -44,11 +44,11 @@ export function applyElementAndBounds(bounds: ElementAndBounds, index: GModelInd
  *
  * @param alignment The new alignment.
  * @param index     The model index.
- * @returns The changed element.
+ * @returns The changed element, or `undefined` if the alignment could not be applied to any element.
  */
 export function applyAlignment(alignment: ElementAndAlignment, index: GModelIndex): GAlignable | undefined {
-    const element = getOrThrow(index.get(alignment.elementId), 'Model element not found! ID: ' + alignment.elementId);
-    if (isGAlignable(element)) {
+    const element = index.find(alignment.elementId);
+    if (element && isGAlignable(element)) {
         element.alignment = alignment.newAlignment;
         return element;
     }
@@ -56,19 +56,20 @@ export function applyAlignment(alignment: ElementAndAlignment, index: GModelInde
 }
 
 /**
- * Applies the new route to the model.
+ * Applies the new route to the model. A route needs at least a source and a target point to describe an edge.
  *
  * @param route The new route.
  * @param index The model index.
- * @returns The changed element.
+ * @returns The changed edge, or `undefined` if the route could not be applied to any edge.
  */
-export function applyRoute(route: ElementAndRoutingPoints, index: GModelIndex): GEdge {
+export function applyRoute(route: ElementAndRoutingPoints, index: GModelIndex): GEdge | undefined {
     const routingPoints = route.newRoutingPoints ?? [];
-    if (routingPoints.length < 2) {
-        throw new GLSPServerError('Invalid Route!');
+    const edge = index.findByClass(route.elementId, GEdge);
+    if (!edge || routingPoints.length < 2) {
+        return undefined;
     }
     // first and last point mark the source and target point
-    const edge = applyRoutingPoints(route, index);
+    edge.routingPoints = routingPoints;
     const edgeRoutingPoints = edge.routingPoints;
 
     const args = edge.args ?? {};

package/src/node/launch/socket-server-launcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 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
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Disposable } from '@eclipse-glsp/protocol';
+import { Disposable, Emitter } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import * as net from 'net';
 import * as jsonrpc from 'vscode-jsonrpc/node';
@@ -24,48 +24,71 @@ import { Logger } from '../../common/utils/logger';
 export class SocketServerLauncher extends JsonRpcGLSPServerLauncher<net.TcpSocketConnectOpts> {
     @inject(Logger) protected override logger: Logger;
 
-    protected netServer: net.Server;
+    protected netServer?: net.Server;
 
-    constructor() {
-        super();
+    protected onConnectionEmitter = new Emitter<net.Socket>();
+
+    /**
+     * Fires for every socket the server accepts, before the JSON-RPC connection is built on it.
+     *
+     * A listener must not consume the socket. Subscribe before {@link start} to observe the first connection; the
+     * subscription outlives an individual launch and is disposed by the caller.
+     */
+    readonly onConnection = this.onConnectionEmitter.event;
+
+    protected override getServerSocket(): net.Server | undefined {
+        return this.netServer;
+    }
+
+    protected override registerDisposables(): void {
+        super.registerDisposables();
         this.toDispose.push(
             Disposable.create(() => {
-                this.netServer.close();
+                this.netServer?.close();
             })
         );
     }
 
     protected run(opts: net.TcpSocketConnectOpts): Promise<void> {
-        this.netServer = net.createServer(socket => {
-            const connection = this.createConnection(socket);
-            this.createServerInstance(connection);
-        });
+        this.resetListening();
+        const netServer = net.createServer(socket => this.acceptConnection(socket));
+        this.netServer = netServer;
 
-        this.netServer.listen(opts.port, opts.host);
-        this.netServer.on('listening', () => {
-            const addressInfo = this.netServer.address();
-            if (!addressInfo) {
-                this.logger.error('Could not resolve GLSP Server address info. Shutting down.');
-                this.shutdown();
-                return;
-            } else if (typeof addressInfo === 'string') {
-                this.logger.error(`GLSP Server is unexpectedly listening to pipe or domain socket "${addressInfo}". Shutting down.`);
-                this.shutdown();
-                return;
-            }
-            const currentPort = addressInfo.port;
-            this.logger.info(`The GLSP server is ready to accept new client requests on port: ${currentPort}`);
-            // Print a message to the output stream that indicates that the start is completed.
-            // This indicates to the client that the server process is ready (in an embedded scenario).
-            console.log(this.startupCompleteMessage.concat(currentPort.toString()));
-        });
-        this.netServer.on('error', () => this.shutdown());
+        netServer.listen(opts.port, opts.host);
+        netServer.on('listening', () => this.handleListening(netServer));
+        netServer.on('error', error => this.handleError(error));
         return new Promise((resolve, reject) => {
-            this.netServer.on('close', () => resolve(undefined));
-            this.netServer.on('error', error => reject(error));
+            netServer.on('close', () => resolve(undefined));
+            netServer.on('error', error => reject(error));
         });
     }
 
+    /**
+     * Takes up a socket the server accepted. Observers are notified before the socket is read from.
+     *
+     * @param socket The accepted socket.
+     */
+    protected acceptConnection(socket: net.Socket): void {
+        this.onConnectionEmitter.fire(socket);
+        this.createServerInstance(this.createConnection(socket));
+    }
+
+    /**
+     * Reports the server as ready and resolves {@link listening}.
+     *
+     * @param server The server that reported itself as listening.
+     */
+    protected handleListening(server: net.Server): void {
+        const addressInfo = this.settleListening(server);
+        if (!addressInfo) {
+            return;
+        }
+        this.logger.info(`The GLSP server is ready to accept new client requests on port: ${addressInfo.port}`);
+        // Print a message to the output stream that indicates that the start is completed.
+        // This indicates to the client that the server process is ready (in an embedded scenario).
+        console.log(this.startupCompleteMessage.concat(addressInfo.port.toString()));
+    }
+
     protected createConnection(socket: net.Socket): jsonrpc.MessageConnection {
         return jsonrpc.createMessageConnection(new jsonrpc.SocketMessageReader(socket), new jsonrpc.SocketMessageWriter(socket), console);
     }

package/src/node/launch/websocket-server-launcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-2026 EclipseSource 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
@@ -14,12 +14,12 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { createWebSocketConnection, Disposable, MaybePromise, WebSocketWrapper } from '@eclipse-glsp/protocol';
+import { createWebSocketConnection, Disposable, Emitter, MaybePromise, WebSocketWrapper } from '@eclipse-glsp/protocol';
 import * as http from 'http';
 import { inject, injectable } from 'inversify';
 import * as net from 'net';
 import * as jsonrpc from 'vscode-jsonrpc';
-import { Server, WebSocket } from 'ws';
+import { WebSocket, WebSocketServer } from 'ws';
 import { JsonRpcGLSPServerLauncher } from '../../common/launch/jsonrpc-server-launcher';
 import { Logger } from '../../common/utils/logger';
 
@@ -41,6 +41,13 @@ export interface WebsocketConnectionData {
     connection: jsonrpc.MessageConnection;
 }
 
+/** An accepted web socket together with the upgrade request it was negotiated with. */
+export interface AcceptedWebSocket {
+    socket: WebSocket;
+    /** The handshake request, the only place where its headers and query are still available. */
+    request: http.IncomingMessage;
+}
+
 const STATUS_UPGRADE_REQUIRED = 426;
 
 @injectable()
@@ -48,35 +55,86 @@ export class WebSocketServerLauncher extends JsonRpcGLSPServerLauncher<WebSocket
     @inject(Logger)
     protected override logger: Logger;
 
-    protected server: Server;
+    protected server?: WebSocketServer;
+
+    /**
+     * The HTTP server the web socket server is mounted on.
+     *
+     * Held separately because `ws` only closes an HTTP server it created itself, so releasing the socket is up to us.
+     */
+    protected httpServer?: http.Server;
 
-    constructor() {
-        super();
+    protected onConnectionEmitter = new Emitter<AcceptedWebSocket>();
+
+    /**
+     * Fires for every web socket the server accepts, before the JSON-RPC connection is built on it.
+     *
+     * A listener must not consume the socket. Subscribe before {@link start} to observe the first connection; the
+     * subscription outlives an individual launch and is disposed by the caller.
+     */
+    readonly onConnection = this.onConnectionEmitter.event;
+
+    protected override getServerSocket(): net.Server | undefined {
+        return this.httpServer;
+    }
+
+    protected override registerDisposables(): void {
+        super.registerDisposables();
         this.toDispose.push(
             Disposable.create(() => {
-                this.server.close();
+                this.server?.close();
+                // `ws` leaves an HTTP server it did not create itself listening, so close ours explicitly.
+                this.httpServer?.close();
+                this.httpServer = undefined;
             })
         );
     }
 
     protected async run(options: WebSocketServerOptions): Promise<void> {
+        this.resetListening();
         const resolvedOptions = await this.resolveOptions(options);
-        this.server = new Server({ server: resolvedOptions.server, path: resolvedOptions.path });
+        if (!this.running) {
+            // Shut down while the options were being resolved, so release the socket they already bound.
+            resolvedOptions.server.close();
+            return;
+        }
+        this.httpServer = resolvedOptions.server;
+        this.server = new WebSocketServer({ server: resolvedOptions.server, path: resolvedOptions.path });
         const endpoint = `ws://${resolvedOptions.host}:${resolvedOptions.port}:${resolvedOptions.path}`;
         this.logger.info(`The GLSP Websocket launcher is ready to accept new client requests on endpoint '${endpoint}'`);
         console.log(this.startupCompleteMessage.concat(resolvedOptions.port.toString()));
 
-        this.server.on('connection', (ws, req) => {
-            const connection = this.createConnection(ws);
-            this.createServerInstance(connection);
-        });
+        this.observeListening(resolvedOptions.server);
+        this.server.on('connection', (ws, request) => this.acceptConnection(ws, request));
 
+        const server = this.server;
         return new Promise((resolve, reject) => {
-            this.server.on('close', () => resolve(undefined));
-            this.server.on('error', error => reject(error));
+            server.on('close', () => resolve(undefined));
+            server.on('error', error => reject(error));
         });
     }
 
+    /** Settles {@link listening} from the HTTP server, which may already be bound by the time we get here. */
+    protected observeListening(server: http.Server): void {
+        if (server.listening) {
+            this.settleListening(server);
+            return;
+        }
+        server.on('listening', () => this.settleListening(server));
+        server.on('error', error => this.handleError(error));
+    }
+
+    /**
+     * Takes up a web socket the server accepted. Observers are notified before the socket is read from.
+     *
+     * @param socket  The accepted web socket.
+     * @param request The upgrade request the socket was negotiated with.
+     */
+    protected acceptConnection(socket: WebSocket, request: http.IncomingMessage): void {
+        this.onConnectionEmitter.fire({ socket, request });
+        this.createServerInstance(this.createConnection(socket));
+    }
+
     protected createConnection(socket: WebSocket): jsonrpc.MessageConnection {
         return createWebSocketConnection(wrapWebSocket(socket));
     }

package/src/browser/di/browser-action-dispatch-scope.spec.ts

@@ -1,75 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 EclipseSource 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 } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { ClientAction } from '../../common/protocol/client-action';
-import * as mock from '../../common/test/mock-util';
-import { BrowserActionDispatchScope } from './browser-action-dispatch-scope';
-
-describe('BrowserActionDispatchScope', () => {
-    const action: Action = { kind: 'foo' };
-    const markedClientAction = ((): Action => {
-        const a: Action = { kind: 'bar' };
-        ClientAction.mark(a);
-        return a;
-    })();
-
-    let scope: BrowserActionDispatchScope;
-    beforeEach(() => {
-        scope = new BrowserActionDispatchScope();
-    });
-
-    it('isReentrant is false outside enter()', () => {
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('isReentrant is true during a synchronous enter()', () => {
-        scope.enter(() => {
-            expect(scope.isReentrant(action)).to.be.true;
-        });
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('isReentrant is true during an async enter() and false after settle', async () => {
-        const probe: Promise<boolean> = scope.enter(async () => {
-            await Promise.resolve();
-            return scope.isReentrant(action);
-        });
-        expect(await probe).to.be.true;
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('resets active flag when callback throws synchronously', () => {
-        expect(() =>
-            scope.enter(() => {
-                throw new Error('boom');
-            })
-        ).to.throw('boom');
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('resets active flag when async callback rejects', async () => {
-        await mock.expectToThrowAsync(() => scope.enter(() => Promise.reject(new Error('boom'))), 'boom');
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('isReentrant is false for client-originated actions even when scope is active', () => {
-        scope.enter(() => {
-            expect(scope.isReentrant(markedClientAction)).to.be.false;
-            expect(scope.isReentrant(action)).to.be.true;
-        });
-    });
-});

package/src/common/actions/action-handler-registry.spec.ts

@@ -1,52 +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 * as mock from '../test/mock-util';
-import { ActionHandlerRegistry } from './action-handler-registry';
-import { expect } from 'chai';
-
-describe('Test ActionHandlerRegistry (only functionality that is not covered by "registry.spec.ts"', () => {
-    const singleAction = 'singleHandledAction';
-    const multiAction = 'multiHandledAction';
-
-    const h1 = new mock.StubActionHandler([singleAction]);
-    const h2 = new mock.StubActionHandler([multiAction]);
-    const h3 = new mock.StubActionHandler([multiAction]);
-    const h4 = new mock.StubActionHandler([multiAction]);
-    const registry: ActionHandlerRegistry = new ActionHandlerRegistry();
-
-    it('registerHandler - should register given handlers', () => {
-        // setup
-        registry.registerHandler(h1);
-        registry.registerHandler(h2);
-        registry.registerHandler(h3);
-        registry.registerHandler(h4);
-
-        const result = registry.getAll();
-        expect(result).to.have.length(4);
-        expect(result.includes(h1)).true;
-        expect(result.includes(h2)).true;
-        expect(result.includes(h3)).true;
-        expect(result.includes(h4)).true;
-    });
-
-    it('get - should return three handlers sorted by priority', () => {
-        const result = registry.get(multiAction);
-        expect(result.length).to.be.equal(3);
-        expect(result[0]).to.be.deep.equal(h4);
-        expect(result[1]).to.be.deep.equal(h2);
-        expect(result[2]).to.be.deep.equal(h3);
-    });
-});

package/src/common/actions/global-action-provider.spec.ts

@@ -1,68 +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 { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import { ClientSessionInitializer } from '../session/client-session-initializer';
-import * as mock from '../test/mock-util';
-import { Logger } from '../utils/logger';
-import { ActionHandler } from './action-handler';
-import { ActionHandlerRegistry } from './action-handler-registry';
-import { DefaultGlobalActionProvider } from './global-action-provider';
-
-describe('test DefaultGlobalActionProvider', () => {
-    const container = new Container();
-    const serverActions = ['A1', 'A2', 'A3'];
-    const diagramType = 'myDiagramType';
-
-    const handler1Actions = ['A1', 'A2'];
-    const handler2Actions = ['A2', 'A3'];
-
-    const h1 = new mock.StubActionHandler(handler1Actions);
-    const h2 = new mock.StubActionHandler(handler2Actions);
-
-    const handlerRegistry = new ActionHandlerRegistry();
-    sinon.stub(handlerRegistry, 'getAll').returns([h1, h2]);
-
-    const diagramModule1 = new ContainerModule(bind => {
-        bind(ClientSessionInitializer).toConstantValue(new mock.StubClientSessionInitializer());
-        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler1Actions));
-        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler2Actions));
-        bind(ActionHandlerRegistry).toConstantValue(handlerRegistry);
-    });
-
-    const diagramModules = new Map<string, ContainerModule[]>();
-    diagramModules.set(diagramType, [diagramModule1]);
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new mock.StubLogger());
-            bind(InjectionContainer).toConstantValue(container);
-            bind(DiagramModules).toConstantValue(diagramModules);
-        })
-    );
-
-    const actionProvider = container.resolve(DefaultGlobalActionProvider);
-
-    it('serverActionsKinds', () => {
-        const result = actionProvider.actionKinds;
-        expect(result.size).to.be.equal(1);
-        const resultServerActions = result.get(diagramType);
-        expect(resultServerActions).to.not.be.undefined;
-        expect(serverActions.every(action => resultServerActions!.includes(action))).true;
-    });
-});