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

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

package/src/common/test/mock-util.ts

@@ -1,281 +0,0 @@
-/********************************************************************************
- * 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
- * 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
- ********************************************************************************/
-
-// Stub-implementation classes used for unit testing
-
-import { GEdge, GModelElement, GModelElementConstructor, GNode } from '@eclipse-glsp/graph';
-import {
-    Action,
-    ActionMessage,
-    Args,
-    CreateNodeOperation,
-    EdgeTypeHint,
-    GLSPClientProxy,
-    GLSPServer,
-    GLSPServerListener,
-    InitializeClientSessionParameters,
-    MaybeArray,
-    MaybePromise,
-    Point,
-    RequestAction,
-    RequestEditValidationAction,
-    ResponseAction,
-    ShapeTypeHint,
-    ValidationStatus
-} from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { Container } from 'inversify';
-import { MessageConnection } from 'vscode-jsonrpc';
-import { ActionDispatcher } from '../actions/action-dispatcher';
-import { ActionHandler, ActionHandlerFactory } from '../actions/action-handler';
-import { Command } from '../command/command';
-import { DiagramConfiguration, ServerLayoutKind } from '../diagram/diagram-configuration';
-import { ContextEditValidator } from '../features/directediting/context-edit-validator';
-import { LabelEditValidator } from '../features/directediting/label-edit-validator';
-import { GModelCreateEdgeOperationHandler } from '../gmodel/gmodel-create-edge-operation-handler';
-import { GModelCreateNodeOperationHandler } from '../gmodel/gmodel-create-node-operation-handler';
-import { ClientSession } from '../session/client-session';
-import { ClientSessionFactory } from '../session/client-session-factory';
-import { ClientSessionInitializer } from '../session/client-session-initializer';
-import { ClientSessionListener } from '../session/client-session-listener';
-import { ClientSessionManager } from '../session/client-session-manager';
-import { LogLevel, Logger } from '../utils/logger';
-
-export async function delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Consumes a maybe async function and checks for error
- * @param  method - The function to check
- * @param  message - Optional message to match with error message
- */
-export async function expectToThrowAsync(toEvaluate: () => MaybePromise<void>, message?: string): Promise<void> {
-    let err: Error | undefined = undefined;
-    try {
-        await toEvaluate();
-    } catch (error: any) {
-        err = error;
-    }
-    if (message) {
-        expect(err?.message).to.be.equal(message);
-    } else {
-        expect(err).to.be.an('Error');
-    }
-}
-
-export function createClientSession(
-    id: string,
-    diagramType: string,
-    container = new Container(),
-    actionDispatcher = new StubActionDispatcher()
-): ClientSession {
-    return {
-        id,
-        diagramType,
-        container,
-        actionDispatcher,
-        dispose: () => {
-            //
-        }
-    };
-}
-
-export class StubActionHandler implements ActionHandler {
-    constructor(public actionKinds: string[]) {}
-
-    execute(action: Action): MaybePromise<Action[]> {
-        return [];
-    }
-}
-
-export class StubCreateNodeOperationHandler extends GModelCreateNodeOperationHandler {
-    elementTypeIds: string[];
-
-    constructor(readonly label: string) {
-        super();
-        this.elementTypeIds = [label];
-    }
-
-    createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined {
-        return new GNode();
-    }
-}
-
-export class StubCreateEdgeOperationHandler extends GModelCreateEdgeOperationHandler {
-    elementTypeIds: string[];
-
-    constructor(readonly label: string) {
-        super();
-        this.elementTypeIds = [label];
-    }
-
-    createEdge(source: GModelElement, target: GModelElement): GEdge | undefined {
-        return undefined;
-    }
-}
-
-export class StubActionDispatcher implements ActionDispatcher {
-    dispatchAfterNextUpdate(...actions: MaybeArray<Action[]>): void {}
-
-    dispatch(action: Action): Promise<void> {
-        return Promise.resolve();
-    }
-
-    dispatchAll(...actions: MaybeArray<Action>[]): Promise<void> {
-        return Promise.resolve();
-    }
-
-    request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {
-        return Promise.reject(new Error('Not implemented in stub'));
-    }
-
-    requestUntil<Res extends ResponseAction>(
-        action: RequestAction<Res>,
-        timeoutMs?: number,
-        rejectOnTimeout?: boolean
-    ): Promise<Res | undefined> {
-        return Promise.reject(new Error('Not implemented in stub'));
-    }
-}
-
-export class StubClientSessionFactory implements ClientSessionFactory {
-    create(params: InitializeClientSessionParameters): ClientSession {
-        const { clientSessionId, diagramType } = params;
-        return createClientSession(clientSessionId, diagramType);
-    }
-}
-
-export class StubClientSessionManager implements ClientSessionManager {
-    getOrCreateClientSession(params: InitializeClientSessionParameters): ClientSession {
-        const { clientSessionId, diagramType } = params;
-        return createClientSession(clientSessionId, diagramType);
-    }
-
-    getSession(clientSessionId: string): ClientSession | undefined {
-        return undefined;
-    }
-
-    getSessions(): ClientSession[] {
-        return [];
-    }
-
-    getSessionsByType(diagramType: string): ClientSession[] {
-        return [];
-    }
-
-    disposeClientSession(clientSessionId: string): boolean {
-        return true;
-    }
-
-    addListener(listener: ClientSessionListener, ...clientSessionIds: string[]): boolean {
-        return true;
-    }
-
-    removeListener(listener: ClientSessionListener): boolean {
-        return true;
-    }
-
-    removeListeners(...clientSessionIds: string[]): void {
-        return undefined;
-    }
-}
-
-export class StubLogger extends Logger {
-    logLevel = LogLevel.none;
-    caller = undefined;
-
-    info(message: string, ...params: any[]): void {}
-
-    warn(message: string, ...params: any[]): void {}
-
-    error(message: string, ...params: any[]): void {}
-
-    debug(message: string, ...params: any[]): void {}
-}
-
-export class StubClientSessionListener implements ClientSessionListener {
-    sessionCreated(clientSession: ClientSession): void {}
-
-    sessionDisposed(clientSession: ClientSession): void {}
-}
-
-export class StubGLSPClientProxy implements GLSPClientProxy {
-    connect(connection: MessageConnection): void {}
-
-    process(message: ActionMessage<Action>): void {}
-}
-
-export class StubGLSPServerListener implements GLSPServerListener {
-    serverInitialized(server: GLSPServer): void {}
-
-    serverShutDown(server: GLSPServer): void {}
-}
-
-export class StubDiagramConfiguration implements DiagramConfiguration {
-    typeMapping = new Map<string, GModelElementConstructor>();
-
-    shapeTypeHints: ShapeTypeHint[] = [];
-
-    edgeTypeHints: EdgeTypeHint[] = [];
-
-    layoutKind = ServerLayoutKind.NONE;
-
-    needsClientLayout = true;
-
-    animatedUpdate = true;
-}
-
-export class TestLabelEditValidator extends LabelEditValidator {
-    validate(label: string, element: GModelElement): ValidationStatus {
-        if (label === 'error') {
-            return { severity: ValidationStatus.Severity.ERROR, message: 'error' };
-        }
-        if (label === 'warning') {
-            return { severity: ValidationStatus.Severity.WARNING, message: 'warning' };
-        }
-        return { severity: ValidationStatus.Severity.OK, message: 'ok' };
-    }
-}
-
-export class TestContextEditValidator implements ContextEditValidator {
-    get contextId(): string {
-        return 'test';
-    }
-
-    validate(action: RequestEditValidationAction): ValidationStatus {
-        if (action.text === 'error') {
-            return { severity: ValidationStatus.Severity.ERROR, message: 'error' };
-        }
-        if (action.text === 'warning') {
-            return { severity: ValidationStatus.Severity.WARNING, message: 'warning' };
-        }
-        return { severity: ValidationStatus.Severity.OK, message: 'ok' };
-    }
-}
-
-export const stubActionHandlerFactory: ActionHandlerFactory = constructor => new constructor();
-
-export class StubClientSessionInitializer implements ClientSessionInitializer {
-    initialize(args?: Args): void {}
-}
-
-export class StubCommand implements Command {
-    execute(): void {}
-    undo(): void {}
-    redo(): void {}
-    canUndo?(): boolean;
-}

