neo.mjs 10.0.0-beta.4 → 10.0.0-beta.6

package/test/siesta/tests/config/CircularDependencies.mjs

@@ -0,0 +1,166 @@
+import Neo       from '../../../../src/Neo.mjs';
+import * as core from '../../../../src/core/_export.mjs';
+
+class TestComponent extends core.Base {
+    static config = {
+        className  : 'Neo.Test.CircularDependenciesComponent',
+        configA_   : 'initialA',
+        configB_   : 'initialB',
+        configC_   : 'initialC',
+        nonReactive: 'initialNonReactive'
+    }
+
+    classField = 'initialClassField';
+
+    _customProp = 'initialCustomProp'; // Private backing field for customProp
+
+    // Custom getter/setter for a property not defined in static config
+    get customProp() {
+        return this._customProp;
+    }
+    set customProp(value) {
+        this._customProp = value;
+
+        // Simulate interaction with other properties
+        this.customPropSetLog.push({
+            value,
+            currentConfigA    : this.configA,
+            currentNonReactive: this.nonReactive,
+            currentClassField : this.classField
+        });
+    }
+
+    // To record the state inside afterSet hooks and customProp setter
+    afterSetLogs = {
+        configA: [],
+        configB: [],
+        configC: []
+    };
+    customPropSetLog = [];
+
+    afterSetConfigA(newValue, oldValue) {
+        this.afterSetLogs.configA.push({
+            newValue,
+            oldValue,
+            currentConfigB    : this.configB,
+            currentConfigC    : this.configC,
+            currentClassField : this.classField,
+            currentNonReactive: this.nonReactive,
+            currentCustomProp : this.customProp
+        });
+    }
+
+    afterSetConfigB(newValue, oldValue) {
+        this.afterSetLogs.configB.push({
+            newValue,
+            oldValue,
+            currentConfigA    : this.configA,
+            currentConfigC    : this.configC,
+            currentClassField : this.classField,
+            currentNonReactive: this.nonReactive,
+            currentCustomProp : this.customProp
+        });
+    }
+
+    afterSetConfigC(newValue, oldValue) {
+        this.afterSetLogs.configC.push({
+            newValue,
+            oldValue,
+            currentConfigA    : this.configA,
+            currentConfigB    : this.configB,
+            currentClassField : this.classField,
+            currentNonReactive: this.nonReactive,
+            currentCustomProp : this.customProp
+        });
+    }
+}
+Neo.setupClass(TestComponent);
+
+StartTest(t => {
+    t.it('afterSet hooks should see latest values of other configs and fields during simultaneous update', t => {
+        const instance = Neo.create(TestComponent);
+        instance.afterSetLogs = { configA: [], configB: [], configC: [] }; // Clear logs from initial config processing
+        instance.customPropSetLog = []; // Clear customProp logs
+
+        instance.set({
+            configA    : 'newA',
+            configB    : 'newB',
+            configC    : 'newC',
+            nonReactive: 'newNonReactive',
+            classField : 'newClassField',
+            customProp : 'newCustomProp'
+        });
+
+        // Verify afterSetConfigA log
+        t.is(instance.afterSetLogs.configA.length, 1, 'afterSetConfigA should be called once');
+        const logA = instance.afterSetLogs.configA[0];
+        t.is(logA.newValue,           'newA',           'logA: newValue is correct');
+        t.is(logA.oldValue,           'initialA',       'logA: oldValue is correct');
+        t.is(logA.currentConfigB,     'newB',           'logA: currentConfigB should be newB');
+        t.is(logA.currentConfigC,     'newC',           'logA: currentConfigC should be newC');
+        t.is(logA.currentClassField,  'newClassField',  'logA: currentClassField should be newClassField');
+        t.is(logA.currentNonReactive, 'newNonReactive', 'logA: currentNonReactive should be newNonReactive');
+        t.is(logA.currentCustomProp,  'newCustomProp',  'logA: currentCustomProp should be newCustomProp');
+
+        // Verify afterSetConfigB log
+        t.is(instance.afterSetLogs.configB.length, 1, 'afterSetConfigB should be called once');
+        const logB = instance.afterSetLogs.configB[0];
+        t.is(logB.newValue,           'newB',           'logB: newValue is correct');
+        t.is(logB.oldValue,           'initialB',       'logB: oldValue is correct');
+        t.is(logB.currentConfigA,     'newA',           'logB: currentConfigA should be newA');
+        t.is(logB.currentConfigC,     'newC',           'logB: currentConfigC should be newC');
+        t.is(logB.currentClassField,  'newClassField',  'logB: currentClassField should be newClassField');
+        t.is(logB.currentNonReactive, 'newNonReactive', 'logB: currentNonReactive should be newNonReactive');
+        t.is(logB.currentCustomProp,  'newCustomProp',  'logB: currentCustomProp should be newCustomProp');
+
+        // Verify afterSetConfigC log
+        t.is(instance.afterSetLogs.configC.length, 1, 'afterSetConfigC should be called once');
+        const logC = instance.afterSetLogs.configC[0];
+        t.is(logC.newValue,           'newC',           'logC: newValue is correct');
+        t.is(logC.oldValue,           'initialC',       'logC: oldValue is correct');
+        t.is(logC.currentConfigA,     'newA',           'logC: currentConfigA should be newA');
+        t.is(logC.currentConfigB,     'newB',           'logC: currentConfigB should be newB');
+        t.is(logC.currentClassField,  'newClassField',  'logC: currentClassField should be newClassField');
+        t.is(logC.currentNonReactive, 'newNonReactive', 'logC: currentNonReactive should be newNonReactive');
+        t.is(logC.currentCustomProp,  'newCustomProp',  'logC: currentCustomProp should be newCustomProp');
+
+        // Verify customProp setter log
+        t.is(instance.customPropSetLog.length, 1, 'customProp setter should be called once');
+        const customPropLog = instance.customPropSetLog[0];
+        t.is(customPropLog.value,              'newCustomProp',  'customProp setter: value is correct');
+        t.is(customPropLog.currentConfigA,     'newA',           'customProp setter: currentConfigA should be newA');
+        t.is(customPropLog.currentNonReactive, 'newNonReactive', 'customProp setter: currentNonReactive should be newNonReactive');
+        t.is(customPropLog.currentClassField,  'newClassField',  'customProp setter: currentClassField should be newClassField');
+    });
+
+    t.it('afterSet hooks should see existing values if not part of current set() operation', t => {
+        const instance = Neo.create(TestComponent, {
+            configA    : 'preSetA',
+            configB    : 'preSetB',
+            configC    : 'preSetC',
+            nonReactive: 'preSetNonReactive',
+            classField : 'preSetClassField',
+            customProp : 'preSetCustomProp'
+        });
+        instance.afterSetLogs = { configA: [], configB: [], configC: [] }; // Reset logs
+        instance.customPropSetLog = []; // Reset customProp logs
+
+        instance.set({
+            configA: 'newAOnly'
+        });
+
+        t.is(instance.afterSetLogs.configA.length, 1, 'afterSetConfigA should be called once');
+        const logA = instance.afterSetLogs.configA[0];
+        t.is(logA.newValue,           'newAOnly',          'logA: newValue is correct');
+        t.is(logA.oldValue,           'preSetA',           'logA: oldValue is correct');
+        t.is(logA.currentConfigB,     'preSetB',           'logA: currentConfigB should be preSetB');
+        t.is(logA.currentConfigC,     'preSetC',           'logA: currentConfigC should be preSetC');
+        t.is(logA.currentClassField,  'preSetClassField',  'logA: currentClassField should be preSetClassField');
+        t.is(logA.currentNonReactive, 'preSetNonReactive', 'logA: currentNonReactive should be preSetNonReactive');
+        t.is(logA.currentCustomProp,  'preSetCustomProp',  'logA: currentCustomProp should be preSetCustomProp');
+
+        t.is(instance.afterSetLogs.configB.length, 0, 'afterSetConfigB should not be called');
+        t.is(instance.afterSetLogs.configC.length, 0, 'afterSetConfigC should not be called');
+        t.is(instance.customPropSetLog.length,     0, 'customProp setter should not be called');
+    });
+});

