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

package/src/common/command/command-stack.spec.ts

@@ -1,239 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2023 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 { Container, ContainerModule } from 'inversify';
-import * as sinon from 'sinon';
-import { expectToThrowAsync, StubCommand, StubLogger } from '../test/mock-util';
-import { Logger } from '../utils/logger';
-import { DefaultCommandStack } from './command-stack';
-
-describe('test DefaultCommandStack', () => {
-    const sandbox = sinon.createSandbox();
-    const container = new Container();
-
-    const command1 = sandbox.stub(new StubCommand());
-    const command2 = sandbox.stub(new StubCommand());
-    let commandStack: DefaultCommandStack;
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new StubLogger());
-        })
-    );
-    commandStack = container.resolve(DefaultCommandStack);
-
-    afterEach(() => {
-        sandbox.reset();
-        commandStack = container.resolve(DefaultCommandStack);
-    });
-
-    describe('execute', () => {
-        it('should execute the given command and become dirty', async () => {
-            expect(commandStack.isDirty).to.be.false;
-            await commandStack.execute(command1);
-            expect(command1.execute.calledOnce).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-        });
-
-        it('should execute the given commands in order and become dirty', async () => {
-            expect(commandStack.isDirty).to.be.false;
-            await commandStack.execute(command1);
-            await commandStack.execute(command2);
-
-            expect(command1.execute.calledOnce).to.be.true;
-            expect(command2.execute.calledOnce).to.be.true;
-            expect(command2.execute.calledAfter(command1.execute)).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-        });
-
-        it('should be able to undo after execute', async () => {
-            expect(commandStack.canUndo()).to.be.false;
-            await commandStack.execute(command1);
-            expect(commandStack.canUndo()).to.be.true;
-        });
-
-        it('should clear the redo stack after execution', async () => {
-            commandStack['commands'].push(command2);
-            commandStack['top'] = -1;
-            expect(commandStack.canRedo()).to.be.true;
-
-            await commandStack.execute(command1);
-            expect(commandStack.canRedo()).to.be.false;
-        });
-
-        it('should flush the stack in case of an execution error', async () => {
-            command2.execute.throwsException();
-            const flushSpy = sandbox.spy(commandStack, 'flush');
-
-            await expectToThrowAsync(() => commandStack.execute(command2));
-            expect(command2.execute.calledOnce).to.be.true;
-            expect(flushSpy.calledOnce).to.be.true;
-        });
-    });
-
-    describe('undo', () => {
-        it('should do nothing if the command stack is empty', async () => {
-            expect(commandStack.isDirty).to.be.false;
-
-            await commandStack.undo();
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.false;
-            expect(commandStack.isDirty).to.be.false;
-        });
-
-        it('should undo the command and become non-dirty again', async () => {
-            commandStack['commands'].push(command1);
-            commandStack['top'] = 0;
-            expect(commandStack.isDirty).to.be.true;
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.canRedo()).to.be.false;
-
-            await commandStack.undo();
-            expect(command1.undo.calledOnce).to.be.true;
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canRedo()).to.be.true;
-            expect(commandStack.canUndo()).to.be.false;
-        });
-
-        it('should undo multiple command and become non-dirty again', async () => {
-            commandStack['commands'].push(command1, command2);
-            commandStack['top'] = 1;
-            expect(commandStack.isDirty).to.be.true;
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.canRedo()).to.be.false;
-
-            await commandStack.undo();
-            expect(command2.undo.calledOnce).to.be.true;
-            expect(commandStack.canRedo()).to.be.true;
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-
-            await commandStack.undo();
-            expect(command1.undo.calledOnce).to.be.true;
-            expect(command1.undo.calledAfter(command2.undo)).to.be.true;
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canRedo()).to.be.true;
-            expect(commandStack.canUndo()).to.be.false;
-        });
-        it('should flush the stack in case of an execution error', async () => {
-            command2.undo.throwsException();
-            const flushSpy = sandbox.spy(commandStack, 'flush');
-            commandStack['commands'].push(command2);
-            commandStack['top'] = 0;
-
-            await expectToThrowAsync(() => commandStack.undo());
-            expect(command2.undo.calledOnce).to.be.true;
-            expect(flushSpy.calledOnce).to.be.true;
-        });
-    });
-
-    describe('redo', () => {
-        it('should do nothing if the command stack is empty', async () => {
-            expect(commandStack.isDirty).to.be.false;
-
-            await commandStack.redo();
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.false;
-            expect(commandStack.isDirty).to.be.false;
-        });
-
-        it('should redo the command and become dirty again', async () => {
-            commandStack['commands'].push(command1);
-            commandStack['top'] = -1;
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.true;
-
-            await commandStack.redo();
-            expect(command1.redo.calledOnce).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-            expect(commandStack.canRedo()).to.be.false;
-            expect(commandStack.canUndo()).to.be.true;
-        });
-
-        it('should undo multiple command and become non-dirty again', async () => {
-            commandStack['commands'].push(command2, command1);
-            commandStack['top'] = -1;
-            commandStack['saveIndex'] = -1;
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.true;
-
-            await commandStack.redo();
-            expect(command2.redo.calledOnce).to.be.true;
-            expect(commandStack.canRedo()).to.be.true;
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-
-            await commandStack.redo();
-            expect(command1.redo.calledOnce).to.be.true;
-            expect(command1.redo.calledAfter(command2.redo)).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-            expect(commandStack.canRedo()).to.be.false;
-            expect(commandStack.canUndo()).to.be.true;
-        });
-        it('should flush the stack in case of an execution error', async () => {
-            command2.redo.throwsException();
-            const flushSpy = sandbox.spy(commandStack, 'flush');
-            commandStack['commands'].push(command2);
-            commandStack['top'] = -1;
-
-            await expectToThrowAsync(() => commandStack.redo());
-            expect(command2.redo.calledOnce).to.be.true;
-            expect(flushSpy.calledOnce).to.be.true;
-        });
-        it('should be able to undo after redo', async () => {
-            commandStack['commands'].push(command1);
-            commandStack['top'] = -1;
-            expect(commandStack.canUndo()).to.be.false;
-            await commandStack.redo();
-            expect(commandStack.canUndo()).to.be.true;
-        });
-    });
-
-    describe('flush', () => {
-        it('should reset the internal state of the command stack', () => {
-            commandStack['commands'].push(command1, command1);
-            commandStack['top'] = 0;
-
-            commandStack.flush();
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.false;
-        });
-    });
-
-    describe('isSaveDone', () => {
-        it('should become non-dirty after execution', () => {
-            commandStack['commands'].push(command1);
-            commandStack['top'] = 0;
-            expect(commandStack.isDirty).to.be.true;
-
-            commandStack.saveIsDone();
-            expect(commandStack.isDirty).to.be.false;
-        });
-        it('should maintain undo/redo history after execution', () => {
-            commandStack['commands'].push(command1, command2);
-            commandStack['top'] = 0;
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.canRedo()).to.be.true;
-
-            commandStack.saveIsDone();
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.canRedo()).to.be.true;
-        });
-    });
-});

