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

package/src/common/features/directediting/request-edit-validation-handler.spec.ts

@@ -0,0 +1,131 @@
+/********************************************************************************
+ * 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 { GNode } from '@eclipse-glsp/graph';
+import { RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { TestContextEditValidator, TestLabelEditValidator } from '../../test/mock-util';
+import { GModelIndex } from '../model/gmodel-index';
+import { DefaultModelState } from '../model/model-state';
+import { ContextEditValidator } from './context-edit-validator';
+import { DefaultContextEditValidatorRegistry } from './context-edit-validator-registry';
+import { LabelEditValidator } from './label-edit-validator';
+import { RequestEditValidationHandler } from './request-edit-validation-handler';
+
+describe('Test RequestEditValidationHandler', () => {
+    const contextEditValidators: ContextEditValidator[] = [new TestContextEditValidator()];
+    const modelState = new DefaultModelState();
+    Object.defineProperty(modelState, 'index', { value: new GModelIndex() });
+    sinon.stub(modelState.index, 'get').callsFake(() => new GNode());
+    const contextEditValidatorsRegistry = new DefaultContextEditValidatorRegistry(
+        modelState,
+        contextEditValidators,
+        new TestLabelEditValidator()
+    );
+
+    const requestEditValidationHandler = new RequestEditValidationHandler();
+    requestEditValidationHandler['contextEditValidatorRegistry'] = contextEditValidatorsRegistry;
+
+    it('requestContextEditValidation with ok result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'ok' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.OK);
+        expect(status.message).to.be.equal('ok');
+    });
+
+    it('requestContextEditValidation with warning result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'warning' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.WARNING);
+        expect(status.message).to.be.equal('warning');
+    });
+
+    it('requestContextEditValidation with error result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'error' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.ERROR);
+        expect(status.message).to.be.equal('error');
+    });
+
+    it('requestLabelEditValidation with ok result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'ok' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.OK);
+        expect(status.message).to.be.equal('ok');
+    });
+
+    it('requestLabelEditValidation with warning result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'warning' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.WARNING);
+        expect(status.message).to.be.equal('warning');
+    });
+
+    it('requestLabelEditValidation with error result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'error' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.ERROR);
+        expect(status.message).to.be.equal('error');
+    });
+});

package/src/common/features/directediting/request-edit-validation-handler.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Action, MaybePromise, RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { Logger } from '../../utils/logger';
+import { ContextEditValidatorRegistry } from './context-edit-validator-registry';
+
+@injectable()
+export class RequestEditValidationHandler implements ActionHandler {
+    actionKinds = [RequestEditValidationAction.KIND];
+
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(ContextEditValidatorRegistry)
+    contextEditValidatorRegistry: ContextEditValidatorRegistry;
+
+    execute(action: RequestEditValidationAction): MaybePromise<Action[]> {
+        const validator = this.contextEditValidatorRegistry.get(action.contextId);
+        if (validator) {
+            const validationStatus = validator.validate(action);
+            return [SetEditValidationResultAction.create(validationStatus)];
+        } else {
+            const message = `No validator registered for the context '${action.contextId}'`;
+            this.logger.warn(message);
+            return [SetEditValidationResultAction.create({ severity: ValidationStatus.Severity.WARNING, message: message })];
+        }
+    }
+}

package/src/common/features/layout/layout-engine.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * 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 { GModelRoot } from '@eclipse-glsp/graph';
+import { MaybePromise } from '@eclipse-glsp/protocol';
+
+/**
+ * A layout engine is able to compute layout information for a model.
+ */
+export interface LayoutEngine {
+    /**
+     * Computes a layout for the model state and modify the model accordingly.
+     * @returns the layouted {@link GModelRoot}.
+     */
+    layout(): MaybePromise<GModelRoot>;
+}
+
+export const LayoutEngine = Symbol('LayoutEngine');

package/src/common/features/layout/layout-operation-handler.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * 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 { LayoutOperation, Operation } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
+import { OperationHandler } from '../../operations/operation-handler';
+import { Logger } from '../../utils/logger';
+import { LayoutEngine } from './layout-engine';
+
+@injectable()
+export class LayoutOperationHandler implements OperationHandler {
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(LayoutEngine)
+    @optional()
+    protected layoutEngine?: LayoutEngine;
+
+    @inject(DiagramConfiguration)
+    protected diagramConfiguration: DiagramConfiguration;
+
+    readonly operationType = LayoutOperation.KIND;
+    async execute(operation: Operation): Promise<void> {
+        if (operation.kind === LayoutOperation.KIND) {
+            if (this.diagramConfiguration.layoutKind === ServerLayoutKind.MANUAL) {
+                if (this.layoutEngine) {
+                    await this.layoutEngine.layout();
+                    return;
+                }
+                this.logger.warn('Could not execute layout operation. No `LayoutEngine` is bound!');
+            }
+        }
+    }
+}