package/test/siesta/tests/config/CustomFunctions.mjs

@@ -0,0 +1,69 @@
+import Neo            from '../../../../src/Neo.mjs';
+import * as core      from '../../../../src/core/_export.mjs';
+import {isDescriptor} from '../../../../src/core/ConfigSymbols.mjs';
+
+class TestComponent extends core.Base {
+    static config = {
+        className    : 'Neo.Test.CustomFunctionsComponent',
+        arrayConfig_ : {
+            [isDescriptor]: true,
+            value         : [1, 2],
+            // NOTE: The custom merge function is called during two distinct phases:
+            // 1. During Neo.setupClass(): To merge the static config down the inheritance chain.
+            //    At this stage, `defaultValue` will be `undefined` if the config is defined for the
+            //    first time in this class. The function must handle this case.
+            // 2. During Neo.create(): To merge an instance-specific value into the class's final
+            //    static default value.
+            merge         : (defaultValue, instanceValue) => {
+                // Custom merge: concatenate arrays. Handle the initial undefined case.
+                return (defaultValue || []).concat(instanceValue);
+            }
+        },
+        objectConfig_: {
+            [isDescriptor]: true,
+            value         : {id: 1, data: 'initial'},
+            isEqual       : (a, b) => {
+                // Custom isEqual: compare by id property
+                return a?.id === b?.id;
+            }
+        }
+    }
+}
+Neo.setupClass(TestComponent);
+
+StartTest(t => {
+    t.it('Custom "merge" function for array concatenation', t => {
+        const instance = Neo.create(TestComponent, {
+            arrayConfig: [3, 4]
+        });
+
+        // The custom merge function should concatenate the static default value [1, 2]
+        // with the instance value [3, 4]
+        t.isDeeplyStrict(instance.arrayConfig, [1, 2, 3, 4], 'Custom merge function should concatenate arrays');
+    });
+
+    t.it('Custom "isEqual" function for object comparison by id', t => {
+        const instance = Neo.create(TestComponent);
+
+        let subscriberCalled = 0;
+        instance.observeConfig(instance, 'objectConfig', () => {
+            subscriberCalled++;
+        });
+
+        t.is(instance.objectConfig.data, 'initial', 'Initial object data is correct');
+
+        // Set a new object with the SAME id. The custom isEqual should return true.
+        instance.objectConfig = {id: 1, data: 'updated'};
+
+        t.is(subscriberCalled, 0, 'Subscriber should NOT be called when id is the same');
+        // The value should NOT have been updated because isEqual returned true
+        t.is(instance.objectConfig.data, 'initial', 'Object data should not change when id is the same');
+
+
+        // Set a new object with a DIFFERENT id. The custom isEqual should return false.
+        instance.objectConfig = {id: 2, data: 'new object'};
+
+        t.is(subscriberCalled, 1, 'Subscriber should be called when id is different');
+        t.is(instance.objectConfig.data, 'new object', 'Object data should update when id is different');
+    });
+});