package/src/common/utils/action-queue.spec.ts

@@ -1,133 +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 { expect } from 'chai';
-import { expectToThrowAsync } from '../test/mock-util';
-import { ActionQueue } from './action-queue';
-
-describe('ActionQueue', () => {
-    it('yields pushed items in FIFO order', async () => {
-        const channel = new ActionQueue<number>();
-        const consumed: number[] = [];
-
-        const consumer = (async (): Promise<void> => {
-            for await (const entry of channel.consume()) {
-                consumed.push(entry.item);
-                entry.resolve();
-            }
-        })();
-
-        await Promise.all([channel.push(1), channel.push(2), channel.push(3)]);
-        channel.stop();
-        await consumer;
-
-        expect(consumed).to.deep.equal([1, 2, 3]);
-    });
-
-    it('resolves the push promise once the consumer resolves the entry', async () => {
-        const channel = new ActionQueue<string>();
-        let entryResolver: (() => void) | undefined;
-
-        const consumer = (async (): Promise<void> => {
-            for await (const entry of channel.consume()) {
-                entryResolver = entry.resolve;
-                return;
-            }
-        })();
-
-        const pushed = channel.push('a');
-        // Give the consumer a turn to pick up the entry.
-        await Promise.resolve();
-        await consumer;
-        expect(entryResolver).to.exist;
-        entryResolver!();
-        await pushed;
-    });
-
-    it('propagates reject() from the consumer back to the pushing caller', async () => {
-        const channel = new ActionQueue<number>();
-
-        const consumer = (async (): Promise<void> => {
-            for await (const entry of channel.consume()) {
-                entry.reject(new Error('boom'));
-                return;
-            }
-        })();
-
-        const pushed = channel.push(1);
-        await consumer;
-        await expectToThrowAsync(() => pushed, 'boom');
-    });
-
-    it('rejects push() after stop()', async () => {
-        const channel = new ActionQueue<number>();
-        channel.stop();
-        await expectToThrowAsync(() => channel.push(1), 'ActionQueue is stopped');
-    });
-
-    it('consumer exits after stop() and drain', async () => {
-        const channel = new ActionQueue<number>();
-        const consumed: number[] = [];
-
-        const consumer = (async (): Promise<void> => {
-            for await (const entry of channel.consume()) {
-                consumed.push(entry.item);
-                entry.resolve();
-            }
-        })();
-
-        await channel.push(1);
-        await channel.push(2);
-        channel.stop();
-        await consumer;
-
-        expect(consumed).to.deep.equal([1, 2]);
-        expect(channel.isStopped).to.be.true;
-    });
-
-    it('rejectPending() rejects all queued push() promises without stopping', async () => {
-        const channel = new ActionQueue<number>();
-        const pushes = [channel.push(1), channel.push(2)];
-        expect(channel.size).to.equal(2);
-
-        channel.rejectPending(new Error('cleared'));
-
-        await expectToThrowAsync(() => pushes[0], 'cleared');
-        await expectToThrowAsync(() => pushes[1], 'cleared');
-        expect(channel.size).to.equal(0);
-        expect(channel.isStopped).to.be.false;
-    });
-
-    it('size reflects the number of unconsumed entries', async () => {
-        const channel = new ActionQueue<number>();
-        channel.push(1);
-        channel.push(2);
-        channel.push(3);
-        expect(channel.size).to.equal(3);
-    });
-
-    it('throws when a second consumer is started', async () => {
-        const channel = new ActionQueue<number>();
-        const first = channel.consume();
-        // Kick off the first consumer so it registers as the active consumer.
-        const firstStep = first.next();
-
-        const second = channel.consume();
-        await expectToThrowAsync(() => second.next().then(() => undefined), 'ActionQueue supports only a single consumer');
-
-        channel.stop();
-        await firstStep;
-    });
-});