package/src/common/features/model/gmodel-factory.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+
+export const GModelFactory = Symbol('GModelFactory');
+
+/**
+ * A graph model factory produces a graph model from the model state; typically its contained source model.
+ *
+ * The responsibility of a {@link GModelFactory} implementation is to define how a {@link ModelState} is to be
+ * translated into a {@link GModelRoot} that is sent to the client for rendering. Before a {@link GModelFactory}
+ * is invoked, the {@link SourceModelStorage} has already been executed for loading the source model into the
+ * {@link ModelState}. The {@link GModelFactory} then produces the {@link GModelRoot} from the source model in the
+ * {@link ModelState}. Implementations of {@link GModelFactory} are usually specific to the type of source model, as
+ * they need to understand the source model in order to translate it into a graph model.
+ *
+ * The graph model factory is invoked after initial load of the source model and after each operation that is applied
+ * to the source model by an {@link OperationHandler} in order to update the graph model before sending it to the client
+ * for rendering.
+ *
+ * If an index is needed for mapping between the graph model and the source model, as is typically the case for
+ * {@link ActionHandler action handlers} and {@link OperationHandler operation handlers}, it is the responsibility of
+ * the graph model factory to create such an index while producing the graph model from the source model. The index
+ * shall be put into the model state too. Typically the {@link GModelIndex} is extended for a particular model source
+ * type as well.
+ *
+ * @see SourceModelStorage
+ * @see GModelIndex
+ */
+export interface GModelFactory {
+    /**
+     * Create a {@link GModelRoot} from the specified <code>modelState</code> and puts it into the
+     * <code>modelState</code>. Optionally, this step also produces and sets a {@link GModelIndex} in the model state
+     * that allows mapping from graph model elements to source model elements and vice versa.
+     */
+    createModel(): void;
+}
+
+/**
+ * GModelFactory to be used if the graph model is already available from the model source.
+ */
+@injectable()
+export class GModelFactoryNullImpl implements GModelFactory {
+    createModel(): void {
+        // no-op
+    }
+}

package/src/common/features/model/gmodel-index.ts