package/src/common/command/command.spec.ts

@@ -1,92 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2023 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 * as sinon from 'sinon';
-import { expectToThrowAsync, StubCommand } from '../test/mock-util';
-import { CompoundCommand } from './command';
-
-describe('CompoundCommand', () => {
-    const sandbox = sinon.createSandbox();
-
-    const command1 = sandbox.stub(new StubCommand());
-    const command2 = sandbox.stub(new StubCommand());
-    const command3 = sandbox.stub(new StubCommand());
-
-    const compoundCommand = new CompoundCommand(command1, command2, command3);
-
-    afterEach(() => {
-        sandbox.reset();
-    });
-
-    describe('execute', () => {
-        it('Should execute the subcommands in order', async () => {
-            await compoundCommand.execute();
-            expect(command1.execute.calledOnce).to.be.true;
-            expect(command2.execute.calledOnce).to.be.true;
-            expect(command3.execute.calledOnce).to.be.true;
-            expect(command1.execute.calledBefore(command2.execute)).to.be.true;
-            expect(command2.execute.calledBefore(command3.execute)).to.be.true;
-        });
-        it('Should undo partially executed subcommands in  case of an error', async () => {
-            command3.execute.throwsException();
-
-            await expectToThrowAsync(() => compoundCommand.execute());
-
-            expect(command1.execute.calledOnce).to.be.true;
-            expect(command2.execute.calledOnce).to.be.true;
-            expect(command3.execute.calledOnce).to.be.true;
-            expect(command1.undo.calledOnce).to.be.true;
-            expect(command2.undo.calledOnce).to.be.true;
-        });
-    });
-
-    describe('undo', () => {
-        it('Should undo the subcommands in reverse order', async () => {
-            await compoundCommand.undo();
-            expect(command1.undo.calledOnce).to.be.true;
-            expect(command2.undo.calledOnce).to.be.true;
-            expect(command3.undo.calledOnce).to.be.true;
-            expect(command1.undo.calledAfter(command2.undo)).to.be.true;
-            expect(command2.undo.calledAfter(command3.undo)).to.be.true;
-        });
-
-        it('Should redo partially undone subcommands in  case of an error', async () => {
-            command1.undo.throwsException();
-            await expectToThrowAsync(() => compoundCommand.undo());
-
-            expect(command1.undo.calledOnce).to.be.true;
-            expect(command2.undo.calledOnce).to.be.true;
-            expect(command3.undo.calledOnce).to.be.true;
-            expect(command3.redo.calledOnce).to.be.true;
-            expect(command2.redo.calledOnce).to.be.true;
-        });
-    });
-
-    describe('canUndo', () => {
-        it('should return true if all subcommands can be undone', () => {
-            command1.canUndo?.returns(true);
-            command2.canUndo?.returns(true);
-            command3.canUndo?.returns(true);
-            expect(compoundCommand.canUndo()).to.be.true;
-        });
-        it('should return true if anyof the  subcommands cannot be undone', () => {
-            command1.canUndo?.returns(true);
-            command2.canUndo?.returns(false);
-            command3.canUndo?.returns(true);
-            expect(compoundCommand.canUndo()).to.be.true;
-        });
-    });
-});

