@eclipse-glsp/client 0.10.0-next.ca17587.154 → 1.1.0-RC01

package/src/features/layout/{layout-commands.spec.ts → layout-elements-action.spec.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 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
@@ -13,8 +13,16 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-/* eslint-disable import/no-deprecated,no-unused-expressions */
-import { Action, Bounds, ChangeBoundsOperation, ElementAndBounds } from '@eclipse-glsp/protocol';
+/* eslint-disable deprecation/deprecation */
+import {
+    Action,
+    Bounds,
+    ChangeBoundsOperation,
+    ElementAndBounds,
+    RequestAction,
+    ResponseAction,
+    SetBoundsAction
+} from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import 'mocha';
@@ -29,28 +37,23 @@ import {
     IActionDispatcher,
     MoveAction,
     MoveCommand,
-    RequestAction,
-    ResponseAction,
     SChildElement,
-    SetBoundsAction,
     SetBoundsCommand,
     SGraphFactory,
-    SModelRoot,
-    TYPES
+    SModelRoot
 } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { resizeFeature } from '../change-bounds/model';
 import { SelectionService } from '../select/selection-service';
 import { FeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
 import {
     AlignElementsAction,
-    AlignElementsCommand,
+    AlignElementsActionHandler,
     Alignment,
-    Reduce,
     ResizeDimension,
     ResizeElementsAction,
-    ResizeElementsCommand
-} from './layout-commands';
+    ResizeElementsActionHandler
+} from './layout-elements-action';
 
 class MockActionDispatcher implements IActionDispatcher {
     constructor(public dispatchedActions: Action[] = []) {}
@@ -67,14 +70,21 @@ class MockActionDispatcher implements IActionDispatcher {
     }
 }
 
+class MockSelectionService extends SelectionService {
+    constructor(public modelRoot: SModelRoot) {
+        super();
+    }
+    override getModelRoot(): Readonly<SModelRoot> {
+        return this.modelRoot;
+    }
+}
+
+// Generic Test setup
 const container = new Container();
 container.load(defaultModule);
-container.bind(GLSP_TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
-container.bind(SelectionService).toSelf().inSingletonScope();
-container.bind(GLSP_TYPES.SelectionService).toService(SelectionService);
+container.bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
 container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
 const graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
-const selectionService = container.get<SelectionService>(GLSP_TYPES.SelectionService);
 
 const actionDispatcher = new MockActionDispatcher();
 
@@ -121,16 +131,26 @@ const context: CommandExecutionContext = {
 const defaultSize = { height: 10, width: 10 };
 
 describe('AlignElementsCommand', () => {
-    it('should align all elements left', () => {
+    let handler: AlignElementsActionHandler;
+    const setModel = (newModel: SModelRoot): void => {
+        handler['selectionService'] = new MockSelectionService(newModel);
+    };
+
+    beforeEach(() => {
         actionDispatcher.dispatchedActions = [];
+
+        handler = new AlignElementsActionHandler();
+        handler['actionDispatcher'] = actionDispatcher;
+    });
+    it('should align all elements left', () => {
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Left);
-        const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Left });
+        setModel(newModel);
+        handler.handle(action);
 
         assertAllBounds(
             new Map([
@@ -142,16 +162,14 @@ describe('AlignElementsCommand', () => {
     });
 
     it('should align all elements right', () => {
-        actionDispatcher.dispatchedActions = [];
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Right);
-        const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
-
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Right });
+        setModel(newModel);
+        handler.handle(action);
         assertAllBounds(
             new Map([
                 ['node1', { x: 333, y: 111, width: defaultSize.width, height: defaultSize.height }],
@@ -168,9 +186,9 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Center);
-        const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Center });
+        setModel(newModel);
+        handler.handle(action);
 
         assertAllBounds(
             new Map([
@@ -182,15 +200,14 @@ describe('AlignElementsCommand', () => {
     });
 
     it('should align all elements top', () => {
-        actionDispatcher.dispatchedActions = [];
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Top);
-        const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Top });
+        setModel(newModel);
+        handler.handle(action);
 
         assertAllBounds(
             new Map([
@@ -202,15 +219,14 @@ describe('AlignElementsCommand', () => {
     });
 
     it('should align all elements bottom', () => {
-        actionDispatcher.dispatchedActions = [];
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Bottom);
-        const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Bottom });
+        setModel(newModel);
+        handler.handle(action);
 
         assertAllBounds(
             new Map([
@@ -222,15 +238,14 @@ describe('AlignElementsCommand', () => {
     });
 
     it('should align all elements middle', () => {
-        actionDispatcher.dispatchedActions = [];
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Middle);
-        const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Middle });
+        setModel(newModel);
+        handler.handle(action);
 
         assertAllBounds(
             new Map([
@@ -243,16 +258,30 @@ describe('AlignElementsCommand', () => {
 });
 
 describe('ResizeElementsCommand', () => {
-    it('should make same width as last', () => {
+    let handler: ResizeElementsActionHandler;
+    const setModel = (newModel: SModelRoot): void => {
+        handler['selectionService'] = new MockSelectionService(newModel);
+    };
+
+    beforeEach(() => {
         actionDispatcher.dispatchedActions = [];
+
+        handler = new ResizeElementsActionHandler();
+        handler['actionDispatcher'] = actionDispatcher;
+    });
+    it('should make same width as last', () => {
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 100, y: 100 }, newSize: { height: 10, width: 10 } },
             { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
             { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
         ]);
-        const action = new ResizeElementsAction(['node1', 'node2', 'node3'], ResizeDimension.Width, Reduce.last);
-        const command = new ResizeElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = ResizeElementsAction.create({
+            elementIds: ['node1', 'node2', 'node3'],
+            dimension: ResizeDimension.Width,
+            reduceFunction: 'last'
+        });
+        setModel(newModel);
+        handler.handle(action);
 
         // resize is keeping the center, so the X moves by diff / 2
         assertAllBoundsInChangeBounds(
@@ -265,15 +294,18 @@ describe('ResizeElementsCommand', () => {
     });
 
     it('should make same height as last', () => {
-        actionDispatcher.dispatchedActions = [];
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 100, y: 100 }, newSize: { height: 10, width: 10 } },
             { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
             { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
         ]);
-        const action = new ResizeElementsAction(['node1', 'node2', 'node3'], ResizeDimension.Height, Reduce.last);
-        const command = new ResizeElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = ResizeElementsAction.create({
+            elementIds: ['node1', 'node2', 'node3'],
+            dimension: ResizeDimension.Height,
+            reduceFunction: 'last'
+        });
+        setModel(newModel);
+        handler.handle(action);
 
         // resize is keeping the center, so the Y moves by diff / 2
         assertAllBoundsInChangeBounds(
@@ -286,15 +318,18 @@ describe('ResizeElementsCommand', () => {
     });
 
     it('should make same width and height as last', () => {
-        actionDispatcher.dispatchedActions = [];
         const newModel = initModel([
             { elementId: 'node1', newPosition: { x: 100, y: 100 }, newSize: { height: 10, width: 10 } },
             { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
             { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
         ]);
-        const action = new ResizeElementsAction(['node1', 'node2', 'node3'], ResizeDimension.Width_And_Height, Reduce.last);
-        const command = new ResizeElementsCommand(action, actionDispatcher, selectionService);
-        command.execute(newContext(newModel));
+        const action = ResizeElementsAction.create({
+            elementIds: ['node1', 'node2', 'node3'],
+            dimension: ResizeDimension.Width_And_Height,
+            reduceFunction: 'last'
+        });
+        setModel(newModel);
+        handler.handle(action);
 
         // resize is keeping the center, so the Y moves by diff / 2
         assertAllBoundsInChangeBounds(
@@ -308,22 +343,11 @@ describe('ResizeElementsCommand', () => {
 });
 
 function initModel(elementAndBounds: ElementAndBounds[]): SModelRoot {
-    const mySetBoundsAction = new SetBoundsAction(elementAndBounds);
+    const mySetBoundsAction = SetBoundsAction.create(elementAndBounds);
     const setBoundsCommand = new SetBoundsCommand(mySetBoundsAction);
     return setBoundsCommand.execute(context) as SModelRoot;
 }
 
-function newContext(root: SModelRoot): CommandExecutionContext {
-    return {
-        root: root,
-        modelFactory: graphFactory,
-        duration: 0,
-        modelChanged: undefined!,
-        logger: new ConsoleLogger(),
-        syncer: new AnimationFrameSyncer()
-    };
-}
-
 function assertAllBounds(allBounds: Map<string, Bounds>): void {
     allBounds.forEach((bounds, nodeId) => assertBounds(nodeId, bounds));
 }