44r0n7/privacy.sexy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add object property validation in parser #369

Browse Source 
This commit introduces stricter type validation across the application
to reject objects with unexpected properties, enhancing the robustness
and predictability of data handling.

Changes include:

- Implement a common utility to validate object types.
- Refactor across various parsers and data handlers to utilize the new
  validations.
- Update error messages for better clarity and troubleshooting.
This commit is contained in:
undergroundwires
2024-06-13 22:26:57 +02:00
parent c138f74460
commit 6ecfa9b954
43 changed files with 1215 additions and 466 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
tests/unit/application/Parser/ApplicationParser.spec.ts
View File

@@ -1,20 +1,20 @@
import { describe, it, expect } from 'vitest';
import type { CollectionData } from '@/application/collections/';
import { parseProjectDetails } from '@/application/Parser/ProjectDetailsParser';
import { type CategoryCollectionParserType, parseApplication } from '@/application/Parser/ApplicationParser';
import type { IAppMetadata } from '@/infrastructure/EnvironmentVariables/IAppMetadata';
import { parseApplication } from '@/application/Parser/ApplicationParser';
import WindowsData from '@/application/collections/windows.yaml';
import MacOsData from '@/application/collections/macos.yaml';
import LinuxData from '@/application/collections/linux.yaml';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
import { CollectionDataStub } from '@tests/unit/shared/Stubs/CollectionDataStub';
import { getAbsentCollectionTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
import { AppMetadataStub } from '@tests/unit/shared/Stubs/AppMetadataStub';
import { EnvironmentVariablesFactory } from '@/infrastructure/EnvironmentVariables/EnvironmentVariablesFactory';
import { CategoryCollectionParserStub } from '@tests/unit/shared/Stubs/CategoryCollectionParserStub';
import { ProjectDetailsParserStub } from '@tests/unit/shared/Stubs/ProjectDetailsParserStub';
import { ProjectDetailsStub } from '@tests/unit/shared/Stubs/ProjectDetailsStub';
import type { CategoryCollectionParser } from '@/application/Parser/CategoryCollectionParser';
import type { NonEmptyCollectionAssertion, TypeValidator } from '@/application/Parser/Common/TypeValidator';
import { TypeValidatorStub } from '@tests/unit/shared/Stubs/TypeValidatorStub';
import type { ICategoryCollection } from '@/domain/ICategoryCollection';
describe('ApplicationParser', () => {
describe('parseApplication', () => {
@@ -71,45 +71,21 @@ describe('ApplicationParser', () => {
)).to.equal(true);
});
});
describe('metadata', () => {
it('used to parse expected metadata', () => {
// arrange
const expectedMetadata = new AppMetadataStub();
const projectDetailsParser = new ProjectDetailsParserStub();
// act
new ApplicationParserBuilder()
.withMetadata(expectedMetadata)
.withProjectDetailsParser(projectDetailsParser.getStub())
.parseApplication();
// assert
expect(projectDetailsParser.arguments).to.have.lengthOf(1);
expect(projectDetailsParser.arguments[0]).to.equal(expectedMetadata);
});
it('defaults to metadata from factory', () => {
// arrange
const expectedMetadata: IAppMetadata = EnvironmentVariablesFactory.Current.instance;
const projectDetailsParser = new ProjectDetailsParserStub();
// act
new ApplicationParserBuilder()
.withMetadata(undefined) // force using default
.withProjectDetailsParser(projectDetailsParser.getStub())
.parseApplication();
// assert
expect(projectDetailsParser.arguments).to.have.lengthOf(1);
expect(projectDetailsParser.arguments[0]).to.equal(expectedMetadata);
});
});
describe('collectionsData', () => {
describe('set as expected', () => {
// arrange
const testCases = [
const testScenarios: {
readonly description: string;
readonly input: readonly CollectionData[];
readonly output: readonly ICategoryCollection[];
}[] = [
{
name: 'single collection',
description: 'single collection',
input: [new CollectionDataStub()],
output: [new CategoryCollectionStub().withOs(OperatingSystem.macOS)],
},
{
name: 'multiple collections',
description: 'multiple collections',
input: [
new CollectionDataStub().withOs('windows'),
new CollectionDataStub().withOs('macos'),
@@ -121,22 +97,24 @@ describe('ApplicationParser', () => {
},
];
// act
for (const testCase of testCases) {
it(testCase.name, () => {
testScenarios.forEach(({
description, input, output,
}) => {
it(description, () => {
let categoryParserStub = new CategoryCollectionParserStub();
for (let i = 0; i < testCase.input.length; i++) {
for (let i = 0; i < input.length; i++) {
categoryParserStub = categoryParserStub
.withReturnValue(testCase.input[i], testCase.output[i]);
.withReturnValue(input[i], output[i]);
}
const sut = new ApplicationParserBuilder()
.withCategoryCollectionParser(categoryParserStub.getStub())
.withCollectionsData(testCase.input);
.withCollectionsData(input);
// act
const app = sut.parseApplication();
// assert
expect(app.collections).to.deep.equal(testCase.output);
expect(app.collections).to.deep.equal(output);
});
}
});
});
it('defaults to expected data', () => {
// arrange
@@ -151,30 +129,21 @@ describe('ApplicationParser', () => {
const actual = categoryParserStub.arguments.map((args) => args.data);
expect(actual).to.deep.equal(expected);
});
describe('throws when data is invalid', () => {
it('validates non empty array', () => {
// arrange
const testCases = [
...getAbsentCollectionTestCases<CollectionData>(
{
excludeUndefined: true,
excludeNull: true,
},
).map((testCase) => ({
name: `given absent collection "${testCase.valueName}"`,
value: testCase.absentValue,
expectedError: 'missing collections',
})),
];
for (const testCase of testCases) {
it(testCase.name, () => {
const sut = new ApplicationParserBuilder()
.withCollectionsData(testCase.value);
// act
const act = () => sut.parseApplication();
// assert
expect(act).to.throw(testCase.expectedError);
});
}
const data = [new CollectionDataStub()];
const expectedAssertion: NonEmptyCollectionAssertion = {
value: data,
valueName: 'collections',
};
const validator = new TypeValidatorStub();
const sut = new ApplicationParserBuilder()
.withCollectionsData(data)
.withTypeValidator(validator);
// act
sut.parseApplication();
// assert
validator.expectNonEmptyCollectionAssertion(expectedAssertion);
});
});
});
@@ -182,17 +151,17 @@ describe('ApplicationParser', () => {
class ApplicationParserBuilder {
private categoryCollectionParser
: CategoryCollectionParserType = new CategoryCollectionParserStub().getStub();
: CategoryCollectionParser = new CategoryCollectionParserStub().getStub();
private projectDetailsParser
: typeof parseProjectDetails = new ProjectDetailsParserStub().getStub();
private metadata: IAppMetadata | undefined = new AppMetadataStub();
private validator: TypeValidator = new TypeValidatorStub();
private collectionsData: CollectionData[] | undefined = [new CollectionDataStub()];
private collectionsData: readonly CollectionData[] | undefined = [new CollectionDataStub()];
public withCategoryCollectionParser(
categoryCollectionParser: CategoryCollectionParserType,
categoryCollectionParser: CategoryCollectionParser,
): this {
this.categoryCollectionParser = categoryCollectionParser;
return this;
@@ -205,24 +174,24 @@ class ApplicationParserBuilder {
return this;
}
public withMetadata(
metadata: IAppMetadata | undefined,
): this {
this.metadata = metadata;
public withCollectionsData(collectionsData: readonly CollectionData[] | undefined): this {
this.collectionsData = collectionsData;
return this;
}
public withCollectionsData(collectionsData: CollectionData[] | undefined): this {
this.collectionsData = collectionsData;
public withTypeValidator(validator: TypeValidator): this {
this.validator = validator;
return this;
}
public parseApplication(): ReturnType<typeof parseApplication> {
return parseApplication(
this.categoryCollectionParser,
this.projectDetailsParser,
this.metadata,
this.collectionsData,
{
parseCategoryCollection: this.categoryCollectionParser,
parseProjectDetails: this.projectDetailsParser,
validator: this.validator,
},
);
}
}

356
tests/unit/application/Parser/CategoryCollectionParser.spec.ts
View File

@@ -1,119 +1,313 @@
import { describe, it, expect } from 'vitest';
import type { IEntity } from '@/infrastructure/Entity/IEntity';
import { parseCategoryCollection } from '@/application/Parser/CategoryCollectionParser';
import { parseCategory } from '@/application/Parser/Executable/CategoryParser';
import { TypeValidatorStub } from '@tests/unit/shared/Stubs/TypeValidatorStub';
import { parseCategoryCollection, type CategoryCollectionFactory } from '@/application/Parser/CategoryCollectionParser';
import { type CategoryParser } from '@/application/Parser/Executable/CategoryParser';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
import { ScriptingDefinitionParser } from '@/application/Parser/ScriptingDefinition/ScriptingDefinitionParser';
import { EnumParserStub } from '@tests/unit/shared/Stubs/EnumParserStub';
import { ProjectDetailsStub } from '@tests/unit/shared/Stubs/ProjectDetailsStub';
import { getCategoryStub, CollectionDataStub } from '@tests/unit/shared/Stubs/CollectionDataStub';
import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
import { createFunctionDataWithCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
import { FunctionCallDataStub } from '@tests/unit/shared/Stubs/FunctionCallDataStub';
import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
import type { CategoryData } from '@/application/collections/';
import type { CollectionData, ScriptingDefinitionData, FunctionData } from '@/application/collections/';
import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
import type { NonEmptyCollectionAssertion, ObjectAssertion, TypeValidator } from '@/application/Parser/Common/TypeValidator';
import type { EnumParser } from '@/application/Common/Enum';
import type { ScriptingDefinitionParser } from '@/application/Parser/ScriptingDefinition/ScriptingDefinitionParser';
import { ScriptingDefinitionStub } from '@tests/unit/shared/Stubs/ScriptingDefinitionStub';
import type { CategoryCollectionSpecificUtilitiesFactory } from '@/application/Parser/Executable/CategoryCollectionSpecificUtilities';
import { ScriptingDefinitionDataStub } from '@tests/unit/shared/Stubs/ScriptingDefinitionDataStub';
import { CategoryParserStub } from '@tests/unit/shared/Stubs/CategoryParserStub';
import { createCategoryCollectionFactorySpy } from '@tests/unit/shared/Stubs/CategoryCollectionFactoryStub';
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
describe('CategoryCollectionParser', () => {
describe('parseCategoryCollection', () => {
it('validates object', () => {
// arrange
const data = new CollectionDataStub();
const expectedAssertion: ObjectAssertion<CollectionData> = {
value: data,
valueName: 'collection',
allowedProperties: [
'os', 'scripting', 'actions', 'functions',
],
};
const validator = new TypeValidatorStub();
const context = new TestContext()
.withData(data)
.withTypeValidator(validator);
// act
context.parseCategoryCollection();
// assert
validator.expectObjectAssertion(expectedAssertion);
});
describe('actions', () => {
describe('throws with absent actions', () => {
itEachAbsentCollectionValue<CategoryData>((absentValue) => {
// arrange
const expectedError = 'content does not define any action';
const collection = new CollectionDataStub()
.withActions(absentValue);
const projectDetails = new ProjectDetailsStub();
// act
const act = () => parseCategoryCollection(collection, projectDetails);
// assert
expect(act).to.throw(expectedError);
}, { excludeUndefined: true, excludeNull: true });
});
it('parses actions', () => {
it('validates non-empty collection', () => {
// arrange
const actions = [getCategoryStub('test1'), getCategoryStub('test2')];
const context = new CategoryCollectionSpecificUtilitiesStub();
const expected = [parseCategory(actions[0], context), parseCategory(actions[1], context)];
const collection = new CollectionDataStub()
.withActions(actions);
const projectDetails = new ProjectDetailsStub();
const expectedAssertion: NonEmptyCollectionAssertion = {
value: actions,
valueName: '"actions" in collection',
};
const validator = new TypeValidatorStub();
const context = new TestContext()
.withData(new CollectionDataStub().withActions(actions))
.withTypeValidator(validator);
// act
const actual = parseCategoryCollection(collection, projectDetails).actions;
context.parseCategoryCollection();
// assert
expect(excludingId(actual)).to.be.deep.equal(excludingId(expected));
function excludingId<TId>(array: ReadonlyArray<IEntity<TId>>) {
return array.map((obj) => {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const { id: omitted, ...rest } = obj;
return rest;
validator.expectNonEmptyCollectionAssertion(expectedAssertion);
});
it('parses actions correctly', () => {
// arrange
const {
categoryCollectionFactorySpy,
getInitParameters,
} = createCategoryCollectionFactorySpy();
const actionsData = [getCategoryStub('test1'), getCategoryStub('test2')];
const expectedActions = [new CategoryStub(1), new CategoryStub(2)];
const categoryParserStub = new CategoryParserStub()
.withConfiguredParseResult(actionsData[0], expectedActions[0])
.withConfiguredParseResult(actionsData[1], expectedActions[1]);
const collectionData = new CollectionDataStub()
.withActions(actionsData);
const context = new TestContext()
.withData(collectionData)
.withCategoryParser(categoryParserStub.get())
.withCategoryCollectionFactory(categoryCollectionFactorySpy);
// act
const actualCollection = context.parseCategoryCollection();
// assert
const actualActions = getInitParameters(actualCollection)?.actions;
expect(actualActions).to.have.lengthOf(expectedActions.length);
expect(actualActions).to.have.members(expectedActions);
});
describe('utilities', () => {
it('parses actions with correct utilities', () => {
// arrange
const expectedUtilities = new CategoryCollectionSpecificUtilitiesStub();
const utilitiesFactory: CategoryCollectionSpecificUtilitiesFactory = () => {
return expectedUtilities;
};
const actionsData = [getCategoryStub('test1'), getCategoryStub('test2')];
const collectionData = new CollectionDataStub()
.withActions(actionsData);
const categoryParserStub = new CategoryParserStub();
const context = new TestContext()
.withData(collectionData)
.withCollectionUtilitiesFactory(utilitiesFactory)
.withCategoryParser(categoryParserStub.get());
// act
context.parseCategoryCollection();
// assert
const usedUtilities = categoryParserStub.getUsedUtilities();
expect(usedUtilities).to.have.lengthOf(2);
expect(usedUtilities[0]).to.equal(expectedUtilities);
expect(usedUtilities[1]).to.equal(expectedUtilities);
});
describe('construction', () => {
it('creates utilities with correct functions data', () => {
// arrange
const expectedFunctionsData = [createFunctionDataWithCode()];
const collectionData = new CollectionDataStub()
.withFunctions(expectedFunctionsData);
let actualFunctionsData: ReadonlyArray<FunctionData> | undefined;
const utilitiesFactory: CategoryCollectionSpecificUtilitiesFactory = (data) => {
actualFunctionsData = data;
return new CategoryCollectionSpecificUtilitiesStub();
};
const context = new TestContext()
.withData(collectionData)
.withCollectionUtilitiesFactory(utilitiesFactory);
// act
context.parseCategoryCollection();
// assert
expect(actualFunctionsData).to.equal(expectedFunctionsData);
});
}
it('creates utilities with correct scripting definition', () => {
// arrange
const expectedScripting = new ScriptingDefinitionStub();
const scriptingDefinitionParser: ScriptingDefinitionParser = () => {
return expectedScripting;
};
let actualScripting: IScriptingDefinition | undefined;
const utilitiesFactory: CategoryCollectionSpecificUtilitiesFactory = (_, scripting) => {
actualScripting = scripting;
return new CategoryCollectionSpecificUtilitiesStub();
};
const context = new TestContext()
.withCollectionUtilitiesFactory(utilitiesFactory)
.withScriptDefinitionParser(scriptingDefinitionParser);
// act
context.parseCategoryCollection();
// assert
expect(actualScripting).to.equal(expectedScripting);
});
});
});
});
describe('scripting definition', () => {
it('parses scripting definition as expected', () => {
it('parses correctly', () => {
// arrange
const collection = new CollectionDataStub();
const projectDetails = new ProjectDetailsStub();
const expected = new ScriptingDefinitionParser()
.parse(collection.scripting, projectDetails);
const {
categoryCollectionFactorySpy,
getInitParameters,
} = createCategoryCollectionFactorySpy();
const expected = new ScriptingDefinitionStub();
const scriptingDefinitionParser: ScriptingDefinitionParser = () => {
return expected;
};
const context = new TestContext()
.withCategoryCollectionFactory(categoryCollectionFactorySpy)
.withScriptDefinitionParser(scriptingDefinitionParser);
// act
const actual = parseCategoryCollection(collection, projectDetails).scripting;
const actualCategoryCollection = context.parseCategoryCollection();
// assert
expect(expected).to.deep.equal(actual);
const actualScripting = getInitParameters(actualCategoryCollection)?.scripting;
expect(expected).to.equal(actualScripting);
});
it('parses expected data', () => {
// arrange
const expectedData = new ScriptingDefinitionDataStub();
const collection = new CollectionDataStub()
.withScripting(expectedData);
let actualData: ScriptingDefinitionData | undefined;
const scriptingDefinitionParser
: ScriptingDefinitionParser = (data: ScriptingDefinitionData) => {
actualData = data;
return new ScriptingDefinitionStub();
};
const context = new TestContext()
.withScriptDefinitionParser(scriptingDefinitionParser)
.withData(collection);
// act
context.parseCategoryCollection();
// assert
expect(actualData).to.equal(expectedData);
});
it('parses with correct project details', () => {
// arrange
const expectedProjectDetails = new ProjectDetailsStub();
let actualDetails: ProjectDetails | undefined;
const scriptingDefinitionParser
: ScriptingDefinitionParser = (_, details: ProjectDetails) => {
actualDetails = details;
return new ScriptingDefinitionStub();
};
const context = new TestContext()
.withProjectDetails(expectedProjectDetails)
.withScriptDefinitionParser(scriptingDefinitionParser);
// act
context.parseCategoryCollection();
// assert
expect(actualDetails).to.equal(expectedProjectDetails);
});
});
describe('os', () => {
it('parses as expected', () => {
it('parses correctly', () => {
// arrange
const {
categoryCollectionFactorySpy,
getInitParameters,
} = createCategoryCollectionFactorySpy();
const expectedOs = OperatingSystem.macOS;
const osText = 'macos';
const expectedName = 'os';
const collection = new CollectionDataStub()
const collectionData = new CollectionDataStub()
.withOs(osText);
const parserMock = new EnumParserStub<OperatingSystem>()
.setup(expectedName, osText, expectedOs);
const projectDetails = new ProjectDetailsStub();
const context = new TestContext()
.withOsParser(parserMock)
.withCategoryCollectionFactory(categoryCollectionFactorySpy)
.withData(collectionData);
// act
const actual = parseCategoryCollection(collection, projectDetails, parserMock);
const actualCollection = context.parseCategoryCollection();
// assert
expect(actual.os).to.equal(expectedOs);
});
});
describe('functions', () => {
it('compiles script call with given function', () => {
// arrange
const expectedCode = 'code-from-the-function';
const functionName = 'function-name';
const scriptName = 'script-name';
const script = createScriptDataWithCall()
.withCall(new FunctionCallDataStub().withName(functionName).withParameters({}))
.withName(scriptName);
const func = createFunctionDataWithCode()
.withParametersObject([])
.withName(functionName)
.withCode(expectedCode);
const category = new CategoryDataStub()
.withChildren([script,
createScriptDataWithCode().withName('2')
.withRecommendationLevel(RecommendationLevel.Standard),
createScriptDataWithCode()
.withName('3').withRecommendationLevel(RecommendationLevel.Strict),
]);
const collection = new CollectionDataStub()
.withActions([category])
.withFunctions([func]);
const projectDetails = new ProjectDetailsStub();
// act
const actual = parseCategoryCollection(collection, projectDetails);
// assert
const actualScript = actual.getScript(scriptName);
const actualCode = actualScript.code.execute;
expect(actualCode).to.equal(expectedCode);
const actualOs = getInitParameters(actualCollection)?.os;
expect(actualOs).to.equal(expectedOs);
});
});
});
});
class TestContext {
private data: CollectionData = new CollectionDataStub();
private projectDetails: ProjectDetails = new ProjectDetailsStub();
private validator: TypeValidator = new TypeValidatorStub();
private osParser: EnumParser<OperatingSystem> = new EnumParserStub<OperatingSystem>()
.setupDefaultValue(OperatingSystem.Android);
private collectionUtilitiesFactory
: CategoryCollectionSpecificUtilitiesFactory = () => {
return new CategoryCollectionSpecificUtilitiesStub();
};
private scriptDefinitionParser: ScriptingDefinitionParser = () => new ScriptingDefinitionStub();
private categoryParser: CategoryParser = new CategoryParserStub().get();
private categoryCollectionFactory
: CategoryCollectionFactory = createCategoryCollectionFactorySpy().categoryCollectionFactorySpy;
public withData(data: CollectionData): this {
this.data = data;
return this;
}
public withCategoryParser(categoryParser: CategoryParser): this {
this.categoryParser = categoryParser;
return this;
}
public withCategoryCollectionFactory(categoryCollectionFactory: CategoryCollectionFactory): this {
this.categoryCollectionFactory = categoryCollectionFactory;
return this;
}
public withProjectDetails(projectDetails: ProjectDetails): this {
this.projectDetails = projectDetails;
return this;
}
public withOsParser(osParser: EnumParser<OperatingSystem>): this {
this.osParser = osParser;
return this;
}
public withScriptDefinitionParser(scriptDefinitionParser: ScriptingDefinitionParser): this {
this.scriptDefinitionParser = scriptDefinitionParser;
return this;
}
public withTypeValidator(typeValidator: TypeValidator): this {
this.validator = typeValidator;
return this;
}
public withCollectionUtilitiesFactory(
collectionUtilitiesFactory: CategoryCollectionSpecificUtilitiesFactory,
): this {
this.collectionUtilitiesFactory = collectionUtilitiesFactory;
return this;
}
public parseCategoryCollection(): ReturnType<typeof parseCategoryCollection> {
return parseCategoryCollection(
this.data,
this.projectDetails,
{
osParser: this.osParser,
validator: this.validator,
parseScriptingDefinition: this.scriptDefinitionParser,
createUtilities: this.collectionUtilitiesFactory,
parseCategory: this.categoryParser,
createCategoryCollection: this.categoryCollectionFactory,
},
);
}
}

2
tests/unit/application/Parser/ContextualError.spec.ts → tests/unit/application/Parser/Common/ContextualError.spec.ts
View File

@@ -1,6 +1,6 @@
import { describe, it, expect } from 'vitest';
import { CustomError } from '@/application/Common/CustomError';
import { wrapErrorWithAdditionalContext } from '@/application/Parser/ContextualError';
import { wrapErrorWithAdditionalContext } from '@/application/Parser/Common/ContextualError';
describe('wrapErrorWithAdditionalContext', () => {
it('preserves the original error when wrapped', () => {

2
tests/unit/application/Parser/ContextualErrorTester.ts → tests/unit/application/Parser/Common/ContextualErrorTester.ts
View File

@@ -1,4 +1,4 @@
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
import { indentText } from '@tests/shared/Text';

157
tests/unit/application/Parser/Common/TypeValidator.spec.ts Normal file
View File

@@ -0,0 +1,157 @@
import { describe, it, expect } from 'vitest';
import { createTypeValidator } from '@/application/Parser/Common/TypeValidator';
import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
describe('createTypeValidator', () => {
describe('assertObject', () => {
describe('with valid object', () => {
it('accepts object with allowed properties', () => {
// arrange
const expectedProperties = ['expected1', 'expected2'];
const validValue = createObjectWithProperties(expectedProperties);
const { assertObject } = createTypeValidator();
// act
const act = () => assertObject({
value: validValue,
valueName: 'unimportant name',
allowedProperties: expectedProperties,
});
// assert
expect(act).to.not.throw();
});
it('accepts object with extra unspecified properties', () => {
// arrange
const validValue = createObjectWithProperties(['unevaluated property']);
const { assertObject } = createTypeValidator();
// act
const act = () => assertObject({
value: validValue,
valueName: 'unimportant name',
});
// assert
expect(act).to.not.throw();
});
});
describe('with invalid object', () => {
describe('throws error for missing object', () => {
itEachAbsentObjectValue((absentValue) => {
// arrange
const valueName = 'absent object value';
const expectedMessage = `'${valueName}' is missing.`;
const { assertObject } = createTypeValidator();
// act
const act = () => assertObject({ value: absentValue, valueName });
// assert
expect(act).to.throw(expectedMessage);
});
});
it('throws error for object without properties', () => {
// arrange
const emptyObjectValue: object = {};
const valueName = 'empty object without properties.';
const expectedMessage = `'${valueName}' is an empty object without properties.`;
const { assertObject } = createTypeValidator();
// act
const act = () => assertObject({ value: emptyObjectValue, valueName });
// assert
expect(act).to.throw(expectedMessage);
});
describe('incorrect data type', () => {
// arrange
const testScenarios: readonly {
readonly value: unknown;
readonly valueName: string;
}[] = [
{
value: ['1', '2'],
valueName: 'array of strings',
},
{
value: true,
valueName: 'true boolean',
},
{
value: 35,
valueName: 'number',
},
];
testScenarios.forEach(({ value, valueName }) => {
it(`throws error for ${valueName} passed as object`, () => {
// arrange
const expectedMessage = `'${valueName}' is not an object.`;
const { assertObject } = createTypeValidator();
// act
const act = () => assertObject({ value, valueName });
// assert
expect(act).to.throw(expectedMessage);
});
});
});
it('throws error for object with disallowed properties', () => {
// arrange
const valueName = 'value with unexpected properties';
const unexpectedProperties = ['unexpected-property-1', 'unexpected-property-2'];
const expectedError = `'${valueName}' has disallowed properties: ${unexpectedProperties.join(', ')}.`;
const expectedProperties = ['expected1', 'expected2'];
const value = createObjectWithProperties(
[...expectedProperties, ...unexpectedProperties],
);
const { assertObject } = createTypeValidator();
// act
const act = () => assertObject({
value,
valueName,
allowedProperties: expectedProperties,
});
// assert
expect(act).to.throw(expectedError);
});
});
});
describe('assertNonEmptyCollection', () => {
describe('with valid collection', () => {
it('accepts non-empty collection', () => {
// arrange
const validValue = ['array', 'of', 'strings'];
const { assertNonEmptyCollection } = createTypeValidator();
// act
const act = () => assertNonEmptyCollection({ value: validValue, valueName: 'unimportant name' });
// assert
expect(act).to.not.throw();
});
});
describe('with invalid collection', () => {
describe('throws error for missing collection', () => {
itEachAbsentObjectValue((absentValue) => {
// arrange
const valueName = 'absent collection value';
const expectedMessage = `'${valueName}' is missing.`;
const { assertNonEmptyCollection } = createTypeValidator();
// act
const act = () => assertNonEmptyCollection({ value: absentValue, valueName });
// assert
expect(act).to.throw(expectedMessage);
});
});
it('throws error for empty collection', () => {
// arrange
const emptyArrayValue = [];
const valueName = 'empty collection value';
const expectedMessage = `'${valueName}' cannot be an empty array.`;
const { assertNonEmptyCollection } = createTypeValidator();
// act
const act = () => assertNonEmptyCollection({ value: emptyArrayValue, valueName });
// assert
expect(act).to.throw(expectedMessage);
});
});
});
});
function createObjectWithProperties(properties: readonly string[]): object {
const object = {};
properties.forEach((propertyName) => {
object[propertyName] = 'arbitrary value';
});
return object;
}

127
tests/unit/application/Parser/Executable/CategoryParser.spec.ts
View File

@@ -5,10 +5,9 @@ import { type ScriptParser } from '@/application/Parser/Executable/Script/Script
import { type DocsParser } from '@/application/Parser/Executable/DocumentationParser';
import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
import { getAbsentCollectionTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
import { ExecutableType } from '@/application/Parser/Executable/Validation/ExecutableType';
import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
import type { ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
import { ExecutableValidatorStub, createExecutableValidatorFactoryStub } from '@tests/unit/shared/Stubs/ExecutableValidatorStub';
@@ -20,8 +19,9 @@ import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
import { ScriptParserStub } from '@tests/unit/shared/Stubs/ScriptParserStub';
import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
import { indentText } from '@tests/shared/Text';
import { itThrowsContextualError } from '../ContextualErrorTester';
import { itValidatesName, itValidatesDefinedData, itAsserts } from './Validation/ExecutableValidationTester';
import type { NonEmptyCollectionAssertion, ObjectAssertion } from '@/application/Parser/Common/TypeValidator';
import { itThrowsContextualError } from '../Common/ContextualErrorTester';
import { itValidatesName, itValidatesType, itAsserts } from './Validation/ExecutableValidationTester';
import { generateDataValidationTestScenarios } from './Validation/DataValidationTestScenarioGenerator';
describe('CategoryParser', () => {
@@ -49,14 +49,18 @@ describe('CategoryParser', () => {
};
});
});
describe('validates for defined data', () => {
describe('validates for unknown object', () => {
// arrange
const category = new CategoryDataStub();
const expectedContext: CategoryErrorContext = {
type: ExecutableType.Category,
self: category,
};
itValidatesDefinedData(
const expectedAssertion: ObjectAssertion<unknown> = {
value: category,
valueName: 'Executable',
};
itValidatesType(
(validatorFactory) => {
// act
new TestBuilder()
@@ -65,58 +69,65 @@ describe('CategoryParser', () => {
.parseCategory();
// assert
return {
expectedDataToValidate: category,
assertValidation: (validator) => validator.assertObject(expectedAssertion),
expectedErrorContext: expectedContext,
};
},
);
});
describe('validates that category has some children', () => {
const categoryName = 'test';
const testScenarios = generateDataValidationTestScenarios<CategoryData>({
expectFail: getAbsentCollectionTestCases<ExecutableData>().map(({
valueName, absentValue: absentCollectionValue,
}) => ({
description: `with \`${valueName}\` value as children`,
data: new CategoryDataStub()
.withName(categoryName)
.withChildren(absentCollectionValue as unknown as ExecutableData[]),
})),
expectPass: [{
description: 'has single children',
data: new CategoryDataStub()
.withName(categoryName)
.withChildren([createScriptDataWithCode()]),
}],
});
testScenarios.forEach(({
description, expectedPass, data: categoryData,
}) => {
describe(description, () => {
itAsserts({
expectedConditionResult: expectedPass,
test: (validatorFactory) => {
const expectedMessage = `"${categoryName}" has no children.`;
const expectedContext: CategoryErrorContext = {
type: ExecutableType.Category,
self: categoryData,
};
// act
try {
new TestBuilder()
.withData(categoryData)
.withValidatorFactory(validatorFactory)
.parseCategory();
} catch { /* It may throw due to assertions not being evaluated */ }
// assert
return {
expectedErrorMessage: expectedMessage,
expectedErrorContext: expectedContext,
};
},
});
});
});
describe('validates for category', () => {
// arrange
const category = new CategoryDataStub();
const expectedContext: CategoryErrorContext = {
type: ExecutableType.Category,
self: category,
};
const expectedAssertion: ObjectAssertion<CategoryData> = {
value: category,
valueName: category.category,
allowedProperties: ['docs', 'children', 'category'],
};
itValidatesType(
(validatorFactory) => {
// act
new TestBuilder()
.withData(category)
.withValidatorFactory(validatorFactory)
.parseCategory();
// assert
return {
assertValidation: (validator) => validator.assertObject(expectedAssertion),
expectedErrorContext: expectedContext,
};
},
);
});
describe('validates children for non-empty collection', () => {
// arrange
const category = new CategoryDataStub()
.withChildren([createScriptDataWithCode()]);
const expectedContext: CategoryErrorContext = {
type: ExecutableType.Category,
self: category,
};
const expectedAssertion: NonEmptyCollectionAssertion = {
value: category.children,
valueName: category.category,
};
itValidatesType(
(validatorFactory) => {
// act
new TestBuilder()
.withData(category)
.withValidatorFactory(validatorFactory)
.parseCategory();
// assert
return {
assertValidation: (validator) => validator.assertObject(expectedAssertion),
expectedErrorContext: expectedContext,
};
},
);
});
describe('validates that a child is a category or a script', () => {
// arrange
@@ -171,7 +182,7 @@ describe('CategoryParser', () => {
});
});
describe('validates children recursively', () => {
describe('validates (1th-level) child data', () => {
describe('validates (1th-level) child type', () => {
// arrange
const expectedName = 'child category';
const child = new CategoryDataStub()
@@ -183,7 +194,11 @@ describe('CategoryParser', () => {
self: child,
parentCategory: parent,
};
itValidatesDefinedData(
const expectedAssertion: ObjectAssertion<unknown> = {
value: child,
valueName: 'Executable',
};
itValidatesType(
(validatorFactory) => {
// act
new TestBuilder()
@@ -192,7 +207,7 @@ describe('CategoryParser', () => {
.parseCategory();
// assert
return {
expectedDataToValidate: child,
assertValidation: (validator) => validator.assertObject(expectedAssertion),
expectedErrorContext: expectedContext,
};
},

2
tests/unit/application/Parser/Executable/DocumentationParser.spec.ts
View File

@@ -18,7 +18,7 @@ describe('DocumentationParser', () => {
});
describe('throws when type is unexpected', () => {
// arrange
const expectedTypeError = 'docs field (documentation) must be an array of strings';
const expectedTypeError = 'docs field (documentation) must be a single string or an array of strings.';
const wrongTypedValue = 22 as never;
const testCases: ReadonlyArray<{
readonly name: string;

2
tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts
View File

@@ -8,7 +8,7 @@ import {
import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
import { itThrowsContextualError } from '@tests/unit/application/Parser/Common/ContextualErrorTester';
import { ExpressionStub } from '@tests/unit/shared/Stubs/ExpressionStub';
import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
import type { IExpression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression';

4
tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts
View File

@@ -9,8 +9,8 @@ import { SingleCallCompilerStub } from '@tests/unit/shared/Stubs/SingleCallCompi
import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import { itThrowsContextualError } from '@tests/unit/application/Parser/Common/ContextualErrorTester';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
describe('NestedFunctionCallCompiler', () => {

4
tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts
View File

@@ -11,8 +11,8 @@ import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/Fun
import { createSharedFunctionStubWithCode } from '@tests/unit/shared/Stubs/SharedFunctionStub';
import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
import { SharedFunctionCollectionStub } from '@tests/unit/shared/Stubs/SharedFunctionCollectionStub';
import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import { itThrowsContextualError } from '@tests/unit/application/Parser/Common/ContextualErrorTester';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
describe('NestedFunctionArgumentCompiler', () => {

4
tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.spec.ts
View File

@@ -13,10 +13,10 @@ import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
import { itThrowsContextualError } from '@tests/unit/application/Parser/Common/ContextualErrorTester';
import type { FunctionParameterCollectionFactory } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
import { expectCallsFunctionBody, expectCodeFunctionBody } from './ExpectFunctionBodyType';

4
tests/unit/application/Parser/Executable/Script/Compiler/ScriptCompiler.spec.ts
View File

@@ -16,12 +16,12 @@ import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
import { createScriptCodeFactoryStub } from '@tests/unit/shared/Stubs/ScriptCodeFactoryStub';
import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
import { itThrowsContextualError } from '@tests/unit/application/Parser/Common/ContextualErrorTester';
describe('ScriptCompiler', () => {
describe('canCompile', () => {

27
tests/unit/application/Parser/Executable/Script/ScriptParser.spec.ts
View File

@@ -1,5 +1,5 @@
import { describe, it, expect } from 'vitest';
import type { ScriptData } from '@/application/collections/';
import type { ScriptData, CallScriptData, CodeScriptData } from '@/application/collections/';
import { parseScript, type ScriptFactory } from '@/application/Parser/Executable/Script/ScriptParser';
import { type DocsParser } from '@/application/Parser/Executable/DocumentationParser';
import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
@@ -8,14 +8,13 @@ import { ScriptCompilerStub } from '@tests/unit/shared/Stubs/ScriptCompilerStub'
import { createScriptDataWithCall, createScriptDataWithCode, createScriptDataWithoutCallOrCodes } from '@tests/unit/shared/Stubs/ScriptDataStub';
import { EnumParserStub } from '@tests/unit/shared/Stubs/EnumParserStub';
import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
import type { IEnumParser } from '@/application/Common/Enum';
import type { EnumParser } from '@/application/Common/Enum';
import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
import type { ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
import { ExecutableValidatorStub, createExecutableValidatorFactoryStub } from '@tests/unit/shared/Stubs/ExecutableValidatorStub';
@@ -26,9 +25,11 @@ import { createScriptCodeFactoryStub } from '@tests/unit/shared/Stubs/ScriptCode
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
import { createScriptFactorySpy } from '@tests/unit/shared/Stubs/ScriptFactoryStub';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
import { itThrowsContextualError } from '@tests/unit/application/Parser/Common/ContextualErrorTester';
import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
import type { CategoryCollectionSpecificUtilities } from '@/application/Parser/Executable/CategoryCollectionSpecificUtilities';
import { itAsserts, itValidatesDefinedData, itValidatesName } from '../Validation/ExecutableValidationTester';
import type { ObjectAssertion } from '@/application/Parser/Common/TypeValidator';
import { itAsserts, itValidatesType, itValidatesName } from '../Validation/ExecutableValidationTester';
import { generateDataValidationTestScenarios } from '../Validation/DataValidationTestScenarioGenerator';
describe('ScriptParser', () => {
@@ -290,7 +291,14 @@ describe('ScriptParser', () => {
type: ExecutableType.Script,
self: expectedScript,
};
itValidatesDefinedData(
const expectedAssertion: ObjectAssertion<CallScriptData & CodeScriptData> = {
value: expectedScript,
valueName: expectedScript.name,
allowedProperties: [
'name', 'recommend', 'code', 'revertCode', 'call', 'docs',
],
};
itValidatesType(
(validatorFactory) => {
// act
new TestContext()
@@ -301,6 +309,7 @@ describe('ScriptParser', () => {
return {
expectedDataToValidate: expectedScript,
expectedErrorContext: expectedContext,
assertValidation: (validator) => validator.assertObject(expectedAssertion),
};
},
);
@@ -430,7 +439,7 @@ class TestContext {
private collectionUtilities
: CategoryCollectionSpecificUtilities = new CategoryCollectionSpecificUtilitiesStub();
private levelParser: IEnumParser<RecommendationLevel> = new EnumParserStub<RecommendationLevel>()
private levelParser: EnumParser<RecommendationLevel> = new EnumParserStub<RecommendationLevel>()
.setupDefaultValue(RecommendationLevel.Standard);
private scriptFactory: ScriptFactory = createScriptFactorySpy().scriptFactorySpy;
@@ -464,7 +473,7 @@ class TestContext {
return this;
}
public withParser(parser: IEnumParser<RecommendationLevel>): this {
public withParser(parser: EnumParser<RecommendationLevel>): this {
this.levelParser = parser;
return this;
}

62
tests/unit/application/Parser/Executable/Validation/ExecutableValidationTester.ts
View File

@@ -3,10 +3,11 @@ import type { ExecutableValidator, ExecutableValidatorFactory } from '@/applicat
import type { ExecutableErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
import { ExecutableValidatorStub } from '@tests/unit/shared/Stubs/ExecutableValidatorStub';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import type { ExecutableData } from '@/application/collections/';
import type { FunctionKeys } from '@/TypeHelpers';
import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
import { indentText } from '@tests/shared/Text';
import { TypeValidatorStub } from '@tests/unit/shared/Stubs/TypeValidatorStub';
import { expectDeepIncludes } from '@tests/shared/Assertions/ExpectDeepIncludes';
type ValidationTestFunction<TExpectation> = (
factory: ExecutableValidatorFactory,
@@ -52,39 +53,41 @@ export function itValidatesName(
});
}
interface ValidDataExpectation {
readonly expectedDataToValidate: ExecutableData;
interface TypeAssertionExpectation {
readonly expectedErrorContext: ExecutableErrorContext;
readonly assertValidation: (validator: TypeValidatorStub) => void;
}
export function itValidatesDefinedData(
test: ValidationTestFunction<ValidDataExpectation>,
export function itValidatesType(
test: ValidationTestFunction<TypeAssertionExpectation>,
) {
it('validates data', () => {
it('validates type', () => {
// arrange
const validator = new ExecutableValidatorStub();
const factoryStub: ExecutableValidatorFactory = () => validator;
// act
test(factoryStub);
// assert
const call = validator.callHistory.find((c) => c.methodName === 'assertDefined');
const call = validator.callHistory.find((c) => c.methodName === 'assertType');
expectExists(call);
});
it('validates data with correct data', () => {
it('validates type using specified validator', () => {
// arrange
const typeValidator = new TypeValidatorStub();
const validator = new ExecutableValidatorStub();
const factoryStub: ExecutableValidatorFactory = () => validator;
// act
const expectation = test(factoryStub);
// assert
const expectedData = expectation.expectedDataToValidate;
const calls = validator.callHistory.filter((c) => c.methodName === 'assertDefined');
const names = calls.flatMap((c) => c.args[0]);
expect(names).to.include(expectedData);
const calls = validator.callHistory.filter((c) => c.methodName === 'assertType');
const args = calls.map((c) => c.args as Parameters<ExecutableValidator['assertType']>);
const validateFunctions = args.flatMap((c) => c[0]);
validateFunctions.forEach((validate) => validate(typeValidator));
expectation.assertValidation(typeValidator);
});
it('validates data with correct context', () => {
it('validates type with correct context', () => {
expectCorrectContextForFunctionCall({
methodName: 'assertDefined',
methodName: 'assertType',
act: test,
expectContext: (expectation) => expectation.expectedErrorContext,
});
@@ -185,34 +188,5 @@ function expectCorrectContextForFunctionCall<T>(testScenario: {
const providedContexts = createdValidators
.filter((v) => v.validator.callHistory.find((c) => c.methodName === methodName))
.map((v) => v.context);
expectDeepIncludes( // to.deep.include is not working
providedContexts,
expectedContext,
formatAssertionMessage([
'Error context mismatch.',
'Provided contexts do not include the expected context.',
'Expected context:',
indentText(JSON.stringify(expectedContext, undefined, 2)),
'Provided contexts:',
indentText(JSON.stringify(providedContexts, undefined, 2)),
]),
);
}
function expectDeepIncludes<T>(
array: readonly T[],
item: T,
message: string,
) {
const serializeItem = (c) => JSON.stringify(c);
const serializedContexts = array.map((c) => serializeItem(c));
const serializedExpectedContext = serializeItem(item);
expect(serializedContexts).to.include(serializedExpectedContext, formatAssertionMessage([
'Error context mismatch.',
'Provided contexts do not include the expected context.',
'Expected context:',
indentText(JSON.stringify(message, undefined, 2)),
'Provided contexts:',
indentText(JSON.stringify(message, undefined, 2)),
]));
expectDeepIncludes(providedContexts, expectedContext);
}

70
tests/unit/application/Parser/Executable/Validation/ExecutableValidator.spec.ts
View File

@@ -1,12 +1,12 @@
import { describe, it, expect } from 'vitest';
import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
import type { ExecutableData } from '@/application/collections/';
import { createExecutableErrorContextStub } from '@tests/unit/shared/Stubs/ExecutableErrorContextStub';
import type { ExecutableErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
import { ContextualExecutableValidator, createExecutableDataValidator, type ExecutableValidator } from '@/application/Parser/Executable/Validation/ExecutableValidator';
import type { ExecutableContextErrorMessageCreator } from '@/application/Parser/Executable/Validation/ExecutableErrorContextMessage';
import { getAbsentObjectTestCases, getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
import { TypeValidatorStub } from '@tests/unit/shared/Stubs/TypeValidatorStub';
import type { TypeValidator } from '@/application/Parser/Common/TypeValidator';
describe('createExecutableDataValidator', () => {
it(`returns an instance of ${ContextualExecutableValidator.name}`, () => {
@@ -63,43 +63,41 @@ describe('ContextualExecutableValidator', () => {
expect(act).to.not.throw();
});
});
describe('assertDefined', () => {
describe('throws when data is missing', () => {
describe('assertType', () => {
describe('rethrows when action throws', () => {
// arrange
const testScenarios: readonly {
readonly description: string;
readonly invalidData: unknown;
}[] = [
...getAbsentObjectTestCases().map((testCase) => ({
description: `absent object (${testCase.valueName})`,
invalidData: testCase.absentValue,
})),
{
description: 'empty object',
invalidData: {},
},
];
testScenarios.forEach(({ description, invalidData }) => {
describe(`given "${description}"`, () => {
const expectedMessage = 'missing executable data';
itThrowsCorrectly({
// act
throwingAction: (sut: ExecutableValidator) => {
sut.assertDefined(invalidData as ExecutableData);
},
// assert
expectedMessage,
const expectedMessage = 'Error thrown by action';
itThrowsCorrectly({
// act
throwingAction: (sut: ExecutableValidator) => {
sut.assertType(() => {
throw new Error(expectedMessage);
});
});
},
// assert
expectedMessage,
});
});
it('does not throw if data is defined', () => {
it('provides correct validator', () => {
// arrange
const expectedValidator = new TypeValidatorStub();
const sut = new ValidatorBuilder()
.withTypeValidator(expectedValidator)
.build();
let actualValidator: TypeValidator | undefined;
// act
sut.assertType((validator) => {
actualValidator = validator;
});
// assert
expect(expectedValidator).to.equal(actualValidator);
});
it('does not throw if action does not throw', () => {
// arrange
const data = new CategoryDataStub();
const sut = new ValidatorBuilder()
.build();
// act
const act = () => sut.assertDefined(data);
const act = () => sut.assertType(() => { /* Does not throw */ });
// assert
expect(act).to.not.throw();
});
@@ -223,6 +221,8 @@ class ValidatorBuilder {
private errorMessageCreator: ExecutableContextErrorMessageCreator = () => `[${ValidatorBuilder.name}] stub error message`;
private typeValidator: TypeValidator = new TypeValidatorStub();
public withErrorMessageCreator(errorMessageCreator: ExecutableContextErrorMessageCreator): this {
this.errorMessageCreator = errorMessageCreator;
return this;
@@ -233,10 +233,16 @@ class ValidatorBuilder {
return this;
}
public withTypeValidator(typeValidator: TypeValidator): this {
this.typeValidator = typeValidator;
return this;
}
public build(): ContextualExecutableValidator {
return new ContextualExecutableValidator(
this.errorContext,
this.errorMessageCreator,
this.typeValidator,
);
}
}

102
tests/unit/application/Parser/ScriptingDefinition/ScriptingDefinitionParser.spec.ts
View File

@@ -1,32 +1,52 @@
import { describe, it, expect } from 'vitest';
import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
import { ScriptingDefinitionParser } from '@/application/Parser/ScriptingDefinition/ScriptingDefinitionParser';
import type { IEnumParser } from '@/application/Common/Enum';
import type { EnumParser } from '@/application/Common/Enum';
import type { ICodeSubstituter } from '@/application/Parser/ScriptingDefinition/ICodeSubstituter';
import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
import { ProjectDetailsStub } from '@tests/unit/shared/Stubs/ProjectDetailsStub';
import { EnumParserStub } from '@tests/unit/shared/Stubs/EnumParserStub';
import { ScriptingDefinitionDataStub } from '@tests/unit/shared/Stubs/ScriptingDefinitionDataStub';
import { CodeSubstituterStub } from '@tests/unit/shared/Stubs/CodeSubstituterStub';
import { parseScriptingDefinition } from '@/application/Parser/ScriptingDefinition/ScriptingDefinitionParser';
import type { ObjectAssertion, TypeValidator } from '@/application/Parser/Common/TypeValidator';
import { TypeValidatorStub } from '@tests/unit/shared/Stubs/TypeValidatorStub';
import type { ScriptingDefinitionData } from '@/application/collections/';
import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
describe('ScriptingDefinitionParser', () => {
describe('parseScriptingDefinition', () => {
it('validates data', () => {
// arrange
const data = new ScriptingDefinitionDataStub();
const expectedAssertion: ObjectAssertion<ScriptingDefinitionData> = {
value: data,
valueName: 'scripting definition',
allowedProperties: ['language', 'fileExtension', 'startCode', 'endCode'],
};
const validatorStub = new TypeValidatorStub();
const context = new TestContext()
.withTypeValidator(validatorStub)
.withData(data);
// act
context.parseScriptingDefinition();
// assert
validatorStub.assertObject(expectedAssertion);
});
describe('language', () => {
it('parses as expected', () => {
// arrange
const expectedLanguage = ScriptingLanguage.batchfile;
const languageText = 'batchfile';
const expectedName = 'language';
const projectDetails = new ProjectDetailsStub();
const definition = new ScriptingDefinitionDataStub()
.withLanguage(languageText);
const parserMock = new EnumParserStub<ScriptingLanguage>()
.setup(expectedName, languageText, expectedLanguage);
const sut = new ScriptingDefinitionParserBuilder()
const context = new TestContext()
.withParser(parserMock)
.build();
.withData(definition);
// act
const actual = sut.parse(definition, projectDetails);
const actual = context.parseScriptingDefinition();
// assert
expect(actual.language).to.equal(expectedLanguage);
});
@@ -35,56 +55,92 @@ describe('ScriptingDefinitionParser', () => {
// arrange
const code = 'hello';
const expected = 'substituted';
const testCases = [
const testScenarios: readonly {
readonly description: string;
getActualValue(result: IScriptingDefinition): string;
readonly data: ScriptingDefinitionData;
}[] = [
{
name: 'startCode',
description: 'startCode',
getActualValue: (result: IScriptingDefinition) => result.startCode,
data: new ScriptingDefinitionDataStub()
.withStartCode(code),
},
{
name: 'endCode',
description: 'endCode',
getActualValue: (result: IScriptingDefinition) => result.endCode,
data: new ScriptingDefinitionDataStub()
.withEndCode(code),
},
];
for (const testCase of testCases) {
it(testCase.name, () => {
testScenarios.forEach(({
description, data, getActualValue,
}) => {
it(description, () => {
const projectDetails = new ProjectDetailsStub();
const substituterMock = new CodeSubstituterStub()
.setup(code, projectDetails, expected);
const sut = new ScriptingDefinitionParserBuilder()
.withSubstituter(substituterMock)
.build();
const context = new TestContext()
.withData(data)
.withProjectDetails(projectDetails)
.withSubstituter(substituterMock);
// act
const definition = sut.parse(testCase.data, projectDetails);
const definition = context.parseScriptingDefinition();
// assert
const actual = testCase.getActualValue(definition);
const actual = getActualValue(definition);
expect(actual).to.equal(expected);
});
}
});
});
});
});
class ScriptingDefinitionParserBuilder {
private languageParser: IEnumParser<ScriptingLanguage> = new EnumParserStub<ScriptingLanguage>()
class TestContext {
private languageParser: EnumParser<ScriptingLanguage> = new EnumParserStub<ScriptingLanguage>()
.setupDefaultValue(ScriptingLanguage.shellscript);
private codeSubstituter: ICodeSubstituter = new CodeSubstituterStub();
public withParser(parser: IEnumParser<ScriptingLanguage>) {
private validator: TypeValidator = new TypeValidatorStub();
private data: ScriptingDefinitionData = new ScriptingDefinitionDataStub();
private projectDetails: ProjectDetails = new ProjectDetailsStub();
public withData(data: ScriptingDefinitionData): this {
this.data = data;
return this;
}
public withProjectDetails(projectDetails: ProjectDetails): this {
this.projectDetails = projectDetails;
return this;
}
public withParser(parser: EnumParser<ScriptingLanguage>): this {
this.languageParser = parser;
return this;
}
public withSubstituter(substituter: ICodeSubstituter) {
public withSubstituter(substituter: ICodeSubstituter): this {
this.codeSubstituter = substituter;
return this;
}
public build() {
return new ScriptingDefinitionParser(this.languageParser, this.codeSubstituter);
public withTypeValidator(validator: TypeValidator): this {
this.validator = validator;
return this;
}
public parseScriptingDefinition() {
return parseScriptingDefinition(
this.data,
this.projectDetails,
{
languageParser: this.languageParser,
codeSubstituter: this.codeSubstituter,
validator: this.validator,
},
);
}
}

6
tests/unit/domain/CategoryCollection.spec.ts
View File

@@ -318,6 +318,10 @@ class CategoryCollectionBuilder {
}
public construct(): CategoryCollection {
return new CategoryCollection(this.os, this.actions, this.scriptingDefinition);
return new CategoryCollection({
os: this.os,
actions: this.actions,
scripting: this.scriptingDefinition,
});
}
}

23
tests/unit/shared/Stubs/CategoryCollectionFactoryStub.ts Normal file
View File

@@ -0,0 +1,23 @@
import type { CategoryCollectionFactory } from '@/application/Parser/CategoryCollectionParser';
import type { CategoryCollectionInitParameters } from '@/domain/CategoryCollection';
import type { ICategoryCollection } from '@/domain/ICategoryCollection';
import { CategoryCollectionStub } from './CategoryCollectionStub';
export function createCategoryCollectionFactorySpy(): {
readonly categoryCollectionFactorySpy: CategoryCollectionFactory;
getInitParameters: (
category: ICategoryCollection,
) => CategoryCollectionInitParameters | undefined;
} {
const createdCategoryCollections = new Map<
ICategoryCollection, CategoryCollectionInitParameters
>();
return {
categoryCollectionFactorySpy: (parameters) => {
const categoryCollection = new CategoryCollectionStub();
createdCategoryCollections.set(categoryCollection, parameters);
return categoryCollection;
},
getInitParameters: (category) => createdCategoryCollections.get(category),
};
}

4
tests/unit/shared/Stubs/CategoryCollectionParserStub.ts
View File

@@ -2,8 +2,8 @@ import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
import type { ICategoryCollection } from '@/domain/ICategoryCollection';
import { getEnumValues } from '@/application/Common/Enum';
import type { CollectionData } from '@/application/collections/';
import type { CategoryCollectionParserType } from '@/application/Parser/ApplicationParser';
import { OperatingSystem } from '@/domain/OperatingSystem';
import type { CategoryCollectionParser } from '@/application/Parser/CategoryCollectionParser';
import { CategoryCollectionStub } from './CategoryCollectionStub';
export class CategoryCollectionParserStub {
@@ -22,7 +22,7 @@ export class CategoryCollectionParserStub {
return this;
}
public getStub(): CategoryCollectionParserType {
public getStub(): CategoryCollectionParser {
return (data: CollectionData, projectDetails: ProjectDetails): ICategoryCollection => {
this.arguments.push({ data, projectDetails });
const foundReturnValue = this.returnValues.get(data);

34
tests/unit/shared/Stubs/CategoryParserStub.ts Normal file
View File

@@ -0,0 +1,34 @@
import type { CategoryParser } from '@/application/Parser/Executable/CategoryParser';
import type { CategoryData } from '@/application/collections/';
import type { Category } from '@/domain/Executables/Category/Category';
import type { CategoryCollectionSpecificUtilities } from '@/application/Parser/Executable/CategoryCollectionSpecificUtilities';
import { CategoryStub } from './CategoryStub';
export class CategoryParserStub {
private configuredParseResults = new Map<CategoryData, Category>();
private usedUtilities = new Array<CategoryCollectionSpecificUtilities>();
public get(): CategoryParser {
return (category, utilities) => {
const result = this.configuredParseResults.get(category);
this.usedUtilities.push(utilities);
if (result) {
return result;
}
return new CategoryStub(5489);
};
}
public withConfiguredParseResult(
givenCategory: CategoryData,
parsedCategory: Category,
): this {
this.configuredParseResults.set(givenCategory, parsedCategory);
return this;
}
public getUsedUtilities(): readonly CategoryCollectionSpecificUtilities[] {
return this.usedUtilities;
}
}

8
tests/unit/shared/Stubs/EnumParserStub.ts
View File

@@ -1,17 +1,17 @@
import type { IEnumParser } from '@/application/Common/Enum';
import type { EnumParser } from '@/application/Common/Enum';
export class EnumParserStub<T> implements IEnumParser<T> {
export class EnumParserStub<T> implements EnumParser<T> {
private readonly scenarios = new Array<{
inputName: string, inputValue: string, outputValue: T }>();
private defaultValue: T;
public setup(inputName: string, inputValue: string, outputValue: T) {
public setup(inputName: string, inputValue: string, outputValue: T): this {
this.scenarios.push({ inputName, inputValue, outputValue });
return this;
}
public setupDefaultValue(outputValue: T) {
public setupDefaultValue(outputValue: T): this {
this.defaultValue = outputValue;
return this;
}

2
tests/unit/shared/Stubs/ErrorWithContextWrapperStub.ts
View File

@@ -1,4 +1,4 @@
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
export const errorWithContextWrapperStub
: ErrorWithContextWrapper = (error, message) => new Error(`[stubbed error wrapper] ${error.message} + ${message}`);

2
tests/unit/shared/Stubs/ErrorWrapperStub.ts
View File

@@ -1,4 +1,4 @@
import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
import type { ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
export class ErrorWrapperStub {
private errorToReturn: Error | undefined;

8
tests/unit/shared/Stubs/ExecutableValidatorStub.ts
View File

@@ -1,5 +1,5 @@
import type { ExecutableData } from '@/application/collections/';
import type { ExecutableValidator, ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
import type { TypeValidator } from '@/application/Parser/Common/TypeValidator';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export const createExecutableValidatorFactoryStub
@@ -23,10 +23,10 @@ export class ExecutableValidatorStub
return this;
}
public assertDefined(data: ExecutableData): this {
public assertType(assert: (validator: TypeValidator) => void): this {
this.registerMethodCall({
methodName: 'assertDefined',
args: [data],
methodName: 'assertType',
args: [assert],
});
return this;
}

45
tests/unit/shared/Stubs/TypeValidatorStub.ts Normal file
View File

@@ -0,0 +1,45 @@
import type { NonEmptyCollectionAssertion, ObjectAssertion, TypeValidator } from '@/application/Parser/Common/TypeValidator';
import type { FunctionKeys } from '@/TypeHelpers';
import { expectDeepIncludes } from '@tests/shared/Assertions/ExpectDeepIncludes';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export type UnknownObjectAssertion = ObjectAssertion<unknown>;
export class TypeValidatorStub
extends StubWithObservableMethodCalls<TypeValidator>
implements TypeValidator {
public assertObject<T>(assertion: ObjectAssertion<T>): void {
this.registerMethodCall({
methodName: 'assertObject',
args: [assertion as UnknownObjectAssertion],
});
}
public assertNonEmptyCollection(assertion: NonEmptyCollectionAssertion): void {
this.registerMethodCall({
methodName: 'assertNonEmptyCollection',
args: [assertion],
});
}
public expectObjectAssertion<T>(
expectedAssertion: ObjectAssertion<T>,
): void {
this.expectAssertion('assertObject', expectedAssertion as UnknownObjectAssertion);
}
public expectNonEmptyCollectionAssertion(
expectedAssertion: NonEmptyCollectionAssertion,
): void {
this.expectAssertion('assertNonEmptyCollection', expectedAssertion);
}
private expectAssertion<T extends FunctionKeys<TypeValidator>>(
methodName: T,
expectedAssertion: Parameters<TypeValidator[T]>[0],
): void {
const assertionCalls = this.callHistory.filter((c) => c.methodName === methodName);
const assertionArgs = assertionCalls.map((c) => c.args[0]);
expectDeepIncludes(assertionArgs, expectedAssertion);
}
}