Merge pull request #384 from jvalue/feature/extension-block-custom-va…

…lidation

Block custom validation tests

libs/extensions/std/lang/src/gtfs-rt-interpreter-meta-inf.spec.ts

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import {
+  createJayveeServices,
+  useExtension,
+} from '@jvalue/jayvee-language-server';
+import {
+  TestLangExtension,
+  ValidationResult,
+  readJvTestAssetHelper,
+  validationHelper,
+} from '@jvalue/jayvee-language-server/test';
+import { AstNode } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+
+import { StdLangExtension } from './extension';
+
+describe('Validation of GtfsRTInterpreterMetaInformation', () => {
+  let validate: (input: string) => Promise<ValidationResult<AstNode>>;
+
+  const readJvTestAsset = readJvTestAssetHelper(__dirname, '../test/assets/');
+
+  beforeAll(() => {
+    // Register std extension
+    useExtension(new StdLangExtension());
+    // Register test extension
+    useExtension(new TestLangExtension());
+    // Create language services
+    const services = createJayveeServices(NodeFileSystem).Jayvee;
+    // Create validation helper for language services
+    validate = validationHelper(services);
+  });
+
+  it('should diagnose no error on valid entity parameter value', async () => {
+    const text = readJvTestAsset(
+      'gtfs-rt-interpreter-meta-inf/valid-valid-entity-param.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(0);
+  });
+
+  it('should diagnose error on invalid entity parameter value', async () => {
+    const text = readJvTestAsset(
+      'gtfs-rt-interpreter-meta-inf/invalid-invalid-entity-param.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Entity must be "trip_update", "alert" or "vehicle"',
+        }),
+      ]),
+    );
+  });
+});

libs/extensions/std/lang/src/text-file-interpreter-meta-inf.spec.ts

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import {
+  createJayveeServices,
+  useExtension,
+} from '@jvalue/jayvee-language-server';
+import {
+  TestLangExtension,
+  ValidationResult,
+  readJvTestAssetHelper,
+  validationHelper,
+} from '@jvalue/jayvee-language-server/test';
+import { AstNode } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+
+import { StdLangExtension } from './extension';
+
+describe('Validation of TextFileInterpreterMetaInformation', () => {
+  let validate: (input: string) => Promise<ValidationResult<AstNode>>;
+
+  const readJvTestAsset = readJvTestAssetHelper(__dirname, '../test/assets/');
+
+  beforeAll(() => {
+    // Register std extension
+    useExtension(new StdLangExtension());
+    // Register test extension
+    useExtension(new TestLangExtension());
+    // Create language services
+    const services = createJayveeServices(NodeFileSystem).Jayvee;
+    // Create validation helper for language services
+    validate = validationHelper(services);
+  });
+
+  it('should diagnose error on invalid encoding parameter value', async () => {
+    const text = readJvTestAsset(
+      'text-file-interpreter-meta-inf/invalid-invalid-encoding-param.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Unknown encoding "invalid"',
+        }),
+      ]),
+    );
+  });
+
+  it('should diagnose no error', async () => {
+    const text = readJvTestAsset(
+      'text-file-interpreter-meta-inf/valid-utf8-encoding.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(0);
+  });
+});

libs/extensions/std/lang/src/text-line-deleter-meta-inf.spec.ts

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import {
+  createJayveeServices,
+  useExtension,
+} from '@jvalue/jayvee-language-server';
+import {
+  TestLangExtension,
+  ValidationResult,
+  readJvTestAssetHelper,
+  validationHelper,
+} from '@jvalue/jayvee-language-server/test';
+import { AstNode } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+
+import { StdLangExtension } from './extension';
+
+describe('Validation of TextLineDeleterMetaInformation', () => {
+  let validate: (input: string) => Promise<ValidationResult<AstNode>>;
+
+  const readJvTestAsset = readJvTestAssetHelper(__dirname, '../test/assets/');
+
+  beforeAll(() => {
+    // Register std extension
+    useExtension(new StdLangExtension());
+    // Register test extension
+    useExtension(new TestLangExtension());
+    // Create language services
+    const services = createJayveeServices(NodeFileSystem).Jayvee;
+    // Create validation helper for language services
+    validate = validationHelper(services);
+  });
+
+  it('should diagnose error on line parameter less or equal to zero', async () => {
+    const text = readJvTestAsset(
+      'text-line-deleter-meta-inf/invalid-line-less-or-equal-zero.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(3);
+    expect(diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Line numbers need to be greater than zero',
+        }),
+      ]),
+    );
+  });
+
+  it('should diagnose no error', async () => {
+    const text = readJvTestAsset(
+      'text-line-deleter-meta-inf/valid-postive-line-number.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(0);
+  });
+});

