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

Extend search by including documentation content

Browse Source 
This commit broadens the search functionality within privacy.sexy by
including documentation text in the search scope. Users can now find
scripts and categories not only by their names but also by content in
their documentation. This improvement aims to make the discovery of
relevant scripts and information more intuitive and comprehensive.

Key changes:

- Documentation text is now searchable, enhancing the ability to
  discover scripts and categories based on content details.

Other supporting changes:

- Remove interface prefixes (`I`) from related interfaces to adhere to
  naming conventions, enhancing code readability.
- Refactor filtering to separate actual filtering logic from filter
  state management, improving the structure for easier maintenance.
- Improve test coverage to ensure relability of existing and new search
  capabilities.
- Test coverage expanded to ensure the reliability of the new search
  capabilities.
This commit is contained in:
undergroundwires
2024-02-14 12:10:49 +01:00
parent 63366a4ec2
commit 6142f3a297
36 changed files with 917 additions and 525 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/application/Context/State/CategoryCollectionState.ts
View File

@@ -1,7 +1,7 @@
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { UserFilter } from './Filter/UserFilter';
import { IUserFilter } from './Filter/IUserFilter';
import { AdaptiveFilterContext } from './Filter/AdaptiveFilterContext';
import { FilterContext } from './Filter/FilterContext';
import { ApplicationCode } from './Code/ApplicationCode';
import { UserSelection } from './Selection/UserSelection';
import { ICategoryCollectionState } from './ICategoryCollectionState';
@@ -15,7 +15,7 @@ export class CategoryCollectionState implements ICategoryCollectionState {
public readonly selection: UserSelection;
public readonly filter: IUserFilter;
public readonly filter: FilterContext;
public constructor(
public readonly collection: ICategoryCollection,
@@ -45,7 +45,7 @@ const DefaultSelectionFactory: SelectionFactory = (
) => new UserSelectionFacade(...params);
export type FilterFactory = (
...params: ConstructorParameters<typeof UserFilter>
) => IUserFilter;
...params: ConstructorParameters<typeof AdaptiveFilterContext>
) => FilterContext;
const DefaultFilterFactory: FilterFactory = (...params) => new UserFilter(...params);
const DefaultFilterFactory: FilterFactory = (...params) => new AdaptiveFilterContext(...params);

35
src/application/Context/State/Filter/AdaptiveFilterContext.ts Normal file
View File

@@ -0,0 +1,35 @@
import { EventSource } from '@/infrastructure/Events/EventSource';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { FilterResult } from './Result/FilterResult';
import { FilterContext } from './FilterContext';
import { FilterChangeDetails } from './Event/FilterChangeDetails';
import { FilterChange } from './Event/FilterChange';
import { FilterStrategy } from './Strategy/FilterStrategy';
import { LinearFilterStrategy } from './Strategy/LinearFilterStrategy';
export class AdaptiveFilterContext implements FilterContext {
public readonly filterChanged = new EventSource<FilterChangeDetails>();
public currentFilter: FilterResult | undefined;
constructor(
private readonly collection: ICategoryCollection,
private readonly filterStrategy: FilterStrategy = new LinearFilterStrategy(),
) {
}
public applyFilter(filter: string): void {
if (!filter) {
throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
}
const result = this.filterStrategy.applyFilter(filter, this.collection);
this.currentFilter = result;
this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
}
public clearFilter(): void {
this.currentFilter = undefined;
this.filterChanged.notify(FilterChange.forClear());
}
}

16
src/application/Context/State/Filter/Event/FilterChange.ts
View File

@@ -1,24 +1,24 @@
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { FilterActionType } from './FilterActionType';
import {
IFilterChangeDetails, IFilterChangeDetailsVisitor,
FilterChangeDetails, FilterChangeDetailsVisitor,
ApplyFilterAction, ClearFilterAction,
} from './IFilterChangeDetails';
} from './FilterChangeDetails';
export class FilterChange implements IFilterChangeDetails {
export class FilterChange implements FilterChangeDetails {
public static forApply(
filter: IFilterResult,
): IFilterChangeDetails {
filter: FilterResult,
): FilterChangeDetails {
return new FilterChange({ type: FilterActionType.Apply, filter });
}
public static forClear(): IFilterChangeDetails {
public static forClear(): FilterChangeDetails {
return new FilterChange({ type: FilterActionType.Clear });
}
private constructor(public readonly action: ApplyFilterAction | ClearFilterAction) { }
public visit(visitor: IFilterChangeDetailsVisitor): void {
public visit(visitor: FilterChangeDetailsVisitor): void {
switch (this.action.type) {
case FilterActionType.Apply:
if (visitor.onApply) {

23
src/application/Context/State/Filter/Event/FilterChangeDetails.ts Normal file
View File

@@ -0,0 +1,23 @@
import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import type { FilterActionType } from './FilterActionType';
export interface FilterChangeDetails {
readonly action: FilterAction;
visit(visitor: FilterChangeDetailsVisitor): void;
}
export interface FilterChangeDetailsVisitor {
readonly onClear?: () => void;
readonly onApply?: (filter: FilterResult) => void;
}
export type ApplyFilterAction = {
readonly type: FilterActionType.Apply,
readonly filter: FilterResult;
};
export type ClearFilterAction = {
readonly type: FilterActionType.Clear,
};
export type FilterAction = ApplyFilterAction | ClearFilterAction;

23
src/application/Context/State/Filter/Event/IFilterChangeDetails.ts
View File

@@ -1,23 +0,0 @@
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { FilterActionType } from './FilterActionType';
export interface IFilterChangeDetails {
readonly action: FilterAction;
visit(visitor: IFilterChangeDetailsVisitor): void;
}
export interface IFilterChangeDetailsVisitor {
readonly onClear?: () => void;
readonly onApply?: (filter: IFilterResult) => void;
}
export type ApplyFilterAction = {
readonly type: FilterActionType.Apply,
readonly filter: IFilterResult;
};
export type ClearFilterAction = {
readonly type: FilterActionType.Clear,
};
export type FilterAction = ApplyFilterAction | ClearFilterAction;

13
src/application/Context/State/Filter/FilterContext.ts Normal file
View File

@@ -0,0 +1,13 @@
import { IEventSource } from '@/infrastructure/Events/IEventSource';
import { FilterResult } from './Result/FilterResult';
import { FilterChangeDetails } from './Event/FilterChangeDetails';
export interface ReadonlyFilterContext {
readonly currentFilter: FilterResult | undefined;
readonly filterChanged: IEventSource<FilterChangeDetails>;
}
export interface FilterContext extends ReadonlyFilterContext {
applyFilter(filter: string): void;
clearFilter(): void;
}

13
src/application/Context/State/Filter/IUserFilter.ts
View File

@@ -1,13 +0,0 @@
import { IEventSource } from '@/infrastructure/Events/IEventSource';
import { IFilterResult } from './IFilterResult';
import { IFilterChangeDetails } from './Event/IFilterChangeDetails';
export interface IReadOnlyUserFilter {
readonly currentFilter: IFilterResult | undefined;
readonly filterChanged: IEventSource<IFilterChangeDetails>;
}
export interface IUserFilter extends IReadOnlyUserFilter {
applyFilter(filter: string): void;
clearFilter(): void;
}

4
src/application/Context/State/Filter/FilterResult.ts → src/application/Context/State/Filter/Result/AppliedFilterResult.ts
View File

@@ -1,8 +1,8 @@
import { IScript } from '@/domain/IScript';
import { ICategory } from '@/domain/ICategory';
import { IFilterResult } from './IFilterResult';
import { FilterResult } from './FilterResult';
export class FilterResult implements IFilterResult {
export class AppliedFilterResult implements FilterResult {
constructor(
public readonly scriptMatches: ReadonlyArray<IScript>,
public readonly categoryMatches: ReadonlyArray<ICategory>,

2
src/application/Context/State/Filter/IFilterResult.ts → src/application/Context/State/Filter/Result/FilterResult.ts
View File

@@ -1,6 +1,6 @@
import { IScript, ICategory } from '@/domain/ICategory';
export interface IFilterResult {
export interface FilterResult {
readonly categoryMatches: ReadonlyArray<ICategory>;
readonly scriptMatches: ReadonlyArray<IScript>;
readonly query: string;

9
src/application/Context/State/Filter/Strategy/FilterStrategy.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { ICategoryCollection } from '@/domain/ICategoryCollection';
import type { FilterResult } from '../Result/FilterResult';
export interface FilterStrategy {
applyFilter(
filter: string,
collection: ICategoryCollection,
): FilterResult;
}

80
src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts Normal file
View File

@@ -0,0 +1,80 @@
import type { ICategory, IScript } from '@/domain/ICategory';
import type { IScriptCode } from '@/domain/IScriptCode';
import type { IDocumentable } from '@/domain/IDocumentable';
import type { ICategoryCollection } from '@/domain/ICategoryCollection';
import { AppliedFilterResult } from '../Result/AppliedFilterResult';
import type { FilterStrategy } from './FilterStrategy';
import type { FilterResult } from '../Result/FilterResult';
export class LinearFilterStrategy implements FilterStrategy {
applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
const filterLowercase = filter.toLocaleLowerCase();
const filteredScripts = collection.getAllScripts().filter(
(script) => matchesScript(script, filterLowercase),
);
const filteredCategories = collection.getAllCategories().filter(
(category) => matchesCategory(category, filterLowercase),
);
return new AppliedFilterResult(
filteredScripts,
filteredCategories,
filter,
);
}
}
function matchesCategory(
category: ICategory,
filterLowercase: string,
): boolean {
return matchesAny(
() => matchName(category.name, filterLowercase),
() => matchDocumentation(category, filterLowercase),
);
}
function matchesScript(
script: IScript,
filterLowercase: string,
): boolean {
return matchesAny(
() => matchName(script.name, filterLowercase),
() => matchCode(script.code, filterLowercase),
() => matchDocumentation(script, filterLowercase),
);
}
function matchesAny(
...predicates: ReadonlyArray<() => boolean>
): boolean {
return predicates.some((predicate) => predicate());
}
function matchName(
name: string,
filterLowercase: string,
): boolean {
return name.toLowerCase().includes(filterLowercase);
}
function matchCode(
code: IScriptCode,
filterLowercase: string,
): boolean {
if (code.execute.toLowerCase().includes(filterLowercase)) {
return true;
}
if (code.revert?.toLowerCase().includes(filterLowercase)) {
return true;
}
return false;
}
function matchDocumentation(
documentable: IDocumentable,
filterLowercase: string,
): boolean {
return documentable.docs.some(
(doc) => doc.toLocaleLowerCase().includes(filterLowercase),
);
}

56
src/application/Context/State/Filter/UserFilter.ts
View File

@@ -1,56 +0,0 @@
import { IScript } from '@/domain/IScript';
import { EventSource } from '@/infrastructure/Events/EventSource';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { FilterResult } from './FilterResult';
import { IFilterResult } from './IFilterResult';
import { IUserFilter } from './IUserFilter';
import { IFilterChangeDetails } from './Event/IFilterChangeDetails';
import { FilterChange } from './Event/FilterChange';
export class UserFilter implements IUserFilter {
public readonly filterChanged = new EventSource<IFilterChangeDetails>();
public currentFilter: IFilterResult | undefined;
constructor(private collection: ICategoryCollection) {
}
public applyFilter(filter: string): void {
if (!filter) {
throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
}
const filterLowercase = filter.toLocaleLowerCase();
const filteredScripts = this.collection.getAllScripts().filter(
(script) => isScriptAMatch(script, filterLowercase),
);
const filteredCategories = this.collection.getAllCategories().filter(
(category) => category.name.toLowerCase().includes(filterLowercase),
);
const matches = new FilterResult(
filteredScripts,
filteredCategories,
filter,
);
this.currentFilter = matches;
this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
}
public clearFilter(): void {
this.currentFilter = undefined;
this.filterChanged.notify(FilterChange.forClear());
}
}
function isScriptAMatch(script: IScript, filterLowercase: string) {
if (script.name.toLowerCase().includes(filterLowercase)) {
return true;
}
if (script.code.execute.toLowerCase().includes(filterLowercase)) {
return true;
}
if (script.code.revert) {
return script.code.revert.toLowerCase().includes(filterLowercase);
}
return false;
}

6
src/application/Context/State/ICategoryCollectionState.ts
View File

@@ -1,18 +1,18 @@
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { IReadOnlyUserFilter, IUserFilter } from './Filter/IUserFilter';
import { ReadonlyFilterContext, FilterContext } from './Filter/FilterContext';
import { ReadonlyUserSelection, UserSelection } from './Selection/UserSelection';
import { IApplicationCode } from './Code/IApplicationCode';
export interface IReadOnlyCategoryCollectionState {
readonly code: IApplicationCode;
readonly os: OperatingSystem;
readonly filter: IReadOnlyUserFilter;
readonly filter: ReadonlyFilterContext;
readonly selection: ReadonlyUserSelection;
readonly collection: ICategoryCollection;
}
export interface ICategoryCollectionState extends IReadOnlyCategoryCollectionState {
readonly filter: IUserFilter;
readonly filter: FilterContext;
readonly selection: UserSelection;
}

4
src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
View File

@@ -16,7 +16,7 @@
<script lang="ts">
import { defineComponent, ref } from 'vue';
import { injectKey } from '@/presentation/injectionSymbols';
import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
import TheOsChanger from './TheOsChanger.vue';
import TheViewChanger from './View/TheViewChanger.vue';
@@ -49,7 +49,7 @@ export default defineComponent({
}, { immediate: true });
function subscribeToFilterChanges(
filter: IReadOnlyUserFilter,
filter: ReadonlyFilterContext,
): IEventSubscription {
return filter.filterChanged.on((event) => {
event.visit({

8
src/presentation/components/Scripts/View/TheScriptsView.vue
View File

@@ -43,8 +43,8 @@ import { injectKey } from '@/presentation/injectionSymbols';
import ScriptsTree from '@/presentation/components/Scripts/View/Tree/ScriptsTree.vue';
import CardList from '@/presentation/components/Scripts/View/Cards/CardList.vue';
import { ViewType } from '@/presentation/components/Scripts/Menu/View/ViewType';
import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import FlatButton from '@/presentation/components/Shared/FlatButton.vue';
export default defineComponent({
@@ -94,12 +94,12 @@ export default defineComponent({
});
}
function updateFromInitialFilter(filter?: IFilterResult) {
function updateFromInitialFilter(filter?: FilterResult) {
searchQuery.value = filter?.query;
searchHasMatches.value = filter?.hasAnyMatches() ?? false;
}
function subscribeToFilterChanges(filter: IReadOnlyUserFilter) {
function subscribeToFilterChanges(filter: ReadonlyFilterContext) {
return filter.filterChanged.on((event) => {
event.visit({
onApply: (newFilter) => {

12
src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
View File

@@ -4,8 +4,8 @@ import {
import { IScript } from '@/domain/IScript';
import { ICategory } from '@/domain/ICategory';
import { injectKey } from '@/presentation/injectionSymbols';
import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { TreeViewFilterEvent, createFilterRemovedEvent, createFilterTriggeredEvent } from '../TreeView/Bindings/TreeInputFilterEvent';
import { NodeMetadata } from '../NodeContent/NodeMetadata';
import { ReadOnlyTreeNode } from '../TreeView/Node/TreeNode';
@@ -14,7 +14,7 @@ import { getCategoryNodeId, getScriptNodeId } from './CategoryNodeMetadataConver
type TreeNodeFilterResultPredicate = (
node: ReadOnlyTreeNode,
filterResult: IFilterResult,
filterResult: FilterResult,
) => boolean;
export function useTreeViewFilterEvent() {
@@ -41,7 +41,7 @@ export function useTreeViewFilterEvent() {
}
function subscribeToFilterChanges(
filter: IReadOnlyUserFilter,
filter: ReadonlyFilterContext,
latestFilterEvent: Ref<TreeViewFilterEvent | undefined>,
filterPredicate: TreeNodeFilterResultPredicate,
) {
@@ -60,7 +60,7 @@ function subscribeToFilterChanges(
}
function createFilterEvent(
filter: IFilterResult | undefined,
filter: FilterResult | undefined,
filterPredicate: TreeNodeFilterResultPredicate,
): TreeViewFilterEvent {
if (!filter) {
@@ -71,7 +71,7 @@ function createFilterEvent(
);
}
function filterMatches(node: NodeMetadata, filter: IFilterResult): boolean {
function filterMatches(node: NodeMetadata, filter: FilterResult): boolean {
return containsScript(node, filter.scriptMatches)
|| containsCategory(node, filter.categoryMatches);
}

8
src/presentation/components/TheSearchBar.vue
View File

@@ -19,8 +19,8 @@ import {
import { injectKey } from '@/presentation/injectionSymbols';
import { NonCollapsing } from '@/presentation/components/Scripts/View/Cards/NonCollapsingDirective';
import AppIcon from '@/presentation/components/Shared/Icon/AppIcon.vue';
import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
export default defineComponent({
@@ -61,12 +61,12 @@ export default defineComponent({
]);
}, { immediate: true });
function updateFromInitialFilter(filter?: IFilterResult) {
function updateFromInitialFilter(filter?: FilterResult) {
searchQuery.value = filter?.query;
}
function subscribeToFilterChanges(
filter: IReadOnlyUserFilter,
filter: ReadonlyFilterContext,
): IEventSubscription {
return filter.filterChanged.on((event) => {
event.visit({

6
tests/unit/application/Context/State/CategoryCollectionState.spec.ts
View File

@@ -11,8 +11,8 @@ import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { ReadonlyScriptSelection } from '@/application/Context/State/Selection/Script/ScriptSelection';
import { ScriptSelectionStub } from '@tests/unit/shared/Stubs/ScriptSelectionStub';
import { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
import { UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
import type { CodeFactory, FilterFactory, SelectionFactory } from '@/application/Context/State/CategoryCollectionState';
import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
describe('CategoryCollectionState', () => {
describe('code', () => {
@@ -113,7 +113,7 @@ describe('CategoryCollectionState', () => {
let actualCollection: ICategoryCollection | undefined;
const filterFactoryMock: FilterFactory = (collection) => {
actualCollection = collection;
return new UserFilterStub();
return new FilterContextStub();
};
// act
new CategoryCollectionStateBuilder()
@@ -134,7 +134,7 @@ class CategoryCollectionStateBuilder {
private selectionFactory: SelectionFactory = () => new UserSelectionStub();
private filterFactory: FilterFactory = () => new UserFilterStub();
private filterFactory: FilterFactory = () => new FilterContextStub();
public withCollection(collection: ICategoryCollection): this {
this.collection = collection;

130
tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts Normal file
View File

@@ -0,0 +1,130 @@
import { describe, it, expect } from 'vitest';
import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { AdaptiveFilterContext } from '@/application/Context/State/Filter/AdaptiveFilterContext';
import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
import { FilterStrategyStub } from '@tests/unit/shared/Stubs/FilterStrategyStub';
import type { FilterStrategy } from '@/application/Context/State/Filter/Strategy/FilterStrategy';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
describe('AdaptiveFilterContext', () => {
describe('clearFilter', () => {
it('emits clear event on filter removal', () => {
// arrange
const expectedChange = FilterChangeDetailsStub.forClear();
let actualChange: FilterChangeDetails | undefined;
const context = new ContextBuilder().build();
context.filterChanged.on((change) => {
actualChange = change;
});
// act
context.clearFilter();
// assert
expectExists(actualChange);
expect(actualChange).to.deep.equal(expectedChange);
});
it('clears current filter', () => {
// arrange
const context = new ContextBuilder().build();
// act
context.applyFilter('non-important');
context.clearFilter();
// assert
expect(context.currentFilter).to.be.equal(undefined);
});
});
describe('applyFilter', () => {
it('updates current filter correctly', () => {
// arrange
const expectedFilter = new FilterResultStub();
const strategy = new FilterStrategyStub()
.withApplyFilterResult(expectedFilter);
const context = new ContextBuilder()
.withStrategy(strategy)
.build();
// act
context.applyFilter('non-important');
// assert
const actualFilter = context.currentFilter;
expect(actualFilter).to.equal(expectedFilter);
});
it('emits apply event with correct filter', () => {
// arrange
const expectedFilter = new FilterResultStub();
const strategy = new FilterStrategyStub()
.withApplyFilterResult(expectedFilter);
const context = new ContextBuilder()
.withStrategy(strategy)
.build();
let actualFilter: FilterResult | undefined;
context.filterChanged.on((filterResult) => {
filterResult.visit({
onApply: (result) => {
actualFilter = result;
},
});
});
// act
context.applyFilter('non-important');
// assert
expect(actualFilter).to.equal(expectedFilter);
});
it('applies filter using current collection', () => {
// arrange
const expectedCollection = new CategoryCollectionStub();
const strategy = new FilterStrategyStub();
const context = new ContextBuilder()
.withStrategy(strategy)
.withCategoryCollection(expectedCollection)
.build();
// act
context.applyFilter('non-important');
// assert
const applyFilterCalls = strategy.callHistory.filter((c) => c.methodName === 'applyFilter');
expect(applyFilterCalls).to.have.lengthOf(1);
const [, actualCollection] = applyFilterCalls[0].args;
expect(actualCollection).to.equal(expectedCollection);
});
it('applies filter with given query', () => {
// arrange
const expectedQuery = 'expected-query';
const strategy = new FilterStrategyStub();
const context = new ContextBuilder()
.withStrategy(strategy)
.build();
// act
context.applyFilter(expectedQuery);
// assert
const applyFilterCalls = strategy.callHistory.filter((c) => c.methodName === 'applyFilter');
expect(applyFilterCalls).to.have.lengthOf(1);
const [actualQuery] = applyFilterCalls[0].args;
expect(actualQuery).to.equal(expectedQuery);
});
});
});
class ContextBuilder {
private categoryCollection: ICategoryCollection = new CategoryCollectionStub();
private filterStrategy: FilterStrategy = new FilterStrategyStub();
public build(): AdaptiveFilterContext {
return new AdaptiveFilterContext(
this.categoryCollection,
this.filterStrategy,
);
}
public withStrategy(strategy: FilterStrategy): this {
this.filterStrategy = strategy;
return this;
}
public withCategoryCollection(categoryCollection: ICategoryCollection): this {
this.categoryCollection = categoryCollection;
return this;
}
}

80
tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
View File

@@ -3,7 +3,8 @@ import { FilterChange } from '@/application/Context/State/Filter/Event/FilterCha
import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
import { FilterChangeDetailsVisitorStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub';
import { ApplyFilterAction } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { ApplyFilterAction } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
describe('FilterChange', () => {
describe('forApply', () => {
@@ -48,14 +49,48 @@ describe('FilterChange', () => {
});
describe('visit', () => {
describe('onClear', () => {
itVisitsOnce(
() => FilterChange.forClear(),
);
it('visits once', () => {
// arrange
const sut = FilterChange.forClear();
const visitor = new FilterChangeDetailsVisitorStub();
// act
sut.visit(visitor);
// assert
expect(visitor.callHistory).to.have.lengthOf(1);
});
it('visits onClear', () => {
// arrange
const sut = FilterChange.forClear();
const visitor = new FilterChangeDetailsVisitorStub();
// act
sut.visit(visitor);
// assert
const call = visitor.callHistory.find((c) => c.methodName === 'onClear');
expect(call).toBeDefined();
});
});
describe('onApply', () => {
itVisitsOnce(
() => FilterChange.forApply(new FilterResultStub()),
);
it('visits once', () => {
// arrange
const sut = FilterChange.forApply(new FilterResultStub());
const visitor = new FilterChangeDetailsVisitorStub();
// act
sut.visit(visitor);
// assert
expect(visitor.callHistory).to.have.lengthOf(1);
});
it('visits onApply', () => {
// arrange
const sut = FilterChange.forApply(new FilterResultStub());
const visitor = new FilterChangeDetailsVisitorStub();
// act
sut.visit(visitor);
// assert
const call = visitor.callHistory.find((c) => c.methodName === 'onApply');
expect(call).toBeDefined();
});
it('visits with expected filter', () => {
// arrange
@@ -65,34 +100,11 @@ describe('FilterChange', () => {
// act
sut.visit(visitor);
// assert
expect(visitor.visitedResults).to.have.lengthOf(1);
expect(visitor.visitedResults).to.include(expectedFilter);
const call = visitor.callHistory.find((c) => c.methodName === 'onApply');
expectExists(call);
const [actualFilter] = call.args;
expect(actualFilter).to.equal(expectedFilter);
});
});
});
});
function itVisitsOnce(sutFactory: () => FilterChange) {
it('visits', () => {
// arrange
const sut = sutFactory();
const expectedType = sut.action.type;
const visitor = new FilterChangeDetailsVisitorStub();
// act
sut.visit(visitor);
// assert
expect(visitor.visitedEvents).to.include(expectedType);
});
it('visits once', () => {
// arrange
const sut = sutFactory();
const expectedType = sut.action.type;
const visitor = new FilterChangeDetailsVisitorStub();
// act
sut.visit(visitor);
// assert
expect(
visitor.visitedEvents.filter((action) => action === expectedType),
).to.have.lengthOf(1);
});
}

45
tests/unit/application/Context/State/Filter/FilterResult.spec.ts
View File

@@ -1,45 +0,0 @@
import { describe, it, expect } from 'vitest';
import { FilterResult } from '@/application/Context/State/Filter/FilterResult';
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
describe('FilterResult', () => {
describe('hasAnyMatches', () => {
it('false when no matches', () => {
const sut = new FilterResult(
/* scriptMatches */ [],
/* categoryMatches */ [],
'query',
);
const actual = sut.hasAnyMatches();
expect(actual).to.equal(false);
});
it('true when script matches', () => {
const sut = new FilterResult(
/* scriptMatches */ [new ScriptStub('id')],
/* categoryMatches */ [],
'query',
);
const actual = sut.hasAnyMatches();
expect(actual).to.equal(true);
});
it('true when category matches', () => {
const sut = new FilterResult(
/* scriptMatches */ [],
/* categoryMatches */ [new CategoryStub(5)],
'query',
);
const actual = sut.hasAnyMatches();
expect(actual).to.equal(true);
});
it('true when script + category matches', () => {
const sut = new FilterResult(
/* scriptMatches */ [new ScriptStub('id')],
/* categoryMatches */ [new CategoryStub(5)],
'query',
);
const actual = sut.hasAnyMatches();
expect(actual).to.equal(true);
});
});
});

99
tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts Normal file
View File

@@ -0,0 +1,99 @@
import { describe, it, expect } from 'vitest';
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
import { AppliedFilterResult } from '@/application/Context/State/Filter/Result/AppliedFilterResult';
import { ICategory, IScript } from '@/domain/ICategory';
describe('AppliedFilterResult', () => {
describe('constructor', () => {
it('initializes query correctly', () => {
// arrange
const expectedQuery = 'expected query';
const builder = new ResultBuilder()
.withQuery(expectedQuery);
// act
const result = builder.build();
// assert
const actualQuery = result.query;
expect(actualQuery).to.equal(expectedQuery);
});
});
describe('hasAnyMatches', () => {
it('returns false with no matches', () => {
// arrange
const expected = false;
const result = new ResultBuilder()
.withScriptMatches([])
.withCategoryMatches([])
.build();
// act
const actual = result.hasAnyMatches();
// assert
expect(actual).to.equal(expected);
});
it('returns true with script matches', () => {
// arrange
const expected = true;
const result = new ResultBuilder()
.withScriptMatches([new ScriptStub('id')])
.withCategoryMatches([])
.build();
// act
const actual = result.hasAnyMatches();
expect(actual).to.equal(expected);
});
it('returns true with category matches', () => {
// arrange
const expected = true;
const result = new ResultBuilder()
.withScriptMatches([])
.withCategoryMatches([new CategoryStub(5)])
.build();
// act
const actual = result.hasAnyMatches();
expect(actual).to.equal(expected);
});
it('returns true with script and category matches', () => {
// arrange
const expected = true;
const result = new ResultBuilder()
.withScriptMatches([new ScriptStub('id')])
.withCategoryMatches([new CategoryStub(5)])
.build();
// act
const actual = result.hasAnyMatches();
expect(actual).to.equal(expected);
});
});
});
class ResultBuilder {
private scriptMatches: readonly IScript[] = [new ScriptStub('id')];
private categoryMatches: readonly ICategory[] = [new CategoryStub(5)];
private query: string = `[${ResultBuilder.name}]query`;
public withScriptMatches(scriptMatches: readonly IScript[]): this {
this.scriptMatches = scriptMatches;
return this;
}
public withCategoryMatches(categoryMatches: readonly ICategory[]): this {
this.categoryMatches = categoryMatches;
return this;
}
public withQuery(query: string) {
this.query = query;
return this;
}
public build(): AppliedFilterResult {
return new AppliedFilterResult(
this.scriptMatches,
this.categoryMatches,
this.query,
);
}
}

278
tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts Normal file
View File

@@ -0,0 +1,278 @@
import { describe, it, expect } from 'vitest';
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { ICategory } from '@/domain/ICategory';
import { IScript } from '@/domain/IScript';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { LinearFilterStrategy } from '@/application/Context/State/Filter/Strategy/LinearFilterStrategy';
describe('LinearFilterStrategy', () => {
describe('applyFilter', () => {
describe('query', () => {
it('returns provided filter', () => {
// arrange
const expectedQuery = 'non matching filter';
const strategy = new FilterStrategyTestBuilder()
.withFilter(expectedQuery);
// act
const result = strategy.applyFilter();
// assert
expect(result.query).to.equal(expectedQuery);
});
});
describe('hasAnyMatches', () => {
it('returns false when there are no matches', () => {
// arrange
const strategy = new FilterStrategyTestBuilder()
.withFilter('non matching filter')
.withCollection(new CategoryCollectionStub());
// act
const result = strategy.applyFilter();
// assert
expect(result.hasAnyMatches()).be.equal(false);
});
it('returns true for a script match', () => {
// arrange
const matchingFilter = 'matching filter';
const collection = new CategoryCollectionStub()
.withAction(new CategoryStub(2).withScript(createMatchingScript(matchingFilter)));
const strategy = new FilterStrategyTestBuilder()
.withFilter(matchingFilter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expect(result.hasAnyMatches()).be.equal(true);
});
it('returns true for a category match', () => {
// arrange
const matchingFilter = 'matching filter';
const collection = new CategoryCollectionStub()
.withAction(createMatchingCategory(matchingFilter));
const strategy = new FilterStrategyTestBuilder()
.withFilter(matchingFilter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expect(result.hasAnyMatches()).be.equal(true);
});
it('returns true for script and category matches', () => {
// arrange
const matchingFilter = 'matching filter';
const collection = new CategoryCollectionStub()
.withAction(createMatchingCategory(matchingFilter))
.withAction(new CategoryStub(2).withScript(createMatchingScript(matchingFilter)));
const strategy = new FilterStrategyTestBuilder()
.withFilter(matchingFilter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expect(result.hasAnyMatches()).be.equal(true);
});
});
describe('scriptMatches', () => {
it('returns empty when there are no matches', () => {
// arrange
const strategy = new FilterStrategyTestBuilder()
.withFilter('non matching filter')
.withCollection(new CategoryCollectionStub());
// act
const result = strategy.applyFilter();
// assert
expect(result.scriptMatches).to.have.lengthOf(0);
});
describe('returns single matching script', () => {
interface ScriptMatchTestScenario {
readonly description: string;
readonly filter: string;
readonly matchingScript: IScript;
}
const testScenarios: readonly ScriptMatchTestScenario[] = [
{
description: 'case-insensitive code',
filter: 'Hello WoRLD',
matchingScript: new ScriptStub('id').withCode('HELLO world'),
},
{
description: 'case-insensitive revert code',
filter: 'Hello WoRLD',
matchingScript: new ScriptStub('id').withRevertCode('HELLO world'),
},
{
description: 'case-insensitive name',
filter: 'Hello WoRLD',
matchingScript: new ScriptStub('id').withName('HELLO world'),
},
{
description: 'case-insensitive documentation',
filter: 'MaTChing doC',
matchingScript: new ScriptStub('id').withDocs(['unrelated docs', 'matching Docs']),
},
];
testScenarios.forEach(({
description, filter, matchingScript,
}) => {
it(description, () => {
// arrange
const expectedMatches = [matchingScript];
const collection = new CategoryCollectionStub()
.withAction(new CategoryStub(33).withScript(matchingScript));
const strategy = new FilterStrategyTestBuilder()
.withFilter(filter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expectScriptMatches(result, expectedMatches);
});
});
});
it('returns multiple matching scripts', () => {
// arrange
const filter = 'matching filter';
const matchingScripts: readonly IScript[] = [
createMatchingScript(filter),
createMatchingScript(filter),
];
const expectedMatches = [...matchingScripts];
const collection = new CategoryCollectionStub()
.withAction(new CategoryStub(0).withScripts(...matchingScripts));
const strategy = new FilterStrategyTestBuilder()
.withFilter(filter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expectScriptMatches(result, expectedMatches);
});
});
describe('categoryMatches', () => {
it('returns empty when there are no matches', () => {
// arrange
const strategy = new FilterStrategyTestBuilder()
.withFilter('non matching filter')
.withCollection(new CategoryCollectionStub());
// act
const result = strategy.applyFilter();
// assert
expect(result.categoryMatches).to.have.lengthOf(0);
});
describe('returns single matching category', () => {
interface CategoryMatchTestScenario {
readonly description: string;
readonly filter: string;
readonly matchingCategory: ICategory;
}
const testScenarios: readonly CategoryMatchTestScenario[] = [
{
description: 'match with case-insensitive name',
filter: 'Hello WoRLD',
matchingCategory: new CategoryStub(55).withName('HELLO world'),
},
{
description: 'case-sensitive documentation',
filter: 'Hello WoRLD',
matchingCategory: new CategoryStub(55).withDocs(['unrelated-docs', 'HELLO world']),
},
];
testScenarios.forEach(({
description, filter, matchingCategory,
}) => {
it(description, () => {
// arrange
const expectedMatches = [matchingCategory];
const collection = new CategoryCollectionStub()
.withAction(matchingCategory);
const strategy = new FilterStrategyTestBuilder()
.withFilter(filter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expectCategoryMatches(result, expectedMatches);
});
});
});
it('returns multiple matching categories', () => {
// arrange
const filter = 'matching filter';
const matchingCategories: readonly ICategory[] = [
createMatchingCategory(filter),
createMatchingCategory(filter),
];
const expectedMatches = [...matchingCategories];
const collection = new CategoryCollectionStub()
.withActions(...matchingCategories);
const strategy = new FilterStrategyTestBuilder()
.withFilter(filter)
.withCollection(collection);
// act
const result = strategy.applyFilter();
// assert
expectCategoryMatches(result, expectedMatches);
});
});
});
});
function createMatchingScript(
matchingFilter: string,
): ScriptStub {
return new ScriptStub('matching-script')
.withCode(matchingFilter)
.withName(matchingFilter);
}
function createMatchingCategory(
matchingFilter: string,
): CategoryStub {
return new CategoryStub(1)
.withName(matchingFilter)
.withDocs([matchingFilter]);
}
function expectCategoryMatches(
actualFilter: FilterResult,
expectedMatches: readonly ICategory[],
): void {
expect(actualFilter.hasAnyMatches()).be.equal(true);
expect(actualFilter.categoryMatches).to.have.lengthOf(expectedMatches.length);
expect(actualFilter.categoryMatches).to.have.members(expectedMatches);
}
function expectScriptMatches(
actualFilter: FilterResult,
expectedMatches: readonly IScript[],
): void {
expect(actualFilter.hasAnyMatches()).be.equal(true);
expect(actualFilter.scriptMatches).to.have.lengthOf(expectedMatches.length);
expect(actualFilter.scriptMatches).to.have.members(expectedMatches);
}
class FilterStrategyTestBuilder {
private filter: string = `[${FilterStrategyTestBuilder.name}]filter`;
private collection: ICategoryCollection = new CategoryCollectionStub();
public withCollection(collection: ICategoryCollection): this {
this.collection = collection;
return this;
}
public withFilter(filter: string): this {
this.filter = filter;
return this;
}
public applyFilter(): ReturnType<LinearFilterStrategy['applyFilter']> {
const strategy = new LinearFilterStrategy();
return strategy.applyFilter(
this.filter,
this.collection,
);
}
}

194
tests/unit/application/Context/State/Filter/UserFilter.spec.ts
View File

@@ -1,194 +0,0 @@
import { describe, it, expect } from 'vitest';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { UserFilter } from '@/application/Context/State/Filter/UserFilter';
import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
describe('UserFilter', () => {
describe('clearFilter', () => {
it('signals when removing filter', () => {
// arrange
const expectedChange = FilterChangeDetailsStub.forClear();
let actualChange: IFilterChangeDetails | undefined;
const sut = new UserFilter(new CategoryCollectionStub());
sut.filterChanged.on((change) => {
actualChange = change;
});
// act
sut.clearFilter();
// assert
expectExists(actualChange);
expect(actualChange).to.deep.equal(expectedChange);
});
it('sets currentFilter to undefined', () => {
// arrange
const sut = new UserFilter(new CategoryCollectionStub());
// act
sut.applyFilter('non-important');
sut.clearFilter();
// assert
expect(sut.currentFilter).to.be.equal(undefined);
});
});
describe('applyFilter', () => {
interface IApplyFilterTestCase {
readonly name: string;
readonly filter: string;
readonly collection: ICategoryCollection;
readonly assert: (result: IFilterResult) => void;
}
const testCases: readonly IApplyFilterTestCase[] = [
(() => {
const nonMatchingFilter = 'non matching filter';
return {
name: 'given no matches',
filter: nonMatchingFilter,
collection: new CategoryCollectionStub(),
assert: (filter) => {
expect(filter.hasAnyMatches()).be.equal(false);
expect(filter.query).to.equal(nonMatchingFilter);
},
};
})(),
(() => {
const code = 'HELLO world';
const matchingFilter = 'Hello WoRLD';
const script = new ScriptStub('id').withCode(code);
return {
name: 'given script match with case-insensitive code',
filter: matchingFilter,
collection: new CategoryCollectionStub()
.withAction(new CategoryStub(33).withScript(script)),
assert: (filter) => {
expect(filter.hasAnyMatches()).be.equal(true);
expect(filter.categoryMatches).to.have.lengthOf(0);
expect(filter.scriptMatches).to.have.lengthOf(1);
expect(filter.scriptMatches[0]).to.deep.equal(script);
expect(filter.query).to.equal(matchingFilter);
},
};
})(),
(() => {
const revertCode = 'HELLO world';
const matchingFilter = 'Hello WoRLD';
const script = new ScriptStub('id').withRevertCode(revertCode);
return {
name: 'given script match with case-insensitive revertCode',
filter: matchingFilter,
collection: new CategoryCollectionStub()
.withAction(new CategoryStub(33).withScript(script)),
assert: (filter) => {
expect(filter.hasAnyMatches()).be.equal(true);
expect(filter.categoryMatches).to.have.lengthOf(0);
expect(filter.scriptMatches).to.have.lengthOf(1);
expect(filter.scriptMatches[0]).to.deep.equal(script);
expect(filter.query).to.equal(matchingFilter);
},
};
})(),
(() => {
const name = 'HELLO world';
const matchingFilter = 'Hello WoRLD';
const script = new ScriptStub('id').withName(name);
return {
name: 'given script match with case-insensitive name',
filter: matchingFilter,
collection: new CategoryCollectionStub()
.withAction(new CategoryStub(33).withScript(script)),
assert: (filter) => {
expect(filter.hasAnyMatches()).be.equal(true);
expect(filter.categoryMatches).to.have.lengthOf(0);
expect(filter.scriptMatches).to.have.lengthOf(1);
expect(filter.scriptMatches[0]).to.deep.equal(script);
expect(filter.query).to.equal(matchingFilter);
},
};
})(),
(() => {
const categoryName = 'HELLO world';
const matchingFilter = 'Hello WoRLD';
const category = new CategoryStub(55).withName(categoryName);
return {
name: 'given category match with case-insensitive name',
filter: matchingFilter,
collection: new CategoryCollectionStub()
.withAction(category),
assert: (filter) => {
expect(filter.hasAnyMatches()).be.equal(true);
expect(filter.categoryMatches).to.have.lengthOf(1);
expect(filter.categoryMatches[0]).to.deep.equal(category);
expect(filter.scriptMatches).to.have.lengthOf(0);
expect(filter.query).to.equal(matchingFilter);
},
};
})(),
(() => {
const matchingText = 'HELLO world';
const matchingFilter = 'Hello WoRLD';
const script = new ScriptStub('script')
.withName(matchingText);
const category = new CategoryStub(55)
.withName(matchingText)
.withScript(script);
return {
name: 'given category and script matches with case-insensitive names',
filter: matchingFilter,
collection: new CategoryCollectionStub()
.withAction(category),
assert: (filter) => {
expect(filter.hasAnyMatches()).be.equal(true);
expect(filter.categoryMatches).to.have.lengthOf(1);
expect(filter.categoryMatches[0]).to.deep.equal(category);
expect(filter.scriptMatches).to.have.lengthOf(1);
expect(filter.scriptMatches[0]).to.deep.equal(script);
expect(filter.query).to.equal(matchingFilter);
},
};
})(),
];
describe('sets currentFilter as expected', () => {
testCases.forEach(({
name, filter, collection, assert,
}) => {
it(name, () => {
// arrange
const sut = new UserFilter(collection);
// act
sut.applyFilter(filter);
// assert
const actual = sut.currentFilter;
expectExists(actual);
assert(actual);
});
});
});
describe('signals as expected', () => {
testCases.forEach(({
name, filter, collection, assert,
}) => {
it(name, () => {
// arrange
const sut = new UserFilter(collection);
let actualFilterResult: IFilterResult | undefined;
sut.filterChanged.on((filterResult) => {
filterResult.visit({
onApply: (result) => {
actualFilterResult = result;
},
});
});
// act
sut.applyFilter(filter);
// assert
expectExists(actualFilterResult);
assert(actualFilterResult);
});
});
});
});
});

50
tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
View File

@@ -9,12 +9,12 @@ import { useCollectionState } from '@/presentation/components/Shared/Hooks/UseCo
import { UseCollectionStateStub } from '@tests/unit/shared/Stubs/UseCollectionStateStub';
import { InjectionKeys } from '@/presentation/injectionSymbols';
import { UseApplicationStub } from '@tests/unit/shared/Stubs/UseApplicationStub';
import { UserFilterMethod, UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import { UseAutoUnsubscribedEventsStub } from '@tests/unit/shared/Stubs/UseAutoUnsubscribedEventsStub';
import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
const DOM_SELECTOR_NO_MATCHES = '.search-no-matches';
const DOM_SELECTOR_CLOSE_BUTTON = '.search__query__close-button';
@@ -22,12 +22,12 @@ const DOM_SELECTOR_CLOSE_BUTTON = '.search__query__close-button';
describe('TheScriptsView.vue', () => {
describe('view types', () => {
describe('initially', () => {
interface IInitialViewTypeTestCase {
interface InitialViewTypeTestCase {
readonly initialView: ViewType;
readonly expectedComponent: Component;
readonly absentComponents: readonly Component[];
}
const testCases: readonly IInitialViewTypeTestCase[] = [
const testCases: readonly InitialViewTypeTestCase[] = [
{
initialView: ViewType.Tree,
expectedComponent: ScriptsTree,
@@ -96,20 +96,20 @@ describe('TheScriptsView.vue', () => {
});
describe('switching views', () => {
interface ISwitchingViewTestCase {
interface ViewSwitchTestScenario {
readonly name: string;
readonly initialView: ViewType;
readonly changeEvents: readonly IFilterChangeDetails[];
readonly changeEvents: readonly FilterChangeDetails[];
readonly componentsToDisappear: readonly Component[];
readonly expectedComponent: Component;
readonly setupFilter?: (filter: UserFilterStub) => UserFilterStub;
readonly setupFilter?: (filter: FilterContextStub) => FilterContextStub;
}
const testCases: readonly ISwitchingViewTestCase[] = [
const testCases: readonly ViewSwitchTestScenario[] = [
{
name: 'tree on initial search with card view',
initialView: ViewType.Cards,
setupFilter: (filter: UserFilterStub) => filter
.withCurrentFilterResult(
setupFilter: (filter: FilterContextStub) => filter
.withCurrentFilter(
new FilterResultStub().withQueryAndSomeMatches(),
),
changeEvents: [],
@@ -119,8 +119,8 @@ describe('TheScriptsView.vue', () => {
{
name: 'restore card after initial search',
initialView: ViewType.Cards,
setupFilter: (filter: UserFilterStub) => filter
.withCurrentFilterResult(
setupFilter: (filter: FilterContextStub) => filter
.withCurrentFilter(
new FilterResultStub().withQueryAndSomeMatches(),
),
changeEvents: [
@@ -171,7 +171,7 @@ describe('TheScriptsView.vue', () => {
}) => {
it(name, async () => {
// arrange
let filterStub = new UserFilterStub();
let filterStub = new FilterContextStub();
if (setupFilter) {
filterStub = setupFilter(filterStub);
}
@@ -201,7 +201,7 @@ describe('TheScriptsView.vue', () => {
describe('does not show close button when not searching', () => {
it('not searching initially', () => {
// arrange
const filterStub = new UserFilterStub()
const filterStub = new FilterContextStub()
.withNoCurrentFilter();
const stateStub = new UseCollectionStateStub()
.withFilter(filterStub);
@@ -217,7 +217,7 @@ describe('TheScriptsView.vue', () => {
});
it('stop searching', async () => {
// arrange
const filterStub = new UserFilterStub();
const filterStub = new FilterContextStub();
const stateStub = new UseCollectionStateStub().withFilter(filterStub);
const wrapper = mountComponent({
useCollectionState: stateStub.get(),
@@ -239,8 +239,8 @@ describe('TheScriptsView.vue', () => {
describe('shows close button when searching', () => {
it('searching initially', () => {
// arrange
const filterStub = new UserFilterStub()
.withCurrentFilterResult(
const filterStub = new FilterContextStub()
.withCurrentFilter(
new FilterResultStub().withQueryAndSomeMatches(),
);
const stateStub = new UseCollectionStateStub()
@@ -257,7 +257,7 @@ describe('TheScriptsView.vue', () => {
});
it('start searching', async () => {
// arrange
const filterStub = new UserFilterStub()
const filterStub = new FilterContextStub()
.withNoCurrentFilter();
const stateStub = new UseCollectionStateStub().withFilter(filterStub);
const wrapper = mountComponent({
@@ -279,7 +279,7 @@ describe('TheScriptsView.vue', () => {
it('clears search query on close button click', async () => {
// arrange
const filterStub = new UserFilterStub();
const filterStub = new FilterContextStub();
const stateStub = new UseCollectionStateStub().withFilter(filterStub);
const wrapper = mountComponent({
useCollectionState: stateStub.get(),
@@ -296,14 +296,14 @@ describe('TheScriptsView.vue', () => {
// assert
expect(filterStub.callHistory).to.have.lengthOf(1);
expect(filterStub.callHistory).to.include(UserFilterMethod.ClearFilter);
expect(filterStub.callHistory.find((c) => c.methodName === 'clearFilter')).toBeDefined();
});
});
describe('no matches text', () => {
interface NoMatchesTextTestCase {
readonly name: string;
readonly filter: IFilterResult;
readonly filter: FilterResult;
readonly shouldNoMatchesExist: boolean;
}
const commonTestCases: readonly NoMatchesTextTestCase[] = [
@@ -322,7 +322,7 @@ describe('TheScriptsView.vue', () => {
];
describe('initial state', () => {
interface InitialStateTestCase extends Omit<NoMatchesTextTestCase, 'filter'> {
readonly filter?: IFilterResult;
readonly filter?: FilterResult;
}
const initialStateTestCases: readonly InitialStateTestCase[] = [
...commonTestCases,
@@ -355,7 +355,7 @@ describe('TheScriptsView.vue', () => {
it(name, async () => {
// arrange
const expected = shouldNoMatchesExist;
const filterStub = new UserFilterStub();
const filterStub = new FilterContextStub();
const stateStub = new UseCollectionStateStub()
.withFilter(filterStub);
const wrapper = mountComponent({
@@ -375,7 +375,7 @@ describe('TheScriptsView.vue', () => {
});
it('shows no text if filter is removed after matches', async () => {
// arrange
const filter = new UserFilterStub();
const filter = new FilterContextStub();
const stub = new UseCollectionStateStub()
.withFilter(filter);
const wrapper = mountComponent({

24
tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
View File

@@ -14,14 +14,14 @@ import { HierarchyAccessStub } from '@tests/unit/shared/Stubs/HierarchyAccessStu
import { IScript } from '@/domain/IScript';
import { ICategory } from '@/domain/ICategory';
import { TreeNode } from '@/presentation/components/Scripts/View/Tree/TreeView/Node/TreeNode';
import { UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import { CategoryCollectionStateStub } from '@tests/unit/shared/Stubs/CategoryCollectionStateStub';
import { NodeMetadataStub } from '@tests/unit/shared/Stubs/NodeMetadataStub';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
describe('UseTreeViewFilterEvent', () => {
describe('initially', () => {
@@ -45,8 +45,8 @@ describe('UseTreeViewFilterEvent', () => {
// arrange
const newFilter = filterChange;
const initialFilter = new FilterResultStub().withSomeMatches();
const filterStub = new UserFilterStub()
.withCurrentFilterResult(initialFilter);
const filterStub = new FilterContextStub()
.withCurrentFilter(initialFilter);
const stateStub = new UseCollectionStateStub()
.withFilter(filterStub);
const { returnObject } = mountWrapperComponent({ useStateStub: stateStub });
@@ -63,8 +63,8 @@ describe('UseTreeViewFilterEvent', () => {
// arrange
const newFilter = filterChange;
const initialFilter = new FilterResultStub().withSomeMatches();
const filterStub = new UserFilterStub()
.withCurrentFilterResult(initialFilter);
const filterStub = new FilterContextStub()
.withCurrentFilter(initialFilter);
const stateStub = new UseCollectionStateStub()
.withFilter(filterStub);
const { returnObject } = mountWrapperComponent({ useStateStub: stateStub });
@@ -90,7 +90,7 @@ describe('UseTreeViewFilterEvent', () => {
testFilterEvents((_, filterResult) => {
// arrange
const newCollection = new CategoryCollectionStateStub()
.withFilter(new UserFilterStub().withCurrentFilterResult(filterResult));
.withFilter(new FilterContextStub().withCurrentFilter(filterResult));
const initialCollection = new CategoryCollectionStateStub();
const useCollectionStateStub = new UseCollectionStateStub()
.withState(initialCollection);
@@ -113,9 +113,9 @@ describe('UseTreeViewFilterEvent', () => {
// arrange
const newFilter = filterChange;
const initialFilter = new FilterResultStub().withSomeMatches();
const filterStub = new UserFilterStub();
const filterStub = new FilterContextStub();
const newCollection = new CategoryCollectionStateStub()
.withFilter(filterStub.withCurrentFilterResult(initialFilter));
.withFilter(filterStub.withCurrentFilter(initialFilter));
const initialCollection = new CategoryCollectionStateStub();
const useCollectionStateStub = new UseCollectionStateStub()
.withState(initialCollection);
@@ -170,8 +170,8 @@ function mountWrapperComponent(options?: {
}
type FilterChangeTestScenario = (
result: IFilterChangeDetails,
filter: IFilterResult | undefined,
result: FilterChangeDetails,
filter: FilterResult | undefined,
) => Promise<{
readonly event: Ref<TreeViewFilterEvent | undefined>,
}>;

10
tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
View File

@@ -1,5 +1,4 @@
import { IApplicationCode } from '@/application/Context/State/Code/IApplicationCode';
import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { IScript } from '@/domain/IScript';
@@ -7,9 +6,10 @@ import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { UserSelection } from '@/application/Context/State/Selection/UserSelection';
import { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
import { CategoryCollectionStub } from './CategoryCollectionStub';
import { UserSelectionStub } from './UserSelectionStub';
import { UserFilterStub } from './UserFilterStub';
import { FilterContextStub } from './FilterContextStub';
import { ApplicationCodeStub } from './ApplicationCodeStub';
import { CategoryStub } from './CategoryStub';
import { ScriptSelectionStub } from './ScriptSelectionStub';
@@ -17,7 +17,7 @@ import { ScriptSelectionStub } from './ScriptSelectionStub';
export class CategoryCollectionStateStub implements ICategoryCollectionState {
public code: IApplicationCode = new ApplicationCodeStub();
public filter: IUserFilter = new UserFilterStub();
public filter: FilterContext = new FilterContextStub();
public get os(): OperatingSystem {
return this.collection.os;
@@ -55,7 +55,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
return this;
}
public withFilter(filter: IUserFilter): this {
public withFilter(filter: FilterContext): this {
this.filter = filter;
return this;
}
@@ -69,7 +69,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
);
}
public withSelection(selection: UserSelection) {
public withSelection(selection: UserSelection): this {
this.selection = selection;
return this;
}

7
tests/unit/shared/Stubs/CategoryStub.ts
View File

@@ -10,7 +10,7 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
public readonly scripts = new Array<IScript>();
public readonly docs = new Array<string>();
public docs: readonly string[] = new Array<string>();
private allScriptsRecursively: (readonly IScript[]) | undefined;
@@ -82,4 +82,9 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
this.name = categoryName;
return this;
}
public withDocs(docs: readonly string[]): this {
this.docs = docs;
return this;
}
}

10
tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
View File

@@ -1,9 +1,9 @@
import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
import { FilterAction, IFilterChangeDetails, IFilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import type { FilterAction, FilterChangeDetails, FilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
export class FilterChangeDetailsStub implements IFilterChangeDetails {
public static forApply(filter: IFilterResult) {
export class FilterChangeDetailsStub implements FilterChangeDetails {
public static forApply(filter: FilterResult) {
return new FilterChangeDetailsStub({
type: FilterActionType.Apply,
filter,
@@ -20,7 +20,7 @@ export class FilterChangeDetailsStub implements IFilterChangeDetails {
public readonly action: FilterAction,
) { /* Private constructor to enforce factory methods */ }
visit(visitor: IFilterChangeDetailsVisitor): void {
visit(visitor: FilterChangeDetailsVisitor): void {
if (this.action.type === FilterActionType.Apply) {
if (visitor.onApply) {
visitor.onApply(this.action.filter);

29
tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
View File

@@ -1,18 +1,21 @@
import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
import { IFilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import type { FilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export class FilterChangeDetailsVisitorStub implements IFilterChangeDetailsVisitor {
public readonly visitedEvents = new Array<FilterActionType>();
public readonly visitedResults = new Array<IFilterResult>();
onClear(): void {
this.visitedEvents.push(FilterActionType.Clear);
export class FilterChangeDetailsVisitorStub
extends StubWithObservableMethodCalls<Required<FilterChangeDetailsVisitor>>
implements FilterChangeDetailsVisitor {
public onClear(): void {
this.registerMethodCall({
methodName: 'onClear',
args: [],
});
}
onApply(filter: IFilterResult): void {
this.visitedEvents.push(FilterActionType.Apply);
this.visitedResults.push(filter);
public onApply(filter: FilterResult): void {
this.registerMethodCall({
methodName: 'onApply',
args: [filter],
});
}
}

55
tests/unit/shared/Stubs/FilterContextStub.ts Normal file
View File

@@ -0,0 +1,55 @@
import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
import { IEventSource } from '@/infrastructure/Events/IEventSource';
import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { FilterResultStub } from './FilterResultStub';
import { EventSourceStub } from './EventSourceStub';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export enum FilterMethod {
ApplyFilter,
ClearFilter,
}
export class FilterContextStub
extends StubWithObservableMethodCalls<FilterContext>
implements FilterContext {
private readonly filterChangedSource = new EventSourceStub<FilterChangeDetails>();
public currentFilter: FilterResult | undefined = new FilterResultStub();
public filterChanged: IEventSource<FilterChangeDetails> = this.filterChangedSource;
public notifyFilterChange(change: FilterChangeDetails): void {
this.filterChangedSource.notify(change);
if (change.action.type === FilterActionType.Apply) {
this.currentFilter = change.action.filter;
} else {
this.currentFilter = undefined;
}
}
public withNoCurrentFilter(): this {
return this.withCurrentFilter(undefined);
}
public withCurrentFilter(filter: FilterResult | undefined): this {
this.currentFilter = filter;
return this;
}
public applyFilter(...args: Parameters<FilterContext['applyFilter']>): void {
this.registerMethodCall({
methodName: 'applyFilter',
args: [...args],
});
}
public clearFilter(): void {
this.registerMethodCall({
methodName: 'clearFilter',
args: [],
});
}
}

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

@@ -1,10 +1,10 @@
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { ICategory } from '@/domain/ICategory';
import { IScript } from '@/domain/IScript';
import type { ICategory } from '@/domain/ICategory';
import type { IScript } from '@/domain/IScript';
import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { CategoryStub } from './CategoryStub';
import { ScriptStub } from './ScriptStub';
export class FilterResultStub implements IFilterResult {
export class FilterResultStub implements FilterResult {
public categoryMatches: readonly ICategory[] = [];
public scriptMatches: readonly IScript[] = [];

24
tests/unit/shared/Stubs/FilterStrategyStub.ts Normal file
View File

@@ -0,0 +1,24 @@
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { FilterStrategy } from '@/application/Context/State/Filter/Strategy/FilterStrategy';
import { ICategoryCollection } from '@/domain/ICategoryCollection';
import { FilterResultStub } from './FilterResultStub';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export class FilterStrategyStub
extends StubWithObservableMethodCalls<FilterStrategy>
implements FilterStrategy {
private predeterminedResult: FilterResult = new FilterResultStub();
public applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
this.registerMethodCall({
methodName: 'applyFilter',
args: [filter, collection],
});
return this.predeterminedResult;
}
public withApplyFilterResult(predeterminedResult: FilterResult): this {
this.predeterminedResult = predeterminedResult;
return this;
}
}

7
tests/unit/shared/Stubs/ScriptStub.ts
View File

@@ -12,7 +12,7 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
revert: `REM revert-code (${this.id})`,
};
public readonly docs = new Array<string>();
public docs: readonly string[] = new Array<string>();
public level? = RecommendationLevel.Standard;
@@ -60,6 +60,11 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
return this;
}
public withDocs(docs: readonly string[]): this {
this.docs = docs;
return this;
}
public toSelectedScript(): SelectedScriptStub {
return new SelectedScriptStub(this);
}

14
tests/unit/shared/Stubs/UseCollectionStateStub.ts
View File

@@ -4,12 +4,12 @@ import {
StateModifier, useCollectionState,
} from '@/presentation/components/Shared/Hooks/UseCollectionState';
import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
import { IApplicationContext } from '@/application/Context/IApplicationContext';
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
import { CategoryCollectionStateStub } from './CategoryCollectionStateStub';
import { ApplicationContextStub } from './ApplicationContextStub';
import { UserFilterStub } from './UserFilterStub';
import { FilterContextStub } from './FilterContextStub';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export class UseCollectionStateStub
@@ -20,7 +20,7 @@ export class UseCollectionStateStub
new CategoryCollectionStateStub(),
);
public withFilter(filter: IUserFilter) {
public withFilter(filter: FilterContext) {
const state = new CategoryCollectionStateStub()
.withFilter(filter);
const context = new ApplicationContextStub()
@@ -30,9 +30,9 @@ export class UseCollectionStateStub
.withContext(context);
}
public withFilterResult(filterResult: IFilterResult | undefined) {
const filter = new UserFilterStub()
.withCurrentFilterResult(filterResult);
public withFilterResult(filterResult: FilterResult | undefined) {
const filter = new FilterContextStub()
.withCurrentFilter(filterResult);
return this.withFilter(filter);
}

48
tests/unit/shared/Stubs/UserFilterStub.ts
View File

@@ -1,48 +0,0 @@
import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
import { IEventSource } from '@/infrastructure/Events/IEventSource';
import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
import { FilterResultStub } from './FilterResultStub';
import { EventSourceStub } from './EventSourceStub';
export enum UserFilterMethod {
ApplyFilter,
ClearFilter,
}
export class UserFilterStub implements IUserFilter {
private readonly filterChangedSource = new EventSourceStub<IFilterChangeDetails>();
public readonly callHistory = new Array<UserFilterMethod>();
public currentFilter: IFilterResult | undefined = new FilterResultStub();
public filterChanged: IEventSource<IFilterChangeDetails> = this.filterChangedSource;
public notifyFilterChange(change: IFilterChangeDetails) {
this.filterChangedSource.notify(change);
if (change.action.type === FilterActionType.Apply) {
this.currentFilter = change.action.filter;
} else {
this.currentFilter = undefined;
}
}
public withNoCurrentFilter() {
return this.withCurrentFilterResult(undefined);
}
public withCurrentFilterResult(filter: IFilterResult | undefined) {
this.currentFilter = filter;
return this;
}
public applyFilter(): void {
this.callHistory.push(UserFilterMethod.ApplyFilter);
}
public clearFilter(): void {
this.callHistory.push(UserFilterMethod.ClearFilter);
}
}