package/src/common/command/recording-command.spec.ts

@@ -1,86 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { AnyObject, MaybePromise } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { AbstractRecordingCommand } from './recording-command';
-
-interface TestModel {
-    string: string;
-    number: number;
-    flag: boolean;
-    maybe?: AnyObject;
-}
-
-let jsonObject: TestModel;
-
-class TestRecordingCommand<JsonObject extends AnyObject = AnyObject> extends AbstractRecordingCommand<JsonObject> {
-    constructor(
-        protected jsonObject: JsonObject,
-        protected doExecute: () => MaybePromise<void>
-    ) {
-        super();
-    }
-
-    protected getJsonObject(): MaybePromise<JsonObject> {
-        return this.jsonObject;
-    }
-}
-
-describe('RecordingCommand', () => {
-    let beforeState: TestModel;
-
-    beforeEach(() => {
-        jsonObject = {
-            string: 'foo',
-            number: 0,
-            flag: true
-        };
-        beforeState = JSON.parse(JSON.stringify(jsonObject));
-    });
-
-    it('should be undoable after execution', async () => {
-        const command = new TestRecordingCommand(jsonObject, () => {});
-        expect(command.canUndo()).to.be.false;
-        await command.execute();
-        expect(command.canUndo()).to.be.true;
-    });
-
-    it('should restore the pre execution state when undo is called', async () => {
-        const command = new TestRecordingCommand(jsonObject, () => {
-            jsonObject.string = 'bar';
-            jsonObject.flag = false;
-            jsonObject.maybe = { hello: 'world' };
-        });
-        await command.execute();
-        expect(jsonObject).to.not.be.deep.equals(beforeState);
-        await command.undo();
-        expect(jsonObject).to.be.deep.equals(beforeState);
-    });
-
-    it('should restore the post execution state when redo is called', async () => {
-        const command = new TestRecordingCommand(jsonObject, () => {
-            jsonObject.string = 'bar';
-            jsonObject.flag = false;
-            jsonObject.maybe = { hello: 'world' };
-        });
-        await command.execute();
-        const afterState = JSON.parse(JSON.stringify(jsonObject));
-        jsonObject = JSON.parse(JSON.stringify(afterState));
-        await command.redo();
-        expect(jsonObject).to.be.deep.equals(afterState);
-    });
-});

package/src/common/di/binding-target.spec.ts

