Validation Tests

libs/language-server/src/lib/validation/checks/column-id.spec.ts

@@ -11,7 +11,6 @@ import {
   createJayveeServices,
   useExtension,
 } from '../../../lib';
-import { validateColumnId } from '../../../lib/validation/checks/column-id';
 import {
   ParseHelperOptions,
   expectNoParserAndLexerErrors,
@@ -21,6 +20,8 @@ import {
 } from '../../../test';
 import { TestLangExtension } from '../../../test/extension';
 
+import { validateColumnId } from './column-id';
+
 describe('column-id validation tests', () => {
   let parse: (
     input: string,

libs/language-server/src/lib/validation/checks/expression-constraint-definition.spec.ts

@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { AstNode, AstNodeLocator, LangiumDocument } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+
+import {
+  EvaluationContext,
+  ExpressionConstraintDefinition,
+  RuntimeParameterProvider,
+  ValidationContext,
+  createJayveeServices,
+  useExtension,
+} from '../../../lib';
+import {
+  ParseHelperOptions,
+  expectNoParserAndLexerErrors,
+  parseHelper,
+  readJvTestAssetHelper,
+  validationAcceptorMockImpl,
+} from '../../../test';
+import { TestLangExtension } from '../../../test/extension';
+
+import { validateExpressionConstraintDefinition } from './expression-constraint-definition';
+
+describe('expression-constraint-definition validation tests', () => {
+  let parse: (
+    input: string,
+    options?: ParseHelperOptions,
+  ) => Promise<LangiumDocument<AstNode>>;
+
+  const validationAcceptorMock = jest.fn(validationAcceptorMockImpl);
+
+  let locator: AstNodeLocator;
+
+  const readJvTestAsset = readJvTestAssetHelper(
+    __dirname,
+    '../../../test/assets/',
+  );
+
+  async function parseAndValidateExpressionConstraintDefinition(input: string) {
+    const document = await parse(input);
+    expectNoParserAndLexerErrors(document);
+
+    const expressionConstraint =
+      locator.getAstNode<ExpressionConstraintDefinition>(
+        document.parseResult.value,
+        'constraints@0',
+      ) as ExpressionConstraintDefinition;
+
+    validateExpressionConstraintDefinition(
+      expressionConstraint,
+      new ValidationContext(validationAcceptorMock),
+      new EvaluationContext(new RuntimeParameterProvider()),
+    );
+  }
+
+  beforeAll(() => {
+    // Register test extension
+    useExtension(new TestLangExtension());
+    // Create language services
+    const services = createJayveeServices(NodeFileSystem).Jayvee;
+    locator = services.workspace.AstNodeLocator;
+    // Parse function for Jayvee (without validation)
+    parse = parseHelper(services);
+  });
+
+  afterEach(() => {
+    // Reset mock
+    validationAcceptorMock.mockReset();
+  });
+
+  it('should have no error on valid expression constraint', async () => {
+    const text = readJvTestAsset(
+      'expression-constraint-definition/valid-text-constraint.jv',
+    );
+
+    await parseAndValidateExpressionConstraintDefinition(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(0);
+  });
+
+  it('error on incompatible type', async () => {
+    const text = readJvTestAsset(
+      'expression-constraint-definition/invalid-incompatible-type.jv',
+    );
+
+    await parseAndValidateExpressionConstraintDefinition(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(1);
+    expect(validationAcceptorMock).toHaveBeenCalledWith(
+      'error',
+      `The value needs to be of type boolean but is of type integer`,
+      expect.any(Object),
+    );
+  });
+
+  it('info on simplifiable expression constraint', async () => {
+    const text = readJvTestAsset(
+      'expression-constraint-definition/valid-simplify-info.jv',
+    );
+
+    await parseAndValidateExpressionConstraintDefinition(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(1);
+    expect(validationAcceptorMock).toHaveBeenCalledWith(
+      'info',
+      `The expression can be simplified to 8`,
+      expect.any(Object),
+    );
+  });
+});

libs/language-server/src/lib/validation/checks/jayvee-model.spec.ts

@@ -0,0 +1,123 @@
+// SPDX-FileCopyrightText: 2023 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { AstNode, LangiumDocument } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+
+import {
+  JayveeModel,
+  ValidationContext,
+  createJayveeServices,
+  useExtension,
+} from '../../../lib';
+import {
+  ParseHelperOptions,
+  expectNoParserAndLexerErrors,
+  parseHelper,
+  readJvTestAssetHelper,
+  validationAcceptorMockImpl,
+} from '../../../test';
+import { TestLangExtension } from '../../../test/extension';
+
+import { validateJayveeModel } from './jayvee-model';
+
+describe('jayvee-model validation tests', () => {
+  let parse: (
+    input: string,
+    options?: ParseHelperOptions,
+  ) => Promise<LangiumDocument<AstNode>>;
+
+  const validationAcceptorMock = jest.fn(validationAcceptorMockImpl);
+
+  const readJvTestAsset = readJvTestAssetHelper(
+    __dirname,
+    '../../../test/assets/',
+  );
+
+  async function parseAndValidateJayveeModel(input: string) {
+    const document = await parse(input);
+    expectNoParserAndLexerErrors(document);
+
+    const jayveeModel = document.parseResult.value as JayveeModel;
+
+    validateJayveeModel(
+      jayveeModel,
+      new ValidationContext(validationAcceptorMock),
+    );
+  }
+
+  beforeAll(() => {
+    // Register test extension
+    useExtension(new TestLangExtension());
+    // Create language services
+    const services = createJayveeServices(NodeFileSystem).Jayvee;
+    // Parse function for Jayvee (without validation)
+    parse = parseHelper(services);
+  });
+
+  afterEach(() => {
+    // Reset mock
+    validationAcceptorMock.mockReset();
+  });
+
+  it('error on non unique pipelines', async () => {
+    const text = readJvTestAsset(
+      'jayvee-model/invalid-non-unique-pipelines.jv',
+    );
+
+    await parseAndValidateJayveeModel(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(2);
+    expect(validationAcceptorMock).toHaveBeenCalledWith(
+      'error',
+      `The pipelinedefinition name "Pipeline" needs to be unique.`,
+      expect.any(Object),
+    );
+  });
+
+  it('error on non unique transforms', async () => {
+    const text = readJvTestAsset(
+      'jayvee-model/invalid-non-unique-transforms.jv',
+    );
+
+    await parseAndValidateJayveeModel(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(2);
+    expect(validationAcceptorMock).toHaveBeenCalledWith(
+      'error',
+      `The transformdefinition name "Transform" needs to be unique.`,
+      expect.any(Object),
+    );
+  });
+
+  it('error on non unique valuetypes', async () => {
+    const text = readJvTestAsset(
+      'jayvee-model/invalid-non-unique-valuetypes.jv',
+    );
+
+    await parseAndValidateJayveeModel(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(2);
+    expect(validationAcceptorMock).toHaveBeenCalledWith(
+      'error',
+      `The valuetypedefinition name "ValueType" needs to be unique.`,
+      expect.any(Object),
+    );
+  });
+
+  it('error on non unique constraints', async () => {
+    const text = readJvTestAsset(
+      'jayvee-model/invalid-non-unique-constraints.jv',
+    );
+
+    await parseAndValidateJayveeModel(text);
+
+    expect(validationAcceptorMock).toHaveBeenCalledTimes(2);
+    expect(validationAcceptorMock).toHaveBeenCalledWith(
+      'error',
+      `The expressionconstraintdefinition name "Constraint" needs to be unique.`,
+      expect.any(Object),
+    );
+  });
+});

libs/language-server/src/lib/validation/checks/pipe-definition.spec.ts

@@ -11,7 +11,6 @@ import {
   createJayveeServices,
   useExtension,
 } from '../../../lib';
-import { validatePipeDefinition } from '../../../lib/validation/checks/pipe-definition';
 import {
   ParseHelperOptions,
   expectNoParserAndLexerErrors,
@@ -21,6 +20,8 @@ import {
 } from '../../../test';
 import { TestLangExtension } from '../../../test/extension';
 
+import { validatePipeDefinition } from './pipe-definition';
+
 describe('pipe-definition validation tests', () => {
   let parse: (
     input: string,

libs/language-server/src/lib/validation/checks/pipeline-definition.spec.ts

@@ -11,7 +11,6 @@ import {
   createJayveeServices,
   useExtension,
 } from '../../../lib';
-import { validatePipelineDefinition } from '../../../lib/validation/checks/pipeline-definition';
 import {
   ParseHelperOptions,
   expectNoParserAndLexerErrors,
@@ -21,6 +20,8 @@ import {
 } from '../../../test';
 import { TestLangExtension } from '../../../test/extension';
 
+import { validatePipelineDefinition } from './pipeline-definition';
+
 describe('pipeline-definition validation tests', () => {
   let parse: (
     input: string,