libs/extensions/std/lang/src/text-range-selector-meta-inf.spec.ts

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import {
+  createJayveeServices,
+  useExtension,
+} from '@jvalue/jayvee-language-server';
+import {
+  TestLangExtension,
+  ValidationResult,
+  readJvTestAssetHelper,
+  validationHelper,
+} from '@jvalue/jayvee-language-server/test';
+import { AstNode } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+
+import { StdLangExtension } from './extension';
+
+describe('Validation of TextRangeSelectorMetaInformation', () => {
+  let validate: (input: string) => Promise<ValidationResult<AstNode>>;
+
+  const readJvTestAsset = readJvTestAssetHelper(__dirname, '../test/assets/');
+
+  beforeAll(() => {
+    // Register std extension
+    useExtension(new StdLangExtension());
+    // Register test extension
+    useExtension(new TestLangExtension());
+    // Create language services
+    const services = createJayveeServices(NodeFileSystem).Jayvee;
+    // Create validation helper for language services
+    validate = validationHelper(services);
+  });
+
+  it('should diagnose error on lineFrom parameter less or equal to zero', async () => {
+    const text = readJvTestAsset(
+      'text-range-selector-meta-inf/invalid-lineFrom-less-or-equal-zero.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Line numbers need to be greater than zero',
+        }),
+      ]),
+    );
+  });
+
+  it('should diagnose error on lineTo parameter less or equal to zero', async () => {
+    const text = readJvTestAsset(
+      'text-range-selector-meta-inf/invalid-lineTo-less-or-equal-zero.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(2);
+    expect(diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Line numbers need to be greater than zero',
+        }),
+      ]),
+    );
+  });
+
+  it('should diagnose error on lineFrom > lineTo', async () => {
+    const text = readJvTestAsset(
+      'text-range-selector-meta-inf/invalid-lineFrom-greater-lineTo.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(2);
+    expect(diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message:
+            'The lower line number needs to be smaller or equal to the upper line number',
+        }),
+      ]),
+    );
+  });
+
+  it('should diagnose no error', async () => {
+    const text = readJvTestAsset(
+      'text-range-selector-meta-inf/valid-correct-range.jv',
+    );
+
+    const validationResult = await validate(text);
+    const diagnostics = validationResult.diagnostics;
+
+    expect(diagnostics).toHaveLength(0);
+  });
+});

libs/extensions/std/lang/test/assets/gtfs-rt-interpreter-meta-inf/invalid-invalid-entity-param.jv

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+pipeline Pipeline {
+  block Test oftype GtfsRTInterpreter {
+    entity: 'invalid';
+  }
+
+  block TestExtractor oftype TestFileExtractor {
+  }
+
+  block TestLoader oftype TestSheetLoader {
+  }
+
+  TestExtractor -> Test -> TestLoader;
+}

libs/extensions/std/lang/test/assets/gtfs-rt-interpreter-meta-inf/valid-valid-entity-param.jv

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+pipeline Pipeline {
+  block Test oftype GtfsRTInterpreter {
+    entity: 'alert';
+  }
+
+  block TestExtractor oftype TestFileExtractor {
+  }
+
+  block TestLoader oftype TestSheetLoader {
+  }
+
+  TestExtractor -> Test -> TestLoader;
+}

libs/extensions/std/lang/test/assets/text-file-interpreter-meta-inf/invalid-invalid-encoding-param.jv

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+pipeline Pipeline {
+  block Test oftype TextFileInterpreter {
+    encoding: 'invalid';
+  }
+
+  block TestExtractor oftype TestFileExtractor {
+  }
+
+  block TestLoader oftype TestTextFileLoader {
+  }
+
+  TestExtractor -> Test -> TestLoader;
+}

libs/extensions/std/lang/test/assets/text-file-interpreter-meta-inf/valid-utf8-encoding.jv

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+pipeline Pipeline {
+  block Test oftype TextFileInterpreter {
+    encoding: 'utf8';
+  }
+
+  block TestExtractor oftype TestFileExtractor {
+  }
+
+  block TestLoader oftype TestTextFileLoader {
+  }
+
+  TestExtractor -> Test -> TestLoader;
+}

libs/extensions/std/lang/test/assets/text-line-deleter-meta-inf/invalid-line-less-or-equal-zero.jv

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+pipeline Pipeline {
+  block Test oftype TextLineDeleter {
+    lines: [2,3,0,-1,-20];
+  }
+
+  block TestExtractor oftype TestTextFileExtractor {
+  }
+
+  block TestLoader oftype TestTextFileLoader {
+  }
+
+  TestExtractor -> Test -> TestLoader;
+}