Improve script/category name validation

- Use better error messages with more context.
- Unify their validation logic and share tests.
- Validate also type of the name.
- Refactor node (Script/Category) parser tests for easier future
  changes and cleaner test code (using `TestBuilder` to do dirty work in
  unified way).
- Add more tests. Custom `Error` properties are compared manually due to
  `chai` not supporting deep equality checks (chaijs/chai#1065,
  chaijs/chai#1405).

tests/unit/application/Parser/NodeValidation/NodeDataError.spec.ts

@@ -0,0 +1,67 @@
+import 'mocha';
+import { expect } from 'chai';
+import { INodeDataErrorContext, NodeDataError } from '@/application/Parser/NodeValidation/NodeDataError';
+import { NodeDataErrorContextStub } from '@tests/unit/shared/Stubs/NodeDataErrorContextStub';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
+
+describe('NodeDataError', () => {
+  it('sets message as expected', () => {
+    // arrange
+    const message = 'message';
+    const context = new NodeDataErrorContextStub();
+    const expected = `[${NodeType[context.type]}] ${message}`;
+    // act
+    const sut = new NodeDataErrorBuilder()
+      .withContext(context)
+      .withMessage(expected)
+      .build();
+    // assert
+    expect(sut.message).to.include(expected);
+  });
+  it('sets context as expected', () => {
+    // arrange
+    const expected = new NodeDataErrorContextStub();
+    // act
+    const sut = new NodeDataErrorBuilder()
+      .withContext(expected)
+      .build();
+    // assert
+    expect(sut.context).to.equal(expected);
+  });
+  it('sets stack as expected', () => {
+    // arrange
+    // act
+    const sut = new NodeDataErrorBuilder()
+      .build();
+    // assert
+    expect(sut.stack !== undefined);
+  });
+  it('extends Error', () => {
+    // arrange
+    const expected = Error;
+    // act
+    const sut = new NodeDataErrorBuilder().build();
+    // assert
+    expect(sut).to.be.an.instanceof(expected);
+  });
+});
+
+class NodeDataErrorBuilder {
+  private message = 'error';
+
+  private context: INodeDataErrorContext = new NodeDataErrorContextStub();
+
+  public withContext(context: INodeDataErrorContext) {
+    this.context = context;
+    return this;
+  }
+
+  public withMessage(message: string) {
+    this.message = message;
+    return this;
+  }
+
+  public build(): NodeDataError {
+    return new NodeDataError(this.message, this.context);
+  }
+}

tests/unit/application/Parser/NodeValidation/NodeValidator.spec.ts

@@ -0,0 +1,100 @@
+import 'mocha';
+import { expect } from 'chai';
+import { NodeDataError } from '@/application/Parser/NodeValidation/NodeDataError';
+import { NodeValidator } from '@/application/Parser/NodeValidation/NodeValidator';
+import { expectThrowsError } from '@tests/unit/shared/Assertions/ExpectThrowsError';
+import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
+import { NodeDataErrorContextStub } from '@tests/unit/shared/Stubs/NodeDataErrorContextStub';
+import { NodeData } from '@/application/Parser/NodeValidation/NodeData';
+import { NodeValidationTestRunner } from './NodeValidatorTestRunner';
+
+describe('NodeValidator', () => {
+  describe('assertValidName', () => {
+    describe('throws if invalid', () => {
+      // arrange
+      const context = new NodeDataErrorContextStub();
+      const sut = new NodeValidator(context);
+      // act
+      const act = (invalidName: string) => sut.assertValidName(invalidName);
+      // assert
+      new NodeValidationTestRunner()
+        .testInvalidNodeName((invalidName) => ({
+          act: () => act(invalidName),
+          expectedContext: context,
+        }));
+    });
+    it('does not throw if valid', () => {
+      // arrange
+      const validName = 'validName';
+      const sut = new NodeValidator(new NodeDataErrorContextStub());
+      // act
+      const act = () => sut.assertValidName(validName);
+      // assert
+      expect(act).to.not.throw();
+    });
+  });
+  describe('assertDefined', () => {
+    describe('throws if missing', () => {
+      // arrange
+      const context = new NodeDataErrorContextStub();
+      const sut = new NodeValidator(context);
+      // act
+      const act = (undefinedNode: NodeData) => sut.assertDefined(undefinedNode);
+      // assert
+      new NodeValidationTestRunner()
+        .testMissingNodeData((invalidName) => ({
+          act: () => act(invalidName),
+          expectedContext: context,
+        }));
+    });
+    it('does not throw if defined', () => {
+      // arrange
+      const definedNode = mockNode();
+      const sut = new NodeValidator(new NodeDataErrorContextStub());
+      // act
+      const act = () => sut.assertDefined(definedNode);
+      // assert
+      expect(act).to.not.throw();
+    });
+  });
+  describe('assert', () => {
+    it('throws expected error if condition is false', () => {
+      // arrange
+      const message = 'error';
+      const falsePredicate = () => false;
+      const context = new NodeDataErrorContextStub();
+      const expected = new NodeDataError(message, context);
+      const sut = new NodeValidator(context);
+      // act
+      const act = () => sut.assert(falsePredicate, message);
+      // assert
+      expectThrowsError(act, expected);
+    });
+    it('does not throw if condition is true', () => {
+      // arrange
+      const truePredicate = () => true;
+      const sut = new NodeValidator(new NodeDataErrorContextStub());
+      // act
+      const act = () => sut.assert(truePredicate, 'ignored error');
+      // assert
+      expect(act).to.not.throw();
+    });
+  });
+  describe('throw', () => {
+    it('throws expected error', () => {
+      // arrange
+      const message = 'error';
+      const context = new NodeDataErrorContextStub();
+      const expected = new NodeDataError(message, context);
+      const sut = new NodeValidator(context);
+      // act
+      const act = () => sut.throw(message);
+      // assert
+      expectThrowsError(act, expected);
+    });
+  });
+});
+
+function mockNode() {
+  return new CategoryDataStub();
+}

tests/unit/application/Parser/NodeValidation/NodeValidatorTestRunner.ts

@@ -0,0 +1,87 @@
+import 'mocha';
+import { NodeDataError, INodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataError';
+import { NodeData } from '@/application/Parser/NodeValidation/NodeData';
+import { AbsentObjectTestCases, AbsentStringTestCases, itEachAbsentTestCase } from '@tests/unit/shared/TestCases/AbsentTests';
+import { expectThrowsError } from '@tests/unit/shared/Assertions/ExpectThrowsError';
+
+export interface ITestScenario {
+  readonly act: () => void;
+  readonly expectedContext: INodeDataErrorContext;
+}
+
+export class NodeValidationTestRunner {
+  public testInvalidNodeName(
+    testBuildPredicate: (invalidName: string) => ITestScenario,
+  ) {
+    describe('throws given invalid names', () => {
+      // arrange
+      const testCases = [
+        ...AbsentStringTestCases.map((testCase) => ({
+          testName: `missing name (${testCase.valueName})`,
+          nameValue: testCase.absentValue,
+          expectedMessage: 'missing name',
+        })),
+        {
+          testName: 'invalid type',
+          nameValue: 33,
+          expectedMessage: 'Name (33) is not a string but number.',
+        },
+      ];
+      for (const testCase of testCases) {
+        it(`given "${testCase.testName}"`, () => {
+          const test = testBuildPredicate(testCase.nameValue as never);
+          expectThrowsNodeError(test, testCase.expectedMessage);
+        });
+      }
+    });
+    return this;
+  }
+
+  public testMissingNodeData(
+    testBuildPredicate: (missingNode: NodeData) => ITestScenario,
+  ) {
+    describe('throws given missing node data', () => {
+      itEachAbsentTestCase([
+        ...AbsentObjectTestCases,
+        {
+          valueName: 'empty object',
+          absentValue: {},
+        },
+      ], (absentValue) => {
+        // arrange
+        const expectedError = 'missing node data';
+        // act
+        const test = testBuildPredicate(absentValue as NodeData);
+        // assert
+        expectThrowsNodeError(test, expectedError);
+      });
+    });
+    return this;
+  }
+
+  public runThrowingCase(
+    testCase: {
+      readonly name: string,
+      readonly scenario: ITestScenario,
+      readonly expectedMessage: string
+    },
+  ) {
+    it(testCase.name, () => {
+      expectThrowsNodeError(testCase.scenario, testCase.expectedMessage);
+    });
+    return this;
+  }
+}
+
+export function expectThrowsNodeError(
+  test: ITestScenario,
+  expectedMessage: string,
+) {
+  // arrange
+  const expected = new NodeDataError(expectedMessage, test.expectedContext);
+  // act
+  const act = () => test.act();
+  // assert
+  expectThrowsError(act, expected);
+  return this;
+}