package/test/siesta/tests/config/Hierarchy.mjs

@@ -0,0 +1,94 @@
+import Neo            from '../../../../src/Neo.mjs';
+import * as core      from '../../../../src/core/_export.mjs';
+import {isDescriptor} from '../../../../src/core/ConfigSymbols.mjs';
+
+// Base Class
+class BaseComponent extends core.Base {
+    static config = {
+        className    : 'Neo.Test.BaseComponent',
+        myConfig_    : 'baseValue',
+        arrayConfig_ : {
+            [isDescriptor]: true,
+            value         : [1, 2],
+            merge         : 'replace'
+        },
+        objectConfig_: {
+            [isDescriptor]: true,
+            value         : {a: 1, b: {c: 2}},
+            merge         : 'deep'
+        }
+    }
+}
+Neo.setupClass(BaseComponent);
+
+// Derived Class
+class DerivedComponent extends BaseComponent {
+    static config = {
+        className   : 'Neo.Test.DerivedComponent',
+        myConfig    : 'derivedValue',
+        arrayConfig : [3, 4], // Override with a new array
+        objectConfig: {b: {c: 3, d: 4}, e: 5} // Override with a partial object for deep merge
+    }
+}
+Neo.setupClass(DerivedComponent);
+
+
+StartTest(t => {
+    t.it('Initial values for DerivedComponent instance', t => {
+        const instance = Neo.create(DerivedComponent);
+
+        t.is(instance.myConfig, 'derivedValue', 'myConfig should be the value from the derived class');
+
+        // Test 'replace' merge strategy for arrayConfig
+        t.isDeeplyStrict(instance.arrayConfig, [3, 4], 'arrayConfig should be replaced by the derived class value');
+
+        // Test 'deep' merge strategy for objectConfig
+        const expectedObject = {
+            a: 1,       // from BaseComponent
+            b: {c: 3, d: 4}, // from DerivedComponent (b.c is overwritten, b.d is added)
+            e: 5        // from DerivedComponent
+        };
+        t.isDeeplyStrict(instance.objectConfig, expectedObject, 'objectConfig should be a deep merge of base and derived values');
+    });
+
+    t.it('Reactivity on DerivedComponent instance', t => {
+        const instance = Neo.create(DerivedComponent);
+
+        let subscriberCalled = false;
+        let receivedNewValue, receivedOldValue;
+
+        const cleanup = instance.observeConfig(instance, 'myConfig', (newValue, oldValue) => { // Discouraged: Self-observation
+            subscriberCalled = true;
+            receivedNewValue = newValue;
+            receivedOldValue = oldValue;
+        });
+
+        instance.myConfig = 'newValue';
+
+        t.ok(subscriberCalled, 'Subscriber callback should be called');
+        t.is(receivedNewValue, 'newValue', 'New value should be passed to subscriber');
+        t.is(receivedOldValue, 'derivedValue', 'Old value should be the initial value from the derived class');
+
+        cleanup();
+    });
+
+    t.it('Instance-level config overrides derived defaults', t => {
+        const instance = Neo.create(DerivedComponent, {
+            myConfig    : 'instanceValue',
+            arrayConfig : [5, 6],
+            objectConfig: {b: {c: 99}, g: 7}
+        });
+
+        t.is(instance.myConfig, 'instanceValue', 'myConfig should be the value from the instance config');
+        t.isDeeplyStrict(instance.arrayConfig, [5, 6], 'arrayConfig should be replaced by the instance config value');
+
+        const expectedObject = {
+            a: 1,             // from BaseComponent
+            b: {c: 99, d: 4}, // b.c from instance, b.d from DerivedComponent
+            e: 5,             // from DerivedComponent
+            g: 7              // from instance
+        };
+
+        t.isDeeplyStrict(instance.objectConfig, expectedObject, 'objectConfig from instance should be deep-merged into the class default');
+    });
+});

