@theia/task 1.53.0-next.4 → 1.53.0-next.55

package/src/browser/task-definition-registry.spec.ts

@@ -1,203 +1,203 @@
-// *****************************************************************************
-// Copyright (C) 2019 Ericsson 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-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { expect } from 'chai';
-import { PanelKind, RevealKind, TaskScope, TaskDefinition } from '../common';
-import { TaskDefinitionRegistry } from './task-definition-registry';
-
-describe('TaskDefinitionRegistry', () => {
-    let registry: TaskDefinitionRegistry;
-    const definitionContributionA: TaskDefinition = {
-        taskType: 'extA',
-        source: 'extA',
-        properties: {
-            required: ['extensionType'],
-            all: ['extensionType', 'taskLabel'],
-            schema: {
-                type: 'object',
-                required: ['extensionType'],
-                properties: {
-                    type: { const: 'extA' },
-                    extensionType: {},
-                    taskLabel: {}
-                }
-            }
-        }
-    };
-    const definitionContributionB: TaskDefinition = {
-        taskType: 'extA',
-        source: 'extA',
-        properties: {
-            required: ['extensionType', 'taskLabel', 'taskDetailedLabel'],
-            all: ['extensionType', 'taskLabel', 'taskDetailedLabel'],
-            schema: {
-                type: 'object',
-                required: ['extensionType', 'taskLabel', 'taskDetailedLabel'],
-                properties: {
-                    type: { const: 'extA' },
-                    extensionType: {},
-                    taskLabel: {},
-                    taskDetailedLabel: {}
-                }
-            }
-        }
-    };
-    const FAKE_TASK_META = {
-        TYPE: 'foobar_type',
-        SRC: 'foobar_src'
-    };
-    const defaultPresentation = {
-        clear: false,
-        echo: true,
-        focus: false,
-        panel: PanelKind.Shared,
-        reveal: RevealKind.Always,
-        showReuseMessage: true,
-    };
-    const fakeTaskDefinition: TaskDefinition = {
-        taskType: FAKE_TASK_META.TYPE,
-        source: FAKE_TASK_META.SRC,
-        properties: {
-            required: ['strArg'],
-            all: ['strArg', 'arrArgs'],
-            schema: {
-                type: 'object',
-                required: ['strArg'],
-                properties: {
-                    type: { const: FAKE_TASK_META.TYPE },
-                    strArg: {},
-                    arrArgs: {}
-                }
-            }
-        }
-    };
-    const configureFakeTask = (
-        executionId = 'foobar',
-        type = FAKE_TASK_META.TYPE,
-        _source = FAKE_TASK_META.SRC,
-        arrArgs: unknown[] = [],
-        strArg = '',
-        label = 'foobar',
-        presentation = defaultPresentation,
-        problemMatcher = undefined,
-        taskType = 'customExecution',
-        _scope = TaskScope.Workspace,
-    ) => ({
-        executionId, arrArgs, strArg, label, presentation,
-        problemMatcher, taskType, type, _scope, _source,
-    });
-
-    beforeEach(() => {
-        registry = new TaskDefinitionRegistry();
-    });
-
-    describe('register function', () => {
-        it('should transform the task definition contribution and store it in memory', () => {
-            registry.register(definitionContributionA);
-            expect(registry['definitions'].get(definitionContributionA.taskType)).to.be.ok;
-            expect(registry['definitions'].get(definitionContributionA.taskType)![0]).to.deep.equal(definitionContributionA);
-        });
-    });
-
-    describe('getDefinitions function', () => {
-        it('should return all definitions associated with the given type', () => {
-            registry.register(definitionContributionA);
-            const defs1 = registry.getDefinitions(definitionContributionA.taskType);
-            expect(defs1.length).to.eq(1);
-
-            registry.register(definitionContributionB);
-            const defs2 = registry.getDefinitions(definitionContributionA.taskType);
-            expect(defs2.length).to.eq(2);
-        });
-    });
-
-    describe('getDefinition function', () => {
-        it('should return undefined if the given task configuration does not match any registered definitions', () => {
-            registry.register(definitionContributionA);
-            registry.register(definitionContributionB);
-            const defs = registry.getDefinition({
-                type: definitionContributionA.taskType, label: 'grunt task', task: 'build'
-            });
-            expect(defs).to.be.not.ok;
-        });
-
-        it('should return the best match if there is one or more registered definitions match the given task configuration', () => {
-            registry.register(definitionContributionA);
-            registry.register(definitionContributionB);
-            const defs = registry.getDefinition({
-                type: definitionContributionA.taskType, label: 'extension task', extensionType: 'extensionType', taskLabel: 'taskLabel'
-            });
-            expect(defs).to.be.ok;
-            expect(defs!.taskType).to.be.eq(definitionContributionA.taskType);
-
-            const defs2 = registry.getDefinition({
-                type: definitionContributionA.taskType, label: 'extension task', extensionType: 'extensionType', taskLabel: 'taskLabel', taskDetailedLabel: 'taskDetailedLabel'
-            });
-            expect(defs2).to.be.ok;
-            expect(defs2!.taskType).to.be.eq(definitionContributionB.taskType);
-        });
-    });
-
-    describe('compareTasks function', () => {
-
-        beforeEach(() => registry.register(fakeTaskDefinition));
-
-        it('should return false if given 2 task configurations with different type', () => {
-            const areSameTasks = registry.compareTasks(
-                configureFakeTask('id_1', 'type_1'),
-                configureFakeTask('id_2', 'type_2'),
-            );
-            expect(areSameTasks).to.be.false;
-        });
-
-        it('should return true if given 2 same task configurations with empty arrays (different by reference) as custom property', () => {
-            const areSameTasks = registry.compareTasks(
-                configureFakeTask('id_1'),
-                configureFakeTask('id_2'),
-            );
-            expect(areSameTasks).to.be.true;
-        });
-
-        it('should return true if given 2 same task configurations with deep properties (different by reference)', () => {
-            const areSameTasks = registry.compareTasks(
-                configureFakeTask('id_1', undefined, undefined, [1, '2', { '3': { a: true, b: 'string' } }]),
-                configureFakeTask('id_2', undefined, undefined, [1, '2', { '3': { a: true, b: 'string' } }]),
-            );
-            expect(areSameTasks).to.be.true;
-        });
-
-        it('should return false if given 2 task configurations with different deep properties', () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const inputs: [any, any][] = [
-                [
-                    configureFakeTask('id_1', undefined, undefined, [1, '2', { '3': { a: true, b: 'b' } }]),
-                    configureFakeTask('id_2', undefined, undefined, [1, '2', { '3': { a: true } }]),
-                ],
-                [
-                    configureFakeTask('id_1', undefined, undefined, [1, '2']),
-                    configureFakeTask('id_2', undefined, undefined, [1, 2]),
-                ],
-                [
-                    // eslint-disable-next-line no-null/no-null
-                    configureFakeTask('id_1', undefined, undefined, [1, '2', { c: null }]),
-                    configureFakeTask('id_2', undefined, undefined, [1, '2', { c: undefined }]),
-                ],
-            ];
-            const allAreFalse = inputs.map(args => registry.compareTasks(...args)).every(areSameTasks => areSameTasks === false);
-            expect(allAreFalse).to.be.true;
-        });
-    });
-});
+// *****************************************************************************
+// Copyright (C) 2019 Ericsson 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { PanelKind, RevealKind, TaskScope, TaskDefinition } from '../common';
+import { TaskDefinitionRegistry } from './task-definition-registry';
+
+describe('TaskDefinitionRegistry', () => {
+    let registry: TaskDefinitionRegistry;
+    const definitionContributionA: TaskDefinition = {
+        taskType: 'extA',
+        source: 'extA',
+        properties: {
+            required: ['extensionType'],
+            all: ['extensionType', 'taskLabel'],
+            schema: {
+                type: 'object',
+                required: ['extensionType'],
+                properties: {
+                    type: { const: 'extA' },
+                    extensionType: {},
+                    taskLabel: {}
+                }
+            }
+        }
+    };
+    const definitionContributionB: TaskDefinition = {
+        taskType: 'extA',
+        source: 'extA',
+        properties: {
+            required: ['extensionType', 'taskLabel', 'taskDetailedLabel'],
+            all: ['extensionType', 'taskLabel', 'taskDetailedLabel'],
+            schema: {
+                type: 'object',
+                required: ['extensionType', 'taskLabel', 'taskDetailedLabel'],
+                properties: {
+                    type: { const: 'extA' },
+                    extensionType: {},
+                    taskLabel: {},
+                    taskDetailedLabel: {}
+                }
+            }
+        }
+    };
+    const FAKE_TASK_META = {
+        TYPE: 'foobar_type',
+        SRC: 'foobar_src'
+    };
+    const defaultPresentation = {
+        clear: false,
+        echo: true,
+        focus: false,
+        panel: PanelKind.Shared,
+        reveal: RevealKind.Always,
+        showReuseMessage: true,
+    };
+    const fakeTaskDefinition: TaskDefinition = {
+        taskType: FAKE_TASK_META.TYPE,
+        source: FAKE_TASK_META.SRC,
+        properties: {
+            required: ['strArg'],
+            all: ['strArg', 'arrArgs'],
+            schema: {
+                type: 'object',
+                required: ['strArg'],
+                properties: {
+                    type: { const: FAKE_TASK_META.TYPE },
+                    strArg: {},
+                    arrArgs: {}
+                }
+            }
+        }
+    };
+    const configureFakeTask = (
+        executionId = 'foobar',
+        type = FAKE_TASK_META.TYPE,
+        _source = FAKE_TASK_META.SRC,
+        arrArgs: unknown[] = [],
+        strArg = '',
+        label = 'foobar',
+        presentation = defaultPresentation,
+        problemMatcher = undefined,
+        taskType = 'customExecution',
+        _scope = TaskScope.Workspace,
+    ) => ({
+        executionId, arrArgs, strArg, label, presentation,
+        problemMatcher, taskType, type, _scope, _source,
+    });
+
+    beforeEach(() => {
+        registry = new TaskDefinitionRegistry();
+    });
+
+    describe('register function', () => {
+        it('should transform the task definition contribution and store it in memory', () => {
+            registry.register(definitionContributionA);
+            expect(registry['definitions'].get(definitionContributionA.taskType)).to.be.ok;
+            expect(registry['definitions'].get(definitionContributionA.taskType)![0]).to.deep.equal(definitionContributionA);
+        });
+    });
+
+    describe('getDefinitions function', () => {
+        it('should return all definitions associated with the given type', () => {
+            registry.register(definitionContributionA);
+            const defs1 = registry.getDefinitions(definitionContributionA.taskType);
+            expect(defs1.length).to.eq(1);
+
+            registry.register(definitionContributionB);
+            const defs2 = registry.getDefinitions(definitionContributionA.taskType);
+            expect(defs2.length).to.eq(2);
+        });
+    });
+
+    describe('getDefinition function', () => {
+        it('should return undefined if the given task configuration does not match any registered definitions', () => {
+            registry.register(definitionContributionA);
+            registry.register(definitionContributionB);
+            const defs = registry.getDefinition({
+                type: definitionContributionA.taskType, label: 'grunt task', task: 'build'
+            });
+            expect(defs).to.be.not.ok;
+        });
+
+        it('should return the best match if there is one or more registered definitions match the given task configuration', () => {
+            registry.register(definitionContributionA);
+            registry.register(definitionContributionB);
+            const defs = registry.getDefinition({
+                type: definitionContributionA.taskType, label: 'extension task', extensionType: 'extensionType', taskLabel: 'taskLabel'
+            });
+            expect(defs).to.be.ok;
+            expect(defs!.taskType).to.be.eq(definitionContributionA.taskType);
+
+            const defs2 = registry.getDefinition({
+                type: definitionContributionA.taskType, label: 'extension task', extensionType: 'extensionType', taskLabel: 'taskLabel', taskDetailedLabel: 'taskDetailedLabel'
+            });
+            expect(defs2).to.be.ok;
+            expect(defs2!.taskType).to.be.eq(definitionContributionB.taskType);
+        });
+    });
+
+    describe('compareTasks function', () => {
+
+        beforeEach(() => registry.register(fakeTaskDefinition));
+
+        it('should return false if given 2 task configurations with different type', () => {
+            const areSameTasks = registry.compareTasks(
+                configureFakeTask('id_1', 'type_1'),
+                configureFakeTask('id_2', 'type_2'),
+            );
+            expect(areSameTasks).to.be.false;
+        });
+
+        it('should return true if given 2 same task configurations with empty arrays (different by reference) as custom property', () => {
+            const areSameTasks = registry.compareTasks(
+                configureFakeTask('id_1'),
+                configureFakeTask('id_2'),
+            );
+            expect(areSameTasks).to.be.true;
+        });
+
+        it('should return true if given 2 same task configurations with deep properties (different by reference)', () => {
+            const areSameTasks = registry.compareTasks(
+                configureFakeTask('id_1', undefined, undefined, [1, '2', { '3': { a: true, b: 'string' } }]),
+                configureFakeTask('id_2', undefined, undefined, [1, '2', { '3': { a: true, b: 'string' } }]),
+            );
+            expect(areSameTasks).to.be.true;
+        });
+
+        it('should return false if given 2 task configurations with different deep properties', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const inputs: [any, any][] = [
+                [
+                    configureFakeTask('id_1', undefined, undefined, [1, '2', { '3': { a: true, b: 'b' } }]),
+                    configureFakeTask('id_2', undefined, undefined, [1, '2', { '3': { a: true } }]),
+                ],
+                [
+                    configureFakeTask('id_1', undefined, undefined, [1, '2']),
+                    configureFakeTask('id_2', undefined, undefined, [1, 2]),
+                ],
+                [
+                    // eslint-disable-next-line no-null/no-null
+                    configureFakeTask('id_1', undefined, undefined, [1, '2', { c: null }]),
+                    configureFakeTask('id_2', undefined, undefined, [1, '2', { c: undefined }]),
+                ],
+            ];
+            const allAreFalse = inputs.map(args => registry.compareTasks(...args)).every(areSameTasks => areSameTasks === false);
+            expect(allAreFalse).to.be.true;
+        });
+    });
+});