package/src/common/utils/promise-queue.spec.ts

@@ -1,142 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { delay } from '../test/mock-util';
-
-import { expect } from 'chai';
-// eslint-disable-next-line import-x/no-deprecated
-import { PromiseQueue } from './promise-queue';
-
-// Helper types and functions that are needed for test setup
-
-/**
- * Helper class to inspect the state of promise during its resolve() execution.
- */
-class PromiseState {
-    private _started = false;
-    private _stopped = false;
-    onStartRunnable?: () => void;
-    onStopRunnable?: () => void;
-
-    start(): void {
-        this._started = true;
-        if (this.onStartRunnable) {
-            this.onStartRunnable();
-        }
-    }
-
-    stop(): void {
-        this._stopped = true;
-        if (this.onStopRunnable) {
-            this.onStopRunnable();
-        }
-    }
-
-    onStart(runnable: () => void): void {
-        this.onStartRunnable = runnable;
-    }
-
-    onStop(runnable: () => void): void {
-        this.onStopRunnable = runnable;
-    }
-
-    get started(): boolean {
-        return this._started;
-    }
-
-    get stopped(): boolean {
-        return this._stopped;
-    }
-}
-
-interface TestPromise {
-    state: PromiseState;
-    promise: () => Promise<void>;
-}
-
-function newTestPromise(resolveTime: number): TestPromise {
-    const state = new PromiseState();
-    const promise = async (): Promise<void> => {
-        state.start();
-        await delay(resolveTime);
-        state.stop();
-    };
-    return { state, promise };
-}
-
-// eslint-disable-next-line @typescript-eslint/no-deprecated, import-x/no-deprecated
-let queue = new PromiseQueue();
-
-// Test execution
-describe('test PromiseQueue', () => {
-    beforeEach(() => {
-        // eslint-disable-next-line import-x/no-deprecated, @typescript-eslint/no-deprecated
-        queue = new PromiseQueue();
-    });
-    it('enqueue - one element', async () => {
-        const { state, promise } = newTestPromise(100);
-        state.onStart(() => {
-            expect(queue.isBusy).true;
-        });
-        const queEnd = queue.enqueue(promise);
-        expect(queue.isEmpty).true;
-        await queEnd;
-    });
-
-    it('enqueue - two elements', async () => {
-        const p1 = newTestPromise(100);
-        p1.state.onStop(() => expect(p2.state.started).false);
-
-        const p2 = newTestPromise(100);
-
-        p2.state.onStart(() => {
-            expect(queue.isEmpty).true;
-            expect(p1.state.stopped).true;
-        });
-
-        queue.enqueue(p1.promise);
-        const queEnd = queue.enqueue(p2.promise);
-        expect(queue.size).to.be.equal(1);
-        await queEnd;
-    });
-
-    it('enqueue - three elements (first promise in queue has longest resolve time)', async () => {
-        const p1 = newTestPromise(300);
-        p1.state.onStop(() => {
-            expect(p2.state.started).false;
-            expect(p3.state.started).false;
-        });
-
-        const p2 = newTestPromise(200);
-        p2.state.onStart(() => {
-            expect(queue.size).to.be.equal(1);
-            expect(p1.state.stopped).true;
-            expect(p3.state.started).false;
-        });
-
-        const p3 = newTestPromise(100);
-        p3.state.onStart(() => {
-            expect(queue.isEmpty).true;
-            expect(p2.state.stopped).true;
-        });
-
-        queue.enqueue(p1.promise);
-        queue.enqueue(p2.promise);
-        expect(queue.size).to.be.equal(1);
-        const queueEnd = queue.enqueue(p3.promise);
-        expect(queue.size).to.be.equal(2);
-        await queueEnd;
-    });
-});