package/test/siesta/tests/config/MemoryLeak.mjs

@@ -0,0 +1,92 @@
+import Neo       from '../../../../src/Neo.mjs';
+import * as core from '../../../../src/core/_export.mjs';
+
+class PublisherComponent extends core.Base {
+    static config = {
+        className: 'PublisherComponent',
+        myConfig_: 'initialValue'
+    }
+}
+
+class LeakySubscriberComponent extends core.Base {
+    static config = {
+        className: 'LeakySubscriberComponent'
+    }
+
+    // A flag to check if the subscriber was called
+    subscriberCalled = false; // This will be updated via sharedState
+
+    // A method to subscribe to a publisher's config
+    subscribeToPublisher(publisherInstance, sharedStateRef) {
+        this.cleanupFn = this.observeConfig(publisherInstance, 'myConfig', (newValue, oldValue) => {
+            sharedStateRef.subscriberCalled = true;
+        });
+    }
+}
+
+PublisherComponent = Neo.setupClass(PublisherComponent);
+LeakySubscriberComponent = Neo.setupClass(LeakySubscriberComponent);
+
+StartTest(t => {
+    t.it('Memory leak scenario: destroyed subscriber without cleanup', t => {
+        const sharedState = { subscriberCalled: false };
+        const publisher = Neo.create(PublisherComponent);
+        let subscriber = Neo.create(LeakySubscriberComponent);
+
+        subscriber.subscribeToPublisher(publisher, sharedState);
+
+        // Destroy the subscriber instance without calling cleanupFn
+        subscriber.destroy();
+        subscriber = null; // Nullify reference to help GC, though subscription still exists
+
+        // Change the publisher's config value
+        // This should trigger the subscriber's callback if the leak exists
+        publisher.myConfig = 'newValueAfterSubscriberDestroyed';
+
+        // Assert that the subscriber's callback was NOT called due to automatic cleanup
+        t.notOk(sharedState.subscriberCalled, 'Leaked subscriber callback should NOT be called due to automatic cleanup');
+
+        // The observeConfig method now handles automatic cleanup, so no manual cleanup is needed here.
+        publisher.destroy();
+    });
+
+    t.it('No memory leak scenario: destroyed subscriber with cleanup', t => {
+        const sharedStateClean = { subscriberCalled: false };
+        const publisherClean = Neo.create(PublisherComponent);
+        let subscriberClean = Neo.create(LeakySubscriberComponent);
+
+        subscriberClean.subscribeToPublisher(publisherClean, sharedStateClean);
+
+        // Explicitly call cleanup before destroying
+        subscriberClean.destroy();
+        subscriberClean = null;
+
+        publisherClean.myConfig = 'noLeakTrigger';
+
+        t.notOk(sharedStateClean.subscriberCalled, 'Subscriber callback should NOT be called after cleanup');
+        publisherClean.destroy(); // Clean up publisher
+    });
+
+    t.it('Manual unsubscribe before destruction', t => {
+        const sharedStateManual = { subscriberCalled: false };
+        const publisherManual = Neo.create(PublisherComponent);
+        let subscriberManual = Neo.create(LeakySubscriberComponent);
+
+        const cleanupManual = subscriberManual.observeConfig(publisherManual, 'myConfig', (newValue, oldValue) => {
+            sharedStateManual.subscriberCalled = true;
+        });
+
+        // Manually unsubscribe
+        cleanupManual();
+
+        // Change the publisher's config value
+        publisherManual.myConfig = 'valueAfterManualUnsubscribe';
+
+        // Assert that the subscriber's callback was NOT called
+        t.notOk(sharedStateManual.subscriberCalled, 'Subscriber callback should NOT be called after manual unsubscribe');
+
+        // Destroy instances to ensure full cleanup
+        subscriberManual.destroy();
+        publisherManual.destroy();
+    });
+});