@@ -1,147 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 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 { Container, ContainerModule, interfaces } from 'inversify';
-import * as sinon from 'sinon';
-import { applyBindingTarget } from './binding-target';
-// Simple no op classes to construct inversify binding syntaxes.
-class Target {}
-
-class SubTarget extends Target {}
-
-describe('BindingTarget', () => {
-    describe('bindTarget()', () => {
-        // Setup nested spies for the fluent inversify binding API
-        let context: {
-            bind: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], interfaces.BindingToSyntax<any>>;
-            isBound: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], boolean>;
-        };
-        let toSyntax: sinon.SinonStubbedInstance<interfaces.BindingToSyntax<any>>;
-        let whenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingWhenOnSyntax<any>>;
-
-        const setupStubs = (): {
-            context: {
-                bind: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], interfaces.BindingToSyntax<any>>;
-                isBound: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], boolean>;
-            };
-            toSyntax: sinon.SinonStubbedInstance<interfaces.BindingToSyntax<any>>;
-            inWhenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingInWhenOnSyntax<any>>;
-            whenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingWhenOnSyntax<any>>;
-        } => {
-            const container = new Container();
-            const bind = sinon.stub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], interfaces.BindingToSyntax<any>>();
-            const isBound = sinon.stub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], boolean>();
-
-            let toSyntax: sinon.SinonStubbedInstance<interfaces.BindingToSyntax<any>> = {} as any;
-            let inWhenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingInWhenOnSyntax<any>> = {} as any;
-            container.load(
-                new ContainerModule(_bind => {
-                    const toStub = _bind('StubMe');
-                    inWhenOnSyntax = sinon.stub(toStub.to(Target));
-                    whenOnSyntax = sinon.stub(toStub.toConstantValue(''));
-                    toSyntax = sinon.stub(toStub);
-
-                    bind.returns(toSyntax);
-                    toSyntax.to.returns(inWhenOnSyntax);
-                    toSyntax.toSelf.returns(inWhenOnSyntax);
-                    toSyntax.toDynamicValue.returns(inWhenOnSyntax);
-                    toSyntax.toService.returns();
-                })
-            );
-
-            return {
-                context: { bind, isBound },
-                toSyntax,
-                inWhenOnSyntax,
-                whenOnSyntax
-            };
-        };
-
-        beforeEach(() => {
-            const stubs = setupStubs();
-            context = stubs.context;
-            toSyntax = stubs.toSyntax;
-            whenOnSyntax = stubs.whenOnSyntax;
-        });
-
-        describe('Bind to constructor', () => {
-            it('Should bind the service identifier `to` the given target with no scope', () => {
-                applyBindingTarget(context, Target, SubTarget);
-                expect(toSyntax.to.calledOnceWith(SubTarget)).to.be.true;
-            });
-
-            it('Should bind the service identifier `toSelf` with no scope', () => {
-                applyBindingTarget(context, Target, Target);
-                expect(toSyntax.toSelf.calledOnce).to.be.true;
-            });
-        });
-
-        describe('Bind to service', () => {
-            it('Should bind the service identifier `service` using the given target service with no scope', () => {
-                context.isBound.returns(true);
-                applyBindingTarget(context, Target, { service: SubTarget });
-                expect(toSyntax.toService.calledOnceWith(SubTarget)).to.be.true;
-            });
-            it('Should throw an error because the given target service is not bound', () => {
-                context.isBound.returns(false);
-                expect(() => applyBindingTarget(context, Target, { service: SubTarget, autoBind: false })).to.throw();
-            });
-            it('Should bind the unbound target service to itself before applying the toService binding', () => {
-                context.isBound.returns(false);
-                applyBindingTarget(context, Target, { service: SubTarget });
-                expect(context.bind.calledWith(Target)).to.be.true;
-            });
-            it('The return syntax should be no op and invocation of a syntax function should throw an error', () => {
-                context.isBound.returns(true);
-                const syntax = applyBindingTarget(context, Target, { service: SubTarget });
-                expect(() => {
-                    syntax.inRequestScope();
-                }).to.throw(
-                    `${Target.toString()} has been bound to 'service'.` +
-                        "Using 'in','when' or 'on' bindings after" +
-                        "a 'toService' binding is not possible."
-                );
-            });
-        });
-
-        describe('Bind to constant value', () => {
-            it('Should bind the service identifier `toConstantValue` using the given target with no scope', () => {
-                const subTarget = new SubTarget();
-                applyBindingTarget(context, Target, { constantValue: subTarget });
-                expect(toSyntax.toConstantValue.calledOnceWith(subTarget)).to.be.true;
-            });
-            it("The return syntax's in functions should be no op and invocation should log a warning", () => {
-                const spy = sinon.spy(console, 'warn');
-                const subTarget = new SubTarget();
-                const syntax = applyBindingTarget(context, Target, { constantValue: subTarget });
-                syntax.inSingletonScope();
-                expect(
-                    spy.calledWith(
-                        `${Target.toString()} has been bound to 'constantValue'. Binding in Singleton scope has no effect.` +
-                            'Constant value bindings are effectively Singleton bindings.'
-                    )
-                ).to.be.true;
-            });
-        });
-
-        describe('Bind to dynamic value', () => {
-            it('Should bind the service identifier `toDynamicValue` using the given factory function with no scope', () => {
-                applyBindingTarget(context, Target, { dynamicValue: context => new SubTarget() });
-                expect(toSyntax.toDynamicValue.calledOnce);
-            });
-        });
-    });
-});