@@ -0,0 +1,195 @@
+/********************************************************************************
+ * 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 { GEdge, GModelElement, GModelElementConstructor, GModelRoot, GNode } from '@eclipse-glsp/graph';
+import { TypeGuard } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { getOrThrow, GLSPServerError } from '../../utils/glsp-server-error';
+
+/**
+ * Is used to index all child elements of a {@link GModelRoot} by their id. Offers a set
+ * of query methods to retrieve indexed elements.
+ */
+@injectable()
+export class GModelIndex {
+    protected idToElement: Map<string, GModelElement>;
+    protected typeToElements: Map<string, GModelElement[]>;
+
+    constructor() {
+        this.idToElement = new Map();
+        this.typeToElements = new Map();
+    }
+
+    clear(): void {
+        this.idToElement.clear();
+        this.typeToElements.clear();
+    }
+
+    indexRoot(root: GModelRoot): void {
+        this.clear();
+        this.doIndex(root);
+    }
+
+    protected doIndex(element: GModelElement): void {
+        if (this.idToElement.has(element.id)) {
+            throw new GLSPServerError('Duplicate ID in model: ' + element.id);
+        }
+        this.idToElement.set(element.id, element);
+        const typeSet = this.typeToElements.get(element.type) ?? [];
+        typeSet.push(element);
+        this.typeToElements.set(element.type, typeSet);
+        (element.children ?? []).forEach(child => {
+            this.doIndex(child);
+            // Double check wether the parent reference of the child is set correctly
+            if (!child.parent) {
+                child.parent = element;
+            }
+        });
+    }
+
+    find(elementId: string, predicate?: (test: GModelElement) => boolean): GModelElement | undefined {
+        const element = this.idToElement.get(elementId);
+        if (element && predicate ? predicate(element) : true) {
+            return element;
+        }
+        return undefined;
+    }
+
+    findByClass<G extends GModelElement>(elementTypeId: string, constructor: GModelElementConstructor<G>): G | undefined {
+        const element = this.find(elementTypeId);
+        if (element && element instanceof constructor) {
+            return element;
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns an optional {@link GModelElement} by its elementId.
+     *
+     * @param elementId The id of the requested {@link GModelElement}.
+     * @returns An optional instance of the {@link GModelElement}.
+     */
+    get(elementId: string): GModelElement {
+        return getOrThrow(this.find(elementId), `Could not retrieve element with id: '${elementId}'`);
+    }
+
+    /**
+     * Returns a set of {@link GModelElement} instances by a Collection of elementIds.
+     *
+     * @param elementIds The ids to request the {@link GModelElement} from an array of elementIds.
+     * @returns A set of {@link GModelElement}s.
+     */
+    getAll(elementIds: string[]): GModelElement[] {
+        return elementIds.map(id => this.idToElement.get(id)).filter(element => element) as GModelElement[];
+    }
+
+    /**
+     * Returns all elements of the type constructor contained in the {@link GModelRoot}.
+     *
+     * @type Type of the elements to be returned.
+     * @param constructor The class of which the returned elements should be instances.
+     * @returns A set containing the elements of type constructor.
+     */
+    getAllByClass<G extends GModelElement>(constructor: GModelElementConstructor<G>): G[] {
+        return Array.from(this.idToElement.values()).filter(element => element instanceof constructor) as G[];
+    }
+
+    /**
+     * Returns a list of all {@link GModelElement} ids contained in this instance of the GModelIndex.
+     *
+     * @returns A list of elementIds.
+     */
+    allIds(): string[] {
+        return Array.from(this.idToElement.keys());
+    }
+
+    /**
+     * Returns all elements of a type {@link GModelRoot}.
+     *
+     * @param type   Type of the elements to be returned.
+     * @returns A set containing the elements of the given type.
+     */
+    getElements(type: string): GModelElement[] {
+        return this.typeToElements.get(type) ?? [];
+    }
+
+    /**
+     * Returns the current amount of type occurrences in this instance of the GModelIndex.
+     *
+     * @param eClass The EClass to be counted in this instance of the GModelIndex.
+     *
+     * @returns The amount of type occurrences.
+     */
+    typeCount(type: string): number {
+        return this.getElements(type).length;
+    }
+
+    /**
+     * Returns all incoming edges for a node.
+     *
+     * @param node The node where the edges are connected.
+     *
+     * @returns All incoming edges.
+     */
+    getIncomingEdges(node: GNode): GEdge[] {
+        return this.getAllEdges().filter(edge => edge.targetId === node.id);
+    }
+
+    /**
+     * Returns all outgoing edges for a node.
+     *
+     * @param node The node where the edges are connected.
+     *
+     * @returns All outgoing edges.
+     */
+    getOutgoingEdges(node: GModelElement): GEdge[] {
+        return this.getAllEdges().filter(edge => edge.sourceId === node.id);
+    }
+
+    /**
+     * Returns all edges in the index.
+     *
+     * @returns All edges in the index.
+     */
+    getAllEdges(): GEdge[] {
+        return this.getAllByClass(GEdge);
+    }
+
+    /**
+     * Returns the first element matching the given {@link TypeGuard} starting element with the
+     * given id and walking up the parent hierarchy.
+     *
+     * @param elementId The element to start the search from
+     * @param guard The typeguard which the element should match
+     * @return The first matching element or `undefined`.
+     */
+    findParentElement<T extends GModelElement>(elementId: string, guard: TypeGuard<T>): T | undefined {
+        const element = this.get(elementId);
+        return element ? this._findElement(element, guard) : undefined;
+    }
+
+    protected _findElement<T>(element: GModelElement, guard: TypeGuard<T>): T | undefined {
+        if (!element) {
+            return undefined;
+        }
+        if (guard(element)) {
+            return element;
+        }
+        if (element instanceof GModelRoot) {
+            return undefined;
+        }
+        return this._findElement(element.parent, guard);
+    }
+}

package/src/common/features/model/gmodel-serializer.spec.ts

@@ -0,0 +1,141 @@
+/********************************************************************************
+ * 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 { GEdge, getDefaultMapping, GGraph, GNode } from '@eclipse-glsp/graph';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import { DiagramConfiguration } from '../../diagram/diagram-configuration';
+import * as mock from '../../test/mock-util';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+import { Logger } from '../../utils/logger';
+import { DefaultGModelSerializer } from './gmodel-serializer';
+
+class TestNode extends GNode {
+    foo(): void {
+        // should not be serialized to schema
+    }
+}
+
+let testRootSchema: any;
+
+let testNodeSchema: any;
+
+let testNodeSchemaWithParent: any;
+
+describe('test DefaultGModelSerializer', () => {
+    const container = new Container();
+    const diagramConfiguration = new mock.StubDiagramConfiguration();
+    diagramConfiguration['typeMapping'] = getDefaultMapping();
+    diagramConfiguration.typeMapping.set('node', TestNode);
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new mock.StubLogger());
+            bind(DiagramConfiguration).toConstantValue(diagramConfiguration);
+        })
+    );
+
+    const serializer = container.resolve(DefaultGModelSerializer);
+
+    beforeEach(() => {
+        testRootSchema = {
+            id: 'graph',
+            type: 'graph',
+            children: [
+                { id: 'node1', type: 'node', position: { x: 5, y: 10 } },
+                { id: 'node2', type: 'node', position: { x: 15, y: 5 } },
+                { id: 'edge1', type: 'edge', sourceId: 'node1', targetId: 'node2' }
+            ]
+        };
+        testNodeSchema = { id: 'node1', type: 'node', position: { x: 5, y: 10 }, children: [], cssClasses: [] };
+        testNodeSchemaWithParent = {
+            id: 'node1',
+            type: 'node',
+            position: { x: 5, y: 10 },
+            children: [],
+            cssClasses: [],
+            parent: new GNode()
+        };
+    });
+
+    it('createElement - unregistered type', () => {
+        testNodeSchema['type'] = 'notRegistered';
+        expect(() => serializer.createElement(testNodeSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createElement - with root schema', () => {
+        expect(() => serializer.createElement(testRootSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createElement - with node schema', () => {
+        const node = serializer.createElement(testNodeSchema);
+        expect(node).to.be.an.instanceOf(TestNode);
+        expect(node).to.be.deep.include(testNodeSchema);
+        expect((node as TestNode).foo).to.not.be.undefined;
+    });
+
+    it('createElement- with sub type of registered schema', () => {
+        testNodeSchema.type = 'node:rectangular';
+        const node = serializer.createElement(testNodeSchema);
+        expect(node).to.be.an.instanceOf(TestNode);
+        expect(node).to.be.deep.include(testNodeSchema);
+        expect((node as TestNode).foo).to.not.be.undefined;
+    });
+
+    it('createElement - with parent', () => {
+        const parent = new GNode();
+        const child = serializer.createElement(testNodeSchema, parent);
+        expect(child).to.be.an.instanceOf(TestNode);
+        expect(child).to.be.deep.include(testNodeSchemaWithParent);
+        expect(child.parent).to.be.equal(parent);
+    });
+
+    it('createRoot - unregistered type', () => {
+        testRootSchema['type'] = 'notRegistered';
+        expect(() => serializer.createRoot(testNodeSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createRoot - with child schema ', () => {
+        expect(() => serializer.createRoot(testNodeSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createRoot - with registered root schema', () => {
+        const root = serializer.createRoot(testRootSchema);
+        expect(root).to.be.an.instanceOf(GGraph);
+        expect(root.children.length).to.be.equal(3);
+        const node1 = root.children[0];
+        expect(node1).to.be.an.instanceOf(TestNode);
+        const node2 = root.children[1];
+        expect(node2).to.be.an.instanceOf(TestNode);
+        expect(root.children[2]).to.be.an.instanceOf(GEdge);
+        const edge = root.children[2] as GEdge;
+        expect(edge.sourceId).to.be.equal(node1.id);
+        expect(edge.targetId).to.be.equal(node2.id);
+    });
+
+    it('createSchema- unregistered type', () => {
+        expect(() => serializer.createRoot({ id: 'id', type: 'unregistered' })).to.throw(GLSPServerError);
+    });
+
+    it('createSchema- with node', () => {
+        const testNode = new TestNode();
+        testNode.position = { x: 5, y: 10 };
+        testNode.size = { width: 10, height: 100 };
+        testNode.layoutOptions = { ['my']: 'Options' };
+        const schema = serializer.createSchema(testNode);
+        delete (testNode as Partial<TestNode>).foo;
+        expect(schema).to.be.deep.include(testNode);
+    });
+});