package/test/siesta/tests/config/MultiLevelHierarchy.mjs

@@ -0,0 +1,85 @@
+import Neo            from '../../../../src/Neo.mjs';
+import * as core      from '../../../../src/core/_export.mjs';
+import {isDescriptor} from '../../../../src/core/ConfigSymbols.mjs';
+
+// Level 1
+class BaseComponent extends core.Base {
+    static config = {
+        className    : 'Neo.Test.MultiLevel.BaseComponent',
+        myConfig_    : 'baseValue',
+        arrayConfig_ : {
+            [isDescriptor]: true,
+            value         : [1, 2],
+            merge         : 'replace'
+        },
+        objectConfig_: {
+            [isDescriptor]: true,
+            value         : {a: 1, b: {c: 2}},
+            merge         : 'deep'
+        }
+    }
+}
+Neo.setupClass(BaseComponent);
+
+// Level 2
+class MidLevelComponent extends BaseComponent {
+    static config = {
+        className   : 'Neo.Test.MultiLevel.MidLevelComponent',
+        arrayConfig : [3, 4],
+        objectConfig: {b: {c: 3, d: 4}, e: 5}
+    }
+}
+Neo.setupClass(MidLevelComponent);
+
+// Level 3
+class TopLevelComponent extends MidLevelComponent {
+    static config = {
+        className   : 'Neo.Test.MultiLevel.TopLevelComponent',
+        myConfig    : 'topValue',
+        objectConfig: {b: {d: 99}, f: 6} // Override again
+    }
+}
+Neo.setupClass(TopLevelComponent);
+
+
+StartTest(t => {
+    t.it('Initial values for a three-level hierarchy instance', t => {
+        const instance = Neo.create(TopLevelComponent);
+
+        // myConfig is defined in Base, overridden in Top (Mid doesn't touch it)
+        t.is(instance.myConfig, 'topValue', 'myConfig should be the value from the top-level class');
+
+        // arrayConfig is defined in Base, overridden in Mid (Top doesn't touch it)
+        t.isDeeplyStrict(instance.arrayConfig, [3, 4], 'arrayConfig should be replaced by the mid-level class value');
+
+        // objectConfig is defined in Base, merged in Mid, and merged again in Top
+        const expectedObject = {
+            a: 1,             // from Base
+            b: {c: 3, d: 99}, // c from Mid, d from Top
+            e: 5,             // from Mid
+            f: 6              // from Top
+        };
+        t.isDeeplyStrict(instance.objectConfig, expectedObject, 'objectConfig should be a deep merge of all three levels');
+    });
+
+    t.it('Instance-level config overrides on a three-level hierarchy', t => {
+        const instance = Neo.create(TopLevelComponent, {
+            myConfig    : 'instanceValue',
+            arrayConfig : [10, 11],
+            objectConfig: {a: 100, b: {c: 101}, g: 102}
+        });
+
+        t.is(instance.myConfig, 'instanceValue', 'myConfig should be the value from the instance config');
+        t.isDeeplyStrict(instance.arrayConfig, [10, 11], 'arrayConfig should be replaced by the instance config value');
+
+        const expectedObject = {
+            a: 100,             // from instance
+            b: {c: 101, d: 99}, // c from instance, d from Top
+            e: 5,               // from Mid
+            f: 6,               // from Top
+            g: 102              // from instance
+        };
+
+        t.isDeeplyStrict(instance.objectConfig, expectedObject, 'objectConfig from instance should be deep-merged into the class hierarchy defaults');
+    });
+});

