Refactor executable IDs to use strings #262
This commit unifies executable ID structure across categories and scripts, paving the way for more complex ID solutions for #262. It also refactors related code to adapt to the changes. Key changes: - Change numeric IDs to string IDs for categories - Use named types for string IDs to improve code clarity - Add unit tests to verify ID uniqueness Other supporting changes: - Separate concerns in entities for data access and executables by using separate abstractions (`Identifiable` and `RepositoryEntity`) - Simplify usage and construction of entities. - Remove `BaseEntity` for simplicity. - Move creation of categories/scripts to domain layer - Refactor CategoryCollection for better validation logic isolation - Rename some categories to keep the names (used as pseudo-IDs) unique on Windows.
This commit is contained in:
undergroundwires
248
tests/unit/domain/Collection/CategoryCollection.spec.ts
Normal file
248
tests/unit/domain/Collection/CategoryCollection.spec.ts
Normal file
@@ -0,0 +1,248 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import type { Category } from '@/domain/Executables/Category/Category';
|
||||
import { OperatingSystem } from '@/domain/OperatingSystem';
|
||||
import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
|
||||
import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
|
||||
import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
|
||||
import { getEnumValues } from '@/application/Common/Enum';
|
||||
import { CategoryCollection } from '@/domain/Collection/CategoryCollection';
|
||||
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
|
||||
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
|
||||
import { EnumRangeTestRunner } from '@tests/unit/application/Common/EnumRangeTestRunner';
|
||||
|
||||
describe('CategoryCollection', () => {
|
||||
describe('getScriptsByLevel', () => {
|
||||
it('filters out scripts without levels', () => {
|
||||
// arrange
|
||||
const recommendationLevels = getEnumValues(RecommendationLevel);
|
||||
const scriptsWithLevels = recommendationLevels.map(
|
||||
(level, index) => new ScriptStub(`Script${index}`).withLevel(level),
|
||||
);
|
||||
const toIgnore = new ScriptStub('script-to-ignore').withLevel(undefined);
|
||||
for (const currentLevel of recommendationLevels) {
|
||||
const category = new CategoryStub('parent-action')
|
||||
.withScripts(...scriptsWithLevels)
|
||||
.withScript(toIgnore);
|
||||
const sut = new TestContext()
|
||||
.withActions([category])
|
||||
.construct();
|
||||
// act
|
||||
const actual = sut.getScriptsByLevel(currentLevel);
|
||||
// assert
|
||||
expect(actual).to.not.include(toIgnore);
|
||||
}
|
||||
});
|
||||
it(`${RecommendationLevel[RecommendationLevel.Standard]} filters ${RecommendationLevel[RecommendationLevel.Strict]}`, () => {
|
||||
// arrange
|
||||
const level = RecommendationLevel.Standard;
|
||||
const expected = [
|
||||
new ScriptStub('S1').withLevel(level),
|
||||
new ScriptStub('S2').withLevel(level),
|
||||
];
|
||||
const actions = [
|
||||
new CategoryStub('parent-category').withScripts(
|
||||
...expected,
|
||||
new ScriptStub('S3').withLevel(RecommendationLevel.Strict),
|
||||
),
|
||||
];
|
||||
const sut = new TestContext()
|
||||
.withActions(actions)
|
||||
.construct();
|
||||
// act
|
||||
const actual = sut.getScriptsByLevel(level);
|
||||
// assert
|
||||
expect(expected).to.deep.equal(actual);
|
||||
});
|
||||
it(`${RecommendationLevel[RecommendationLevel.Strict]} includes ${RecommendationLevel[RecommendationLevel.Standard]}`, () => {
|
||||
// arrange
|
||||
const level = RecommendationLevel.Strict;
|
||||
const expected = [
|
||||
new ScriptStub('S1').withLevel(RecommendationLevel.Standard),
|
||||
new ScriptStub('S2').withLevel(RecommendationLevel.Strict),
|
||||
];
|
||||
const actions = [
|
||||
new CategoryStub('parent-category').withScripts(...expected),
|
||||
];
|
||||
const sut = new TestContext()
|
||||
.withActions(actions)
|
||||
.construct();
|
||||
// act
|
||||
const actual = sut.getScriptsByLevel(level);
|
||||
// assert
|
||||
expect(expected).to.deep.equal(actual);
|
||||
});
|
||||
describe('throws when given invalid level', () => {
|
||||
new EnumRangeTestRunner<RecommendationLevel>((level) => {
|
||||
// arrange
|
||||
const sut = new TestContext()
|
||||
.construct();
|
||||
// act
|
||||
sut.getScriptsByLevel(level);
|
||||
})
|
||||
// assert
|
||||
.testOutOfRangeThrows()
|
||||
.testValidValueDoesNotThrow(RecommendationLevel.Standard);
|
||||
});
|
||||
});
|
||||
describe('totalScripts', () => {
|
||||
it('returns total of initial scripts', () => {
|
||||
// arrange
|
||||
const categories = [
|
||||
new CategoryStub('category-1').withScripts(
|
||||
new ScriptStub('S1').withLevel(RecommendationLevel.Standard),
|
||||
),
|
||||
new CategoryStub('category-2').withScripts(
|
||||
new ScriptStub('S2'),
|
||||
new ScriptStub('S3').withLevel(RecommendationLevel.Strict),
|
||||
),
|
||||
new CategoryStub('category-3').withCategories(
|
||||
new CategoryStub('category-3-subcategory-1').withScripts(new ScriptStub('S4')),
|
||||
),
|
||||
];
|
||||
// act
|
||||
const sut = new TestContext()
|
||||
.withActions(categories)
|
||||
.construct();
|
||||
// assert
|
||||
expect(sut.totalScripts).to.equal(4);
|
||||
});
|
||||
});
|
||||
describe('totalCategories', () => {
|
||||
it('returns total of initial categories', () => {
|
||||
// arrange
|
||||
const expected = 4;
|
||||
const categories = [
|
||||
new CategoryStub('category-1').withScripts(new ScriptStub('S1').withLevel(RecommendationLevel.Strict)),
|
||||
new CategoryStub('category-2').withScripts(new ScriptStub('S2'), new ScriptStub('S3')),
|
||||
new CategoryStub('category-3').withCategories(new CategoryStub('category-3-subcategory-1').withScripts(new ScriptStub('S4'))),
|
||||
];
|
||||
// act
|
||||
const sut = new TestContext()
|
||||
.withActions(categories)
|
||||
.construct();
|
||||
// assert
|
||||
expect(sut.totalCategories).to.equal(expected);
|
||||
});
|
||||
});
|
||||
describe('os', () => {
|
||||
it('sets os as expected', () => {
|
||||
// arrange
|
||||
const expected = OperatingSystem.macOS;
|
||||
// act
|
||||
const sut = new TestContext()
|
||||
.withOs(expected)
|
||||
.construct();
|
||||
// assert
|
||||
expect(sut.os).to.deep.equal(expected);
|
||||
});
|
||||
});
|
||||
describe('scriptingDefinition', () => {
|
||||
it('sets scriptingDefinition as expected', () => {
|
||||
// arrange
|
||||
const expected = getValidScriptingDefinition();
|
||||
// act
|
||||
const sut = new TestContext()
|
||||
.withScripting(expected)
|
||||
.construct();
|
||||
// assert
|
||||
expect(sut.scripting).to.deep.equal(expected);
|
||||
});
|
||||
});
|
||||
describe('getCategory', () => {
|
||||
it('throws if category is not found', () => {
|
||||
// arrange
|
||||
const missingCategoryId = 'missing-category-id';
|
||||
const expectedError = `Missing category with ID: "${missingCategoryId}"`;
|
||||
const collection = new TestContext()
|
||||
.withActions([new CategoryStub(`different than ${missingCategoryId}`).withMandatoryScripts()])
|
||||
.construct();
|
||||
// act
|
||||
const act = () => collection.getCategory(missingCategoryId);
|
||||
// assert
|
||||
expect(act).to.throw(expectedError);
|
||||
});
|
||||
it('finds correct category', () => {
|
||||
// arrange
|
||||
const existingCategoryId = 'expected-action-category-id';
|
||||
const expectedCategory = new CategoryStub(existingCategoryId).withMandatoryScripts();
|
||||
const collection = new TestContext()
|
||||
.withActions([expectedCategory])
|
||||
.construct();
|
||||
// act
|
||||
const actualCategory = collection.getCategory(existingCategoryId);
|
||||
// assert
|
||||
expect(actualCategory).to.equal(expectedCategory);
|
||||
});
|
||||
});
|
||||
describe('getScript', () => {
|
||||
it('throws if script is not found', () => {
|
||||
// arrange
|
||||
const scriptId = 'missingScript';
|
||||
const expectedError = `Missing script: ${scriptId}`;
|
||||
const collection = new TestContext()
|
||||
.withActions([new CategoryStub('parent-action').withMandatoryScripts()])
|
||||
.construct();
|
||||
// act
|
||||
const act = () => collection.getScript(scriptId);
|
||||
// assert
|
||||
expect(act).to.throw(expectedError);
|
||||
});
|
||||
it('finds correct script', () => {
|
||||
// arrange
|
||||
const scriptId = 'existingScript';
|
||||
const expectedScript = new ScriptStub(scriptId);
|
||||
const parentCategory = new CategoryStub('parent-action')
|
||||
.withMandatoryScripts()
|
||||
.withScript(expectedScript);
|
||||
const collection = new TestContext()
|
||||
.withActions([parentCategory])
|
||||
.construct();
|
||||
// act
|
||||
const actualScript = collection.getScript(scriptId);
|
||||
// assert
|
||||
expect(actualScript).to.equal(expectedScript);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function getValidScriptingDefinition(): IScriptingDefinition {
|
||||
return {
|
||||
fileExtension: '.bat',
|
||||
language: ScriptingLanguage.batchfile,
|
||||
startCode: 'start',
|
||||
endCode: 'end',
|
||||
};
|
||||
}
|
||||
|
||||
class TestContext {
|
||||
private os = OperatingSystem.Windows;
|
||||
|
||||
private actions: readonly Category[] = [
|
||||
new CategoryStub(`[${TestContext.name}]-action-1`).withMandatoryScripts(),
|
||||
];
|
||||
|
||||
private scriptingDefinition: IScriptingDefinition = getValidScriptingDefinition();
|
||||
|
||||
public withOs(os: OperatingSystem): this {
|
||||
this.os = os;
|
||||
return this;
|
||||
}
|
||||
|
||||
public withActions(actions: readonly Category[]): this {
|
||||
this.actions = actions;
|
||||
return this;
|
||||
}
|
||||
|
||||
public withScripting(scriptingDefinition: IScriptingDefinition): this {
|
||||
this.scriptingDefinition = scriptingDefinition;
|
||||
return this;
|
||||
}
|
||||
|
||||
public construct(): CategoryCollection {
|
||||
return new CategoryCollection({
|
||||
os: this.os,
|
||||
actions: this.actions,
|
||||
scripting: this.scriptingDefinition,
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { validateCategoryCollection } from '@/domain/Collection/Validation/CompositeCategoryCollectionValidator';
|
||||
import type { CategoryCollectionValidationContext, CategoryCollectionValidator } from '@/domain/Collection/Validation/CategoryCollectionValidator';
|
||||
import { CategoryCollectionValidationContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionValidationContextStub';
|
||||
|
||||
describe('validateCategoryCollection', () => {
|
||||
it('throws error when no validators are provided', () => {
|
||||
// arrange
|
||||
const emptyValidators: CategoryCollectionValidator[] = [];
|
||||
const expectedErrorMessage = 'No validators provided.';
|
||||
|
||||
// act
|
||||
const act = () => new TestContext()
|
||||
.withValidators(emptyValidators)
|
||||
.runValidation();
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
describe('validator execution', () => {
|
||||
it('executes single validator', () => {
|
||||
// arrange
|
||||
let isCalled = false;
|
||||
const singleValidator: CategoryCollectionValidator = () => {
|
||||
isCalled = true;
|
||||
};
|
||||
const validators = [singleValidator];
|
||||
|
||||
// act
|
||||
new TestContext()
|
||||
.withValidators(validators)
|
||||
.runValidation();
|
||||
|
||||
// assert
|
||||
expect(isCalled).to.equal(true);
|
||||
});
|
||||
|
||||
it('executes multiple validators in order', () => {
|
||||
// arrange
|
||||
const expectedExecutionSequence: readonly string[] = [
|
||||
'validator1Call',
|
||||
'validator2Call',
|
||||
];
|
||||
const actualExecutionSequence: string[] = [];
|
||||
const validator1: CategoryCollectionValidator = () => {
|
||||
actualExecutionSequence.push(expectedExecutionSequence[0]);
|
||||
};
|
||||
const validator2: CategoryCollectionValidator = () => {
|
||||
actualExecutionSequence.push(expectedExecutionSequence[1]);
|
||||
};
|
||||
const validators = [validator1, validator2];
|
||||
|
||||
// act
|
||||
new TestContext()
|
||||
.withValidators(validators)
|
||||
.runValidation();
|
||||
|
||||
// assert
|
||||
expect(actualExecutionSequence).to.deep.equal(expectedExecutionSequence);
|
||||
});
|
||||
|
||||
it('passes correct context to single validator', () => {
|
||||
// arrange
|
||||
const expectedContext = new CategoryCollectionValidationContextStub();
|
||||
let actualContext: CategoryCollectionValidationContext | undefined;
|
||||
const validator: CategoryCollectionValidator = (context) => {
|
||||
actualContext = context;
|
||||
};
|
||||
const validators = [validator];
|
||||
|
||||
// act
|
||||
new TestContext()
|
||||
.withValidators(validators)
|
||||
.withValidationContext(expectedContext)
|
||||
.runValidation();
|
||||
|
||||
// assert
|
||||
expect(expectedContext).to.equal(actualContext);
|
||||
});
|
||||
|
||||
it('passes same context to all validators', () => {
|
||||
// arrange
|
||||
const expectedContext = new CategoryCollectionValidationContextStub();
|
||||
const receivedContexts = new Array<CategoryCollectionValidationContext>();
|
||||
const contextStoringValidator: CategoryCollectionValidator = (context) => {
|
||||
receivedContexts.push(context);
|
||||
};
|
||||
const validators = [
|
||||
contextStoringValidator,
|
||||
contextStoringValidator,
|
||||
contextStoringValidator,
|
||||
];
|
||||
|
||||
// act
|
||||
new TestContext()
|
||||
.withValidators(validators)
|
||||
.withValidationContext(expectedContext)
|
||||
.runValidation();
|
||||
|
||||
// assert
|
||||
expect(receivedContexts.every((c) => c === expectedContext)).to.equal(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('propagates error from validator', () => {
|
||||
// arrange
|
||||
const expectedError = 'Error from validator';
|
||||
const errorThrowingValidator: CategoryCollectionValidator = () => {
|
||||
throw new Error(expectedError);
|
||||
};
|
||||
const validators = [errorThrowingValidator];
|
||||
|
||||
// act
|
||||
const act = () => new TestContext()
|
||||
.withValidators(validators)
|
||||
.runValidation();
|
||||
|
||||
// Act & Assert
|
||||
expect(act).to.throw(expectedError);
|
||||
});
|
||||
|
||||
it('halts execution on validator error', () => {
|
||||
// arrange
|
||||
const errorThrowingValidator: CategoryCollectionValidator = () => {
|
||||
throw new Error('Error from validator');
|
||||
};
|
||||
let isSecondValidatorCalled = false;
|
||||
const secondValidator: CategoryCollectionValidator = () => {
|
||||
isSecondValidatorCalled = true;
|
||||
};
|
||||
const validators = [errorThrowingValidator, secondValidator];
|
||||
|
||||
// act
|
||||
try {
|
||||
new TestContext()
|
||||
.withValidators(validators)
|
||||
.runValidation();
|
||||
} catch { /* Swallow */ }
|
||||
|
||||
// Act & Assert
|
||||
expect(isSecondValidatorCalled).to.equal(false);
|
||||
});
|
||||
});
|
||||
|
||||
class TestContext {
|
||||
private validators: readonly CategoryCollectionValidator[] = [
|
||||
() => {},
|
||||
];
|
||||
|
||||
private validationContext
|
||||
: CategoryCollectionValidationContext = new CategoryCollectionValidationContextStub();
|
||||
|
||||
public withValidators(validators: readonly CategoryCollectionValidator[]): this {
|
||||
this.validators = validators;
|
||||
return this;
|
||||
}
|
||||
|
||||
public withValidationContext(validationContext: CategoryCollectionValidationContext): this {
|
||||
this.validationContext = validationContext;
|
||||
return this;
|
||||
}
|
||||
|
||||
public runValidation(): ReturnType<typeof validateCategoryCollection> {
|
||||
return validateCategoryCollection(
|
||||
this.validationContext,
|
||||
this.validators,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
import { describe } from 'vitest';
|
||||
import { OperatingSystem } from '@/domain/OperatingSystem';
|
||||
import { EnumRangeTestRunner } from '@tests/unit/application/Common/EnumRangeTestRunner';
|
||||
import { ensureKnownOperatingSystem } from '@/domain/Collection/Validation/Rules/EnsureKnownOperatingSystem';
|
||||
import { CategoryCollectionValidationContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionValidationContextStub';
|
||||
|
||||
describe('ensureKnownOperatingSystem', () => {
|
||||
// act
|
||||
const act = (os: OperatingSystem) => test(os);
|
||||
// assert
|
||||
new EnumRangeTestRunner(act)
|
||||
.testValidValueDoesNotThrow(OperatingSystem.Android)
|
||||
.testOutOfRangeThrows();
|
||||
});
|
||||
|
||||
function test(operatingSystem: OperatingSystem):
|
||||
ReturnType<typeof ensureKnownOperatingSystem> {
|
||||
const context = new CategoryCollectionValidationContextStub()
|
||||
.withOperatingSystem(operatingSystem);
|
||||
return ensureKnownOperatingSystem(context);
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
|
||||
import type { Script } from '@/domain/Executables/Script/Script';
|
||||
import { ensurePresenceOfAllRecommendationLevels } from '@/domain/Collection/Validation/Rules/EnsurePresenceOfAllRecommendationLevels';
|
||||
import { CategoryCollectionValidationContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionValidationContextStub';
|
||||
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
|
||||
import { getEnumValues } from '@/application/Common/Enum';
|
||||
import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
|
||||
|
||||
describe('ensurePresenceOfAllRecommendationLevels', () => {
|
||||
it('passes when all recommendation levels are present', () => {
|
||||
// arrange
|
||||
const scripts = getAllPossibleRecommendationLevels().map((level, index) => {
|
||||
return new ScriptStub(`script-${index}`)
|
||||
.withLevel(level);
|
||||
});
|
||||
|
||||
// act
|
||||
const act = () => test(scripts);
|
||||
|
||||
// assert
|
||||
expect(act).to.not.throw();
|
||||
});
|
||||
|
||||
describe('missing single level', () => {
|
||||
// arrange
|
||||
const recommendationLevels = getAllPossibleRecommendationLevels();
|
||||
recommendationLevels.forEach((missingLevel) => {
|
||||
const expectedDisplayName = getDisplayName(missingLevel);
|
||||
it(`throws an error when when "${expectedDisplayName}" is missing`, () => {
|
||||
const expectedError = `Missing recommendation levels: ${expectedDisplayName}.`;
|
||||
const otherLevels = recommendationLevels.filter((level) => level !== missingLevel);
|
||||
const scripts = otherLevels.map(
|
||||
(level, index) => new ScriptStub(`script-${index}`).withLevel(level),
|
||||
);
|
||||
// act
|
||||
const act = () => test(scripts);
|
||||
// assert
|
||||
expect(act).to.throw(expectedError);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('throws an error with multiple missing recommendation levels', () => {
|
||||
// arrange
|
||||
const [
|
||||
notExpectedLevelInError,
|
||||
...expectedLevelsInError
|
||||
] = getAllPossibleRecommendationLevels();
|
||||
const scripts: Script[] = [
|
||||
new ScriptStub('recommended').withLevel(notExpectedLevelInError),
|
||||
];
|
||||
|
||||
// act
|
||||
const act = () => test(scripts);
|
||||
|
||||
// assert
|
||||
const actualErrorMessage = collectExceptionMessage(act);
|
||||
expectedLevelsInError.forEach((level) => {
|
||||
const expectedLevelInError = getDisplayName(level);
|
||||
expect(actualErrorMessage).to.include(expectedLevelInError);
|
||||
});
|
||||
expect(actualErrorMessage).to.not.include(getDisplayName(notExpectedLevelInError));
|
||||
});
|
||||
|
||||
it('throws an error when no scripts are provided', () => {
|
||||
// arrange
|
||||
const expectedLevelsInError = getAllPossibleRecommendationLevels()
|
||||
.map((level) => getDisplayName(level));
|
||||
const scripts: Script[] = [];
|
||||
|
||||
// act
|
||||
const act = () => test(scripts);
|
||||
|
||||
// assert
|
||||
const actualErrorMessage = collectExceptionMessage(act);
|
||||
expectedLevelsInError.forEach((expectedLevelInError) => {
|
||||
expect(actualErrorMessage).to.include(expectedLevelInError);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function test(allScripts: Script[]):
|
||||
ReturnType<typeof ensurePresenceOfAllRecommendationLevels> {
|
||||
const context = new CategoryCollectionValidationContextStub()
|
||||
.withAllScripts(allScripts);
|
||||
return ensurePresenceOfAllRecommendationLevels(context);
|
||||
}
|
||||
|
||||
function getAllPossibleRecommendationLevels(): readonly (RecommendationLevel | undefined)[] {
|
||||
return [
|
||||
...getEnumValues(RecommendationLevel),
|
||||
undefined,
|
||||
];
|
||||
}
|
||||
|
||||
function getDisplayName(level: RecommendationLevel | undefined): string {
|
||||
return level === undefined ? 'None' : RecommendationLevel[level];
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { CategoryCollectionValidationContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionValidationContextStub';
|
||||
import type { Category } from '@/domain/Executables/Category/Category';
|
||||
import { ensurePresenceOfAtLeastOneCategory } from '@/domain/Collection/Validation/Rules/EnsurePresenceOfAtLeastOneCategory';
|
||||
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
|
||||
|
||||
describe('ensurePresenceOfAtLeastOneCategory', () => {
|
||||
it('throws an error when no categories are present', () => {
|
||||
// arrange
|
||||
const expectedErrorMessage = 'Collection must have at least one category';
|
||||
const categories: Category[] = [];
|
||||
|
||||
// act
|
||||
const act = () => test(categories);
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
it('does not throw an error when at least one category is present', () => {
|
||||
// arrange
|
||||
const categories: Category[] = [
|
||||
new CategoryStub('existing-category'),
|
||||
];
|
||||
|
||||
// act
|
||||
const act = () => test(categories);
|
||||
|
||||
// assert
|
||||
expect(act).not.to.throw();
|
||||
});
|
||||
});
|
||||
|
||||
function test(allCategories: readonly Category[]):
|
||||
ReturnType<typeof ensurePresenceOfAtLeastOneCategory> {
|
||||
const context = new CategoryCollectionValidationContextStub()
|
||||
.withAllCategories(allCategories);
|
||||
return ensurePresenceOfAtLeastOneCategory(context);
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { CategoryCollectionValidationContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionValidationContextStub';
|
||||
import type { Script } from '@/domain/Executables/Script/Script';
|
||||
import { ensurePresenceOfAtLeastOneScript } from '@/domain/Collection/Validation/Rules/EnsurePresenceOfAtLeastOneScript';
|
||||
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
|
||||
|
||||
describe('ensurePresenceOfAtLeastOneScript', () => {
|
||||
it('throws an error when no scripts are present', () => {
|
||||
// arrange
|
||||
const expectedErrorMessage = 'Collection must have at least one script';
|
||||
const scripts: Script[] = [];
|
||||
|
||||
// act
|
||||
const act = () => test(scripts);
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
it('does not throw an error when at least one category is present', () => {
|
||||
// arrange
|
||||
const scripts: Script[] = [
|
||||
new ScriptStub('existing-script'),
|
||||
];
|
||||
|
||||
// act
|
||||
const act = () => test(scripts);
|
||||
|
||||
// assert
|
||||
expect(act).not.to.throw();
|
||||
});
|
||||
});
|
||||
|
||||
function test(allScripts: readonly Script[]):
|
||||
ReturnType<typeof ensurePresenceOfAtLeastOneScript> {
|
||||
const context = new CategoryCollectionValidationContextStub()
|
||||
.withAllScripts(allScripts);
|
||||
return ensurePresenceOfAtLeastOneScript(context);
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { ensureUniqueIdsAcrossExecutables } from '@/domain/Collection/Validation/Rules/EnsureUniqueIdsAcrossExecutables';
|
||||
import type { Category } from '@/domain/Executables/Category/Category';
|
||||
import type { Script } from '@/domain/Executables/Script/Script';
|
||||
import { CategoryCollectionValidationContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionValidationContextStub';
|
||||
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
|
||||
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
|
||||
import type { ExecutableId } from '@/domain/Executables/Identifiable';
|
||||
|
||||
describe('ensureUniqueIdsAcrossExecutables', () => {
|
||||
it('does not throw an error when all IDs are unique', () => {
|
||||
// arrange
|
||||
const testData: TestData = {
|
||||
categories: [
|
||||
new CategoryStub('category1'),
|
||||
new CategoryStub('category2'),
|
||||
],
|
||||
scripts: [
|
||||
new ScriptStub('script1'),
|
||||
new ScriptStub('script2'),
|
||||
],
|
||||
};
|
||||
|
||||
// act
|
||||
const act = () => test(testData);
|
||||
|
||||
// assert
|
||||
expect(act).to.not.throw();
|
||||
});
|
||||
|
||||
it('throws an error when duplicate IDs are found across categories and scripts', () => {
|
||||
// arrange
|
||||
const duplicateId: ExecutableId = 'duplicate';
|
||||
const expectedErrorMessage = `Duplicate executable IDs found: "${duplicateId}"`;
|
||||
const testData: TestData = {
|
||||
categories: [
|
||||
new CategoryStub(duplicateId),
|
||||
new CategoryStub('category2'),
|
||||
],
|
||||
scripts: [
|
||||
new ScriptStub(duplicateId),
|
||||
new ScriptStub('script2'),
|
||||
],
|
||||
};
|
||||
|
||||
// act
|
||||
const act = () => test(testData);
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
it('throws an error when duplicate IDs are found within categories', () => {
|
||||
// arrange
|
||||
const duplicateId: ExecutableId = 'duplicate';
|
||||
const expectedErrorMessage = `Duplicate executable IDs found: "${duplicateId}"`;
|
||||
const testData: TestData = {
|
||||
categories: [
|
||||
new CategoryStub(duplicateId),
|
||||
new CategoryStub(duplicateId),
|
||||
],
|
||||
scripts: [
|
||||
new ScriptStub('script1'),
|
||||
new ScriptStub('script2'),
|
||||
],
|
||||
};
|
||||
|
||||
// act
|
||||
const act = () => test(testData);
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
it('throws an error when duplicate IDs are found within scripts', () => {
|
||||
// arrange
|
||||
const duplicateId: ExecutableId = 'duplicate';
|
||||
const expectedErrorMessage = `Duplicate executable IDs found: "${duplicateId}"`;
|
||||
const testData: TestData = {
|
||||
categories: [
|
||||
new CategoryStub('category1'),
|
||||
new CategoryStub('category2'),
|
||||
],
|
||||
scripts: [
|
||||
new ScriptStub(duplicateId),
|
||||
new ScriptStub(duplicateId),
|
||||
],
|
||||
};
|
||||
|
||||
// act
|
||||
const act = () => test(testData);
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
it('throws an error with multiple duplicate IDs', () => {
|
||||
// arrange
|
||||
const duplicateId1: ExecutableId = 'duplicate-1';
|
||||
const duplicateId2: ExecutableId = 'duplicate-2';
|
||||
const expectedErrorMessage = `Duplicate executable IDs found: "${duplicateId1}", "${duplicateId2}"`;
|
||||
const testData: TestData = {
|
||||
categories: [
|
||||
new CategoryStub(duplicateId1),
|
||||
new CategoryStub(duplicateId2),
|
||||
],
|
||||
scripts: [
|
||||
new ScriptStub(duplicateId1),
|
||||
new ScriptStub(duplicateId2),
|
||||
],
|
||||
};
|
||||
|
||||
// act
|
||||
const act = () => test(testData);
|
||||
|
||||
// assert
|
||||
expect(act).to.throw(expectedErrorMessage);
|
||||
});
|
||||
|
||||
it('handles empty categories and scripts arrays', () => {
|
||||
// arrange
|
||||
const testData: TestData = {
|
||||
categories: [],
|
||||
scripts: [],
|
||||
};
|
||||
|
||||
// act
|
||||
const act = () => test(testData);
|
||||
|
||||
// assert
|
||||
expect(act).to.not.throw();
|
||||
});
|
||||
});
|
||||
|
||||
interface TestData {
|
||||
readonly categories: readonly Category[];
|
||||
readonly scripts: readonly Script[];
|
||||
}
|
||||
|
||||
function test(testData: TestData):
|
||||
ReturnType<typeof ensureUniqueIdsAcrossExecutables> {
|
||||
const context = new CategoryCollectionValidationContextStub()
|
||||
.withAllCategories(testData.categories)
|
||||
.withAllScripts(testData.scripts);
|
||||
return ensureUniqueIdsAcrossExecutables(context);
|
||||
}
|
||||
Reference in New Issue
Block a user