From a72b51511c7ad654d6621739fec983ae3b6cf533 Mon Sep 17 00:00:00 2001 From: Daan Vanden Bosch Date: Sun, 27 Oct 2019 22:39:47 +0100 Subject: [PATCH] Added many unit tests to the observable module and fixed a bug. --- src/core/observable/Observable.test.ts | 118 +++++++++++++++ .../observable/property/FlatMappedProperty.ts | 9 +- src/core/observable/property/Property.test.ts | 139 ++++++++++++++++++ .../property/WritableProperty.test.ts | 46 ++++++ .../property/list/DependentListProperty.ts | 2 +- .../property/list/ListProperty.test.ts | 55 +++++++ .../property/list/SimpleListProperty.test.ts | 38 +++++ .../property/list/SimpleListProperty.ts | 2 +- 8 files changed, 403 insertions(+), 6 deletions(-) create mode 100644 src/core/observable/Observable.test.ts create mode 100644 src/core/observable/property/Property.test.ts create mode 100644 src/core/observable/property/WritableProperty.test.ts create mode 100644 src/core/observable/property/list/ListProperty.test.ts create mode 100644 src/core/observable/property/list/SimpleListProperty.test.ts diff --git a/src/core/observable/Observable.test.ts b/src/core/observable/Observable.test.ts new file mode 100644 index 00000000..e731543a --- /dev/null +++ b/src/core/observable/Observable.test.ts @@ -0,0 +1,118 @@ +import { ChangeEvent, Observable } from "./Observable"; +import { SimpleEmitter } from "./SimpleEmitter"; +import { SimpleProperty } from "./property/SimpleProperty"; +import { DependentProperty } from "./property/DependentProperty"; +import { list_property, property } from "./index"; +import { FlatMappedProperty } from "./property/FlatMappedProperty"; +import { SimpleListProperty } from "./property/list/SimpleListProperty"; +import { DependentListProperty } from "./property/list/DependentListProperty"; + +// This suite tests every implementation of Observable. + +function test_observable( + name: string, + create: () => { + observable: Observable; + emit: () => void; + }, +): void { + test(`${name} should call observers when events are emitted`, () => { + const { observable, emit } = create(); + const changes: ChangeEvent[] = []; + + observable.observe(c => { + changes.push(c); + }); + + emit(); + + expect(changes.length).toBe(1); + + emit(); + emit(); + emit(); + + expect(changes.length).toBe(4); + }); + + test(`${name} should not call observers after they are disposed`, () => { + const { observable, emit } = create(); + const changes: ChangeEvent[] = []; + + const observer = observable.observe(c => { + changes.push(c); + }); + + emit(); + + expect(changes.length).toBe(1); + + observer.dispose(); + + emit(); + emit(); + emit(); + + expect(changes.length).toBe(1); + }); +} + +test_observable(SimpleEmitter.name, () => { + const observable = new SimpleEmitter(); + return { + observable, + emit: () => observable.emit({ value: 1 }), + }; +}); + +test_observable(SimpleProperty.name, () => { + const observable = new SimpleProperty(1); + return { + observable, + emit: () => (observable.val += 1), + }; +}); + +test_observable(DependentProperty.name, () => { + const p = property(0); + const observable = new DependentProperty([p], () => 2 * p.val); + return { + observable, + emit: () => (p.val += 2), + }; +}); + +test_observable(`${FlatMappedProperty.name} (dependent property emits)`, () => { + const p = property({ x: property(5) }); + const observable = new FlatMappedProperty(p, v => v.x); + return { + observable, + emit: () => (p.val = { x: property(p.val.x.val + 5) }), + }; +}); + +test_observable(`${FlatMappedProperty.name} (nested property emits)`, () => { + const p = property({ x: property(5) }); + const observable = new FlatMappedProperty(p, v => v.x); + return { + observable, + emit: () => (p.val.x.val += 5), + }; +}); + +test_observable(SimpleListProperty.name, () => { + const observable = new SimpleListProperty(); + return { + observable, + emit: () => observable.push("test"), + }; +}); + +test_observable(DependentListProperty.name, () => { + const list = list_property(); + const observable = new DependentListProperty(list, x => x.map(v => 2 * v)); + return { + observable, + emit: () => list.push(10), + }; +}); diff --git a/src/core/observable/property/FlatMappedProperty.ts b/src/core/observable/property/FlatMappedProperty.ts index c1de50ab..803012cd 100644 --- a/src/core/observable/property/FlatMappedProperty.ts +++ b/src/core/observable/property/FlatMappedProperty.ts @@ -27,8 +27,11 @@ export class FlatMappedProperty extends AbstractMinimalProperty impleme super(); } - observe(observer: (event: PropertyChangeEvent) => void): Disposable { - const super_disposable = super.observe(observer); + observe( + observer: (event: PropertyChangeEvent) => void, + options?: { call_now?: boolean }, + ): Disposable { + const super_disposable = super.observe(observer, options); if (this.dependency_disposable == undefined) { this.dependency_disposable = this.dependency.observe(() => { @@ -40,8 +43,6 @@ export class FlatMappedProperty extends AbstractMinimalProperty impleme this.compute_and_observe(); } - this.emit(this.get_val()); - return { dispose: () => { super_disposable.dispose(); diff --git a/src/core/observable/property/Property.test.ts b/src/core/observable/property/Property.test.ts new file mode 100644 index 00000000..258bfbc8 --- /dev/null +++ b/src/core/observable/property/Property.test.ts @@ -0,0 +1,139 @@ +import { SimpleProperty } from "./SimpleProperty"; +import { DependentProperty } from "./DependentProperty"; +import { list_property } from "../index"; +import { FlatMappedProperty } from "./FlatMappedProperty"; +import { SimpleListProperty } from "./list/SimpleListProperty"; +import { DependentListProperty } from "./list/DependentListProperty"; +import { is_property, Property, PropertyChangeEvent } from "./Property"; +import { is_list_property } from "./list/ListProperty"; + +// This suite tests every implementation of Property. + +function test_property( + name: string, + create: () => { + property: Property; + emit: () => void; + }, +): void { + test(`${name} should be a property according to is_property`, () => { + const { property } = create(); + + expect(is_property(property)).toBe(true); + }); + + test(`${name} should call observers immediately if added with call_now set to true`, () => { + const { property } = create(); + const events: PropertyChangeEvent[] = []; + + property.observe(event => events.push(event), { call_now: true }); + + expect(events.length).toBe(1); + }); + + test(`${name} should propagate updates to mapped properties`, () => { + const { property, emit } = create(); + let i = 0; + const mapped = property.map(() => i++); + const events: PropertyChangeEvent[] = []; + + mapped.observe(event => events.push(event)); + + emit(); + + expect(events.length).toBe(1); + }); + + test(`${name} should propagate updates to flat mapped properties`, () => { + const { property, emit } = create(); + let i = 0; + const flat_mapped = property.flat_map(() => new SimpleProperty(i++)); + const events: PropertyChangeEvent[] = []; + + flat_mapped.observe(event => events.push(event)); + + emit(); + + expect(events.length).toBe(1); + }); + + test(`${name} should correctly set value and old_value in emitted PropertyChangeEvents`, () => { + const { property, emit } = create(); + + const events: PropertyChangeEvent[] = []; + + property.observe(event => events.push(event)); + + const initial_value = property.val; + + emit(); + + expect(events.length).toBe(1); + expect(events[0].value).toBe(property.val); + + if (!is_list_property(property)) { + expect(events[0].old_value).toBe(initial_value); + } + + emit(); + + expect(events.length).toBe(2); + expect(events[1].value).toBe(property.val); + + if (!is_list_property(property)) { + expect(events[1].old_value).toBe(events[0].value); + } + }); +} + +test_property(SimpleProperty.name, () => { + const property = new SimpleProperty(1); + return { + property, + emit: () => (property.val += 1), + }; +}); + +test_property(DependentProperty.name, () => { + const p = new SimpleProperty(0); + const property = new DependentProperty([p], () => 2 * p.val); + return { + property, + emit: () => (p.val += 2), + }; +}); + +test_property(`${FlatMappedProperty.name} (dependent property emits)`, () => { + const p = new SimpleProperty({ x: new SimpleProperty(5) }); + const property = new FlatMappedProperty(p, v => v.x); + return { + property, + emit: () => (p.val = { x: new SimpleProperty(p.val.x.val + 5) }), + }; +}); + +test_property(`${FlatMappedProperty.name} (nested property emits)`, () => { + const p = new SimpleProperty({ x: new SimpleProperty(5) }); + const property = new FlatMappedProperty(p, v => v.x); + return { + property, + emit: () => (p.val.x.val += 5), + }; +}); + +test_property(SimpleListProperty.name, () => { + const property = new SimpleListProperty(); + return { + property, + emit: () => property.push("test"), + }; +}); + +test_property(DependentListProperty.name, () => { + const list = list_property(); + const property = new DependentListProperty(list, x => x.map(v => 2 * v)); + return { + property, + emit: () => list.push(10), + }; +}); diff --git a/src/core/observable/property/WritableProperty.test.ts b/src/core/observable/property/WritableProperty.test.ts new file mode 100644 index 00000000..2903d520 --- /dev/null +++ b/src/core/observable/property/WritableProperty.test.ts @@ -0,0 +1,46 @@ +import { SimpleProperty } from "./SimpleProperty"; +import { SimpleListProperty } from "./list/SimpleListProperty"; +import { PropertyChangeEvent } from "./Property"; +import { WritableProperty } from "./WritableProperty"; + +// This suite tests every implementation of WritableProperty. + +function test_writable_property( + name: string, + create: () => { + property: WritableProperty; + emit: () => void; + create_val: () => T; + }, +): void { + test(`${name} should emit a PropertyChangeEvent when val is modified`, () => { + const { property, create_val } = create(); + const events: PropertyChangeEvent[] = []; + + property.observe(event => events.push(event)); + + const new_val = create_val(); + property.val = new_val; + + expect(events.length).toBe(1); + expect(events[0].value).toEqual(new_val); + }); +} + +test_writable_property(SimpleProperty.name, () => { + const property = new SimpleProperty(1); + return { + property, + emit: () => (property.val += 1), + create_val: () => property.val + 1, + }; +}); + +test_writable_property(SimpleListProperty.name, () => { + const property = new SimpleListProperty(); + return { + property, + emit: () => property.push("test"), + create_val: () => ["test"], + }; +}); diff --git a/src/core/observable/property/list/DependentListProperty.ts b/src/core/observable/property/list/DependentListProperty.ts index 303732af..5bc27402 100644 --- a/src/core/observable/property/list/DependentListProperty.ts +++ b/src/core/observable/property/list/DependentListProperty.ts @@ -3,7 +3,7 @@ import { PropertyChangeEvent } from "../Property"; import { Disposable } from "../../Disposable"; import { AbstractListProperty } from "./AbstractListProperty"; -export class DependentListProperty extends AbstractListProperty implements ListProperty { +export class DependentListProperty extends AbstractListProperty { private readonly dependency: ListProperty; private readonly transform: (values: readonly T[]) => T[]; private dependency_disposable?: Disposable; diff --git a/src/core/observable/property/list/ListProperty.test.ts b/src/core/observable/property/list/ListProperty.test.ts new file mode 100644 index 00000000..cc499a7c --- /dev/null +++ b/src/core/observable/property/list/ListProperty.test.ts @@ -0,0 +1,55 @@ +import { + is_list_property, + ListChangeType, + ListProperty, + ListPropertyChangeEvent, +} from "./ListProperty"; +import { SimpleListProperty } from "./SimpleListProperty"; +import { DependentListProperty } from "./DependentListProperty"; +import { list_property } from "../../index"; + +// This suite tests every implementation of ListProperty. + +function test_list_property( + name: string, + create: () => { + property: ListProperty; + emit_list_change: () => void; + }, +): void { + test(`${name} should be a list property according to is_list_property`, () => { + const { property } = create(); + + expect(is_list_property(property)).toBe(true); + }); + + test(`${name} should propagate list changes to a filtered list`, () => { + const { property, emit_list_change } = create(); + const filtered = property.filtered(() => true); + const events: ListPropertyChangeEvent[] = []; + + filtered.observe_list(event => events.push(event)); + + emit_list_change(); + + expect(events.length).toBe(1); + expect(events[0].type).toBe(ListChangeType.ListChange); + }); +} + +test_list_property(SimpleListProperty.name, () => { + const property = new SimpleListProperty(); + return { + property, + emit_list_change: () => property.push("test"), + }; +}); + +test_list_property(DependentListProperty.name, () => { + const list = list_property(); + const property = new DependentListProperty(list, x => x.map(v => 2 * v)); + return { + property, + emit_list_change: () => list.push(10), + }; +}); diff --git a/src/core/observable/property/list/SimpleListProperty.test.ts b/src/core/observable/property/list/SimpleListProperty.test.ts new file mode 100644 index 00000000..64e4097c --- /dev/null +++ b/src/core/observable/property/list/SimpleListProperty.test.ts @@ -0,0 +1,38 @@ +import { SimpleListProperty } from "./SimpleListProperty"; +import { ListChangeType, ListPropertyChangeEvent } from "./ListProperty"; + +test("constructor", () => { + const list = new SimpleListProperty(undefined, 1, 2, 3); + + expect(list.val).toEqual([1, 2, 3]); + expect(list.length.val).toBe(3); +}); + +test("push", () => { + const changes: ListPropertyChangeEvent[] = []; + const list = new SimpleListProperty(); + + list.observe_list(change => changes.push(change)); + + list.push(9); + + expect(list.val).toEqual([9]); + expect(changes.length).toBe(1); + expect(changes[0]).toEqual({ + type: ListChangeType.ListChange, + index: 0, + removed: [], + inserted: [9], + }); + + list.push(1, 2, 3); + + expect(list.val).toEqual([9, 1, 2, 3]); + expect(changes.length).toBe(2); + expect(changes[1]).toEqual({ + type: ListChangeType.ListChange, + index: 1, + removed: [], + inserted: [1, 2, 3], + }); +}); diff --git a/src/core/observable/property/list/SimpleListProperty.ts b/src/core/observable/property/list/SimpleListProperty.ts index 5a00cb44..3e26ad5c 100644 --- a/src/core/observable/property/list/SimpleListProperty.ts +++ b/src/core/observable/property/list/SimpleListProperty.ts @@ -20,7 +20,7 @@ export class SimpleListProperty extends AbstractListProperty /** * @param extract_observables - Extractor function called on each value in this list. Changes - * to the returned observables will be propagated via update events. + * to the returned observables will be propagated via ValueChange events. * @param values - Initial values of this list. */ constructor(extract_observables?: (element: T) => Observable[], ...values: T[]) {