package/test/siesta/tests/core/Effect.mjs

@@ -0,0 +1,127 @@
+import Neo           from '../../../../src/Neo.mjs';
+import * as core     from '../../../../src/core/_export.mjs';
+import Effect        from '../../../../src/core/Effect.mjs';
+import EffectManager from '../../../../src/core/EffectManager.mjs';
+import Config        from '../../../../src/core/Config.mjs';
+
+StartTest(t => {
+    t.it('EffectManager should manage active effects', t => {
+        const effect1 = new Effect(() => {});
+        const effect2 = new Effect(() => {});
+
+        t.is(EffectManager.getActiveEffect(), null, 'No active effect initially');
+
+        EffectManager.push(effect1);
+        t.is(EffectManager.getActiveEffect(), effect1, 'Effect1 is active');
+
+        EffectManager.push(effect2);
+        t.is(EffectManager.getActiveEffect(), effect2, 'Effect2 is active');
+
+        EffectManager.pop();
+        t.is(EffectManager.getActiveEffect(), effect1, 'Effect1 is active after pop');
+
+        EffectManager.pop();
+        t.is(EffectManager.getActiveEffect(), null, 'No active effect after all pops');
+
+        effect1.destroy();
+        effect2.destroy();
+    });
+
+    t.it('Effect should run its function and track dependencies', t => {
+        let runCount = 0;
+        let sum      = 0;
+        const configA = new Config(1);
+        const configB = new Config(10);
+
+        // Identity check
+        t.is(configA,    configA, 'configA is strictly equal to itself');
+        t.is(configB,    configB, 'configB is strictly equal to itself');
+        t.isNot(configA, configB, 'configA is not strictly equal to configB');
+
+        const effect = new Effect(() => {
+            runCount++;
+            // Access configs to register them as dependencies
+            sum = configA.get() + configB.get();
+            t.pass(`Effect ran. Sum: ${sum}`);
+        });
+
+        t.is(runCount,                  1, 'Effect function ran once on creation');
+        t.is(effect.dependencies.size,  2, 'Effect tracked 2 dependencies');
+        t.is(sum,                      11, 'Effect function ran with correct sum: 1 + 10 = 11');
+
+        // Change a dependency, effect should re-run
+        configA.set(2);
+        t.is(runCount,  2, 'Effect function ran again after configA change');
+        t.is(sum,      12, 'Effect function ran with correct sum: 2 + 10 = 12');
+
+        // Change another dependency, effect should re-run
+        configB.set(20);
+        t.is(runCount,  3, 'Effect function ran again after configB change');
+        t.is(sum,      22, 'Effect function ran with correct sum: 2 + 20 = 22');
+
+        // Change a dependency to the same value, effect should not re-run (Config handles this)
+        configA.set(2);
+        t.is(runCount,  3, 'Effect function did not run after no-change configA update');
+        t.is(sum,      22, 'Effect function ran with correct sum: 2 + 20 = 22');
+
+        effect.destroy();
+        t.is(effect.isDestroyed,       true, 'Effect is destroyed');
+        t.is(effect.dependencies.size, 0,    'Effect dependencies cleared after destroy');
+
+        // Changing config after effect is destroyed should not re-run effect
+        configA.set(3);
+        t.is(runCount,  3, 'Effect function did not run after configA change when destroyed');
+        t.is(sum,      22, 'Effect function ran with correct sum: 2 + 20 = 22');
+    });
+
+    t.it('Effect should clean up old dependencies on re-run', t => {
+        let runCount = 0;
+        const configX = new Config('X');
+        const configY = new Config('Y');
+
+        // Initial effect: depends on configX
+        const effect = new Effect(() => {
+            runCount++;
+            t.is(configX.get(), 'X', 'Effect ran (1st): configX value');
+        });
+
+        t.is(runCount,                 1, 'Effect ran once initially');
+        t.is(effect.dependencies.size, 1, 'Effect has 1 dependency (configX)');
+
+        // --- Transition to configY dependency ---
+        // Reassign the effect's function to depend on configY
+        effect.fn = () => {
+            runCount++;
+
+            if (runCount === 2) {
+                t.is(configY.get(), 'Y', 'Effect ran (2nd): configY value');
+            }
+
+            if (runCount === 3) {
+                t.is(configY.get(), 'Y_new', 'Effect ran (3rd): configY value');
+            }
+
+            else if (runCount === 4) {
+                t.is(configY.get(), 'Y_final', 'Effect ran (4th): configY value');
+            }
+        };
+
+        t.is(runCount, 2, 'Effect ran a second time after fn reassignment');
+
+        // Changing the config value will trigger a re-run.
+        configY.set('Y_new');
+
+        t.is(runCount,                 3, 'Effect ran a second time after fn reassignment');
+        t.is(effect.dependencies.size, 1, 'Effect now has 1 dependency (configY)');
+
+        // Change configX: should NOT trigger the effect (old dependency cleaned up)
+        configX.set('X_new');
+        t.is(runCount, 3, 'Effect did not re-run after old dependency (configX) changed');
+
+        // Change configY: should trigger the effect (new dependency)
+        configY.set('Y_final'); // This will trigger runCount to become 3
+        t.is(runCount, 4, 'Effect re-ran after new dependency (configY) changed');
+
+        effect.destroy();
+    });
+});