@schukai/monster 4.153.1 → 4.154.0

package/test/cases/data/pathfinder-resolution-baseline.mjs

@@ -0,0 +1,322 @@
+"use strict";
+
+import {expect} from "chai"
+import {Pathfinder} from "../../../source/data/pathfinder.mjs";
+
+/**
+ * Baseline for issue #576.
+ *
+ * getOption() is called about 1393 times across the library and resolves every
+ * option through Pathfinder, today by throwing and catching. Before that read
+ * path is replaced, this file freezes the resolution semantics that callers
+ * depend on. Every assertion here passes with the old implementation and must
+ * keep passing with the new one.
+ */
+describe('Pathfinder resolution baseline issue #576', function () {
+
+    class WithPrototypeMember {
+        constructor() {
+            this.own = 1;
+        }
+
+        inherited() {
+        }
+    }
+
+    function buildSubject() {
+        const nullProto = Object.create(null);
+        nullProto.leaf = 'from-null-proto';
+
+        return {
+            flat: 'value',
+            zero: 0,
+            emptyString: '',
+            falseValue: false,
+            nullValue: null,
+            undefinedValue: undefined,
+            nested: {
+                deep: {
+                    leaf: 'deep-leaf',
+                },
+                list: ['first', 'second', 'third'],
+                objects: [{id: 1}, {id: 2}],
+            },
+            map: new Map([['key', 'map-value'], ['nested', {leaf: 'map-leaf'}]]),
+            set: new Set(['set-first', 'set-second']),
+            instance: new WithPrototypeMember(),
+            nullProto,
+        };
+    }
+
+    describe('getVia() resolved values', function () {
+
+        [
+            ['flat', 'value'],
+            ['zero', 0],
+            ['emptyString', ''],
+            ['falseValue', false],
+            ['nullValue', null],
+            ['undefinedValue', undefined],
+            ['nested.deep.leaf', 'deep-leaf'],
+            ['nested.list.0', 'first'],
+            ['nested.list.2', 'third'],
+            ['nested.objects.1.id', 2],
+            ['map.key', 'map-value'],
+            ['map.nested.leaf', 'map-leaf'],
+            ['set.0', 'set-first'],
+            ['set.1', 'set-second'],
+            ['instance.own', 1],
+            ['nullProto.leaf', 'from-null-proto'],
+        ].forEach(function (data) {
+            const path = data[0];
+            const expected = data[1];
+
+            it(`getVia(${path}) should resolve to ${JSON.stringify(expected)}`, function () {
+                expect(new Pathfinder(buildSubject()).getVia(path)).to.equal(expected);
+            });
+        });
+
+        it('getVia() should resolve a prototype member', function () {
+            const value = new Pathfinder(buildSubject()).getVia('instance.inherited');
+            expect(typeof value).to.equal('function');
+        });
+
+        it('getVia() should return the root for an empty path', function () {
+            const subject = buildSubject();
+            expect(new Pathfinder(subject).getVia('')).to.equal(subject);
+            expect(new Pathfinder(subject).getVia([])).to.equal(subject);
+        });
+
+        it('getVia() should accept an array path and not mutate it', function () {
+            const path = ['nested', 'deep', 'leaf'];
+            expect(new Pathfinder(buildSubject()).getVia(path)).to.equal('deep-leaf');
+            expect(path).to.deep.equal(['nested', 'deep', 'leaf']);
+        });
+    });
+
+    describe('getVia() missing leaves resolve to undefined', function () {
+
+        [
+            'missing',
+            'nested.missing',
+            'nested.deep.missing',
+            'map.missing',
+        ].forEach(function (path) {
+            it(`getVia(${path}) should resolve to undefined`, function () {
+                expect(new Pathfinder(buildSubject()).getVia(path)).to.equal(undefined);
+            });
+        });
+    });
+
+    describe('getVia() throws past a non traversable value', function () {
+
+        [
+            'flat.deeper',
+            'zero.deeper',
+            'nested.deep.leaf.deeper',
+            'undefinedValue.deeper',
+            'nullValue.deeper',
+            'nested.list.0.deeper',
+        ].forEach(function (path) {
+            it(`getVia(${path}) should throw`, function () {
+                expect(() => new Pathfinder(buildSubject()).getVia(path)).to.throw();
+            });
+        });
+
+        it('should report that the journey is not at its end', function () {
+            expect(() => new Pathfinder(buildSubject()).getVia('flat.deeper'))
+                .to.throw(Error, 'the journey is not at its end');
+        });
+
+        it('should reject an index with trailing characters', function () {
+            expect(() => new Pathfinder(buildSubject()).getVia('nested.list.1suffix'))
+                .to.throw(TypeError, 'value is not an integer');
+            expect(() => new Pathfinder(buildSubject()).getVia('set.1suffix'))
+                .to.throw(TypeError, 'value is not an integer');
+        });
+
+        it('should reject unsupported weak collections', function () {
+            expect(() => new Pathfinder({weak: new WeakSet()}).getVia('weak.entry'))
+                .to.throw(Error, 'unsupported action for this data type (WeakSet)');
+        });
+
+        it('should reject a non string and non array path', function () {
+            expect(() => new Pathfinder(buildSubject()).getVia(42)).to.throw(Error);
+            expect(() => new Pathfinder(buildSubject()).getVia(undefined)).to.throw(Error);
+            expect(() => new Pathfinder(buildSubject()).getVia(null)).to.throw(Error);
+        });
+    });
+
+    describe('exists() membership semantics', function () {
+
+        [
+            ['flat', true],
+            ['zero', true],
+            ['emptyString', true],
+            ['falseValue', true],
+            ['nullValue', true],
+            ['undefinedValue', true],
+            ['missing', false],
+            ['nested.deep.leaf', true],
+            ['nested.deep.missing', false],
+            ['nested.missing.leaf', false],
+            ['nested.list.0', true],
+            ['nested.list.2', true],
+            ['nested.list.3', false],
+            ['nested.objects.1.id', true],
+            ['map.key', true],
+            ['map.missing', false],
+            ['set.0', true],
+            ['set.1', true],
+            ['set.2', false],
+            ['instance.own', true],
+            ['instance.inherited', true],
+            ['nullProto.leaf', true],
+            ['nullProto.missing', false],
+            ['flat.deeper', false],
+        ].forEach(function (data) {
+            const path = data[0];
+            const expected = data[1];
+
+            it(`exists(${path}) should be ${expected}`, function () {
+                expect(new Pathfinder(buildSubject()).exists(path)).to.equal(expected);
+            });
+        });
+
+        it('exists() should report a present key whose value is undefined', function () {
+            expect(new Pathfinder({a: {b: undefined}}).exists('a.b')).to.equal(true);
+            expect(new Pathfinder({a: {b: undefined}}).exists('a.c')).to.equal(false);
+        });
+
+        // load bearing: init-options-from-attributes.mjs and
+        // set-option-from-attribute.mjs call exists() with an undefined option
+        // name for every unknown data-monster-option-* attribute
+        it('exists() should return false instead of throwing for a malformed path', function () {
+            const pathfinder = new Pathfinder(buildSubject());
+
+            expect(pathfinder.exists(undefined)).to.equal(false);
+            expect(pathfinder.exists(null)).to.equal(false);
+            expect(pathfinder.exists(42)).to.equal(false);
+            expect(pathfinder.exists({})).to.equal(false);
+            expect(pathfinder.exists('nested.list.1suffix')).to.equal(false);
+        });
+
+        it('exists() should accept an array path', function () {
+            expect(new Pathfinder(buildSubject()).exists(['nested', 'deep', 'leaf'])).to.equal(true);
+            expect(new Pathfinder(buildSubject()).exists(['nested', 'deep', 'nope'])).to.equal(false);
+        });
+    });
+
+    describe('setVia() vivification', function () {
+
+        it('should build nested objects', function () {
+            const subject = {};
+            new Pathfinder(subject).setVia('a.b.c', true);
+            expect(JSON.stringify(subject)).to.equal('{"a":{"b":{"c":true}}}');
+        });
+
+        it('should build a sparse array for an integer segment', function () {
+            const subject = {};
+            new Pathfinder(subject).setVia('a.b.3.c', true);
+            expect(JSON.stringify(subject)).to.equal('{"a":{"b":[null,null,null,{"c":true}]}}');
+        });
+
+        it('should build nested arrays', function () {
+            const subject = {};
+            new Pathfinder(subject).setVia('a.b.0.0.c', true);
+            expect(JSON.stringify(subject)).to.equal('{"a":{"b":[[{"c":true}]]}}');
+        });
+
+        it('should add to a Set and ignore the key', function () {
+            const values = new Set(['first']);
+            new Pathfinder({values}).setVia('values.anything', 'second');
+            expect([...values]).to.deep.equal(['first', 'second']);
+        });
+
+        it('should write into a Map', function () {
+            const map = new Map();
+            new Pathfinder({map}).setVia('map.key', 'written');
+            expect(map.get('key')).to.equal('written');
+        });
+
+        it('should reject a WeakSet write explicitly', function () {
+            expect(() => new Pathfinder({values: new WeakSet()}).setVia('values.next', {}))
+                .to.throw(Error, 'unsupported action for this data type in setValueViaPath');
+        });
+
+        it('should reject unsafe mutation path segments', function () {
+            expect(() => new Pathfinder({}).setVia('__proto__.polluted', true)).to.throw(Error);
+            expect(() => new Pathfinder({}).setVia('constructor.prototype.polluted', true)).to.throw(Error);
+        });
+    });
+
+    describe('wildcard resolution', function () {
+
+        function wildcardSubject() {
+            return {
+                a: {
+                    b: {leaf: 1},
+                    c: {leaf: 2},
+                },
+                rows: [{value: 'x'}, {value: 'y'}],
+                map: new Map([['first', {leaf: 'm1'}], ['second', {leaf: 'm2'}]]),
+                set: new Set(['s1', 's2']),
+            };
+        }
+
+        it('should return a Map for a trailing wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('a.*');
+            expect(result).to.be.instanceOf(Map);
+            expect([...result.keys()]).to.deep.equal(['b', 'c']);
+        });
+
+        it('should resolve a path behind a wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('a.*.leaf');
+            expect(Array.from(result)).to.deep.equal([['b', 1], ['c', 2]]);
+        });
+
+        it('should enumerate array entries behind a wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('rows.*.value');
+            expect(Array.from(result)).to.deep.equal([['0', 'x'], ['1', 'y']]);
+        });
+
+        it('should enumerate Map values behind a wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('map.*.leaf');
+            expect(Array.from(result)).to.deep.equal([['first', 'm1'], ['second', 'm2']]);
+        });
+
+        it('should enumerate Set values behind a wildcard with stringified indices', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('set.*');
+            expect(Array.from(result)).to.deep.equal([['0', 's1'], ['1', 's2']]);
+        });
+
+        it('should support a leading wildcard', function () {
+            const result = new Pathfinder({a: {x: 1}, b: {x: 2}}).getVia('*.x');
+            expect(Array.from(result)).to.deep.equal([['a', 1], ['b', 2]]);
+        });
+
+        it('exists() should work through a wildcard', function () {
+            expect(new Pathfinder(wildcardSubject()).exists('a.*.leaf')).to.equal(true);
+        });
+    });
+
+    describe('deleteVia()', function () {
+
+        it('should delete an object key', function () {
+            const subject = {a: {b: 1, c: 2}};
+            new Pathfinder(subject).deleteVia('a.b');
+            expect(subject).to.deep.equal({a: {c: 2}});
+        });
+
+        it('should delete a Map entry', function () {
+            const map = new Map([['key', 1]]);
+            new Pathfinder({map}).deleteVia('map.key');
+            expect(map.has('key')).to.equal(false);
+        });
+
+        it('should reject deleting from a Set', function () {
+            expect(() => new Pathfinder({values: new Set(['a'])}).deleteVia('values.0'))
+                .to.throw(Error, 'unsupported action for this data type in deleteValueViaPath');
+        });
+    });
+});

package/test/cases/data/pathfinder.mjs

@@ -557,4 +557,133 @@ describe('Pathfinder', function () {
         });
 
     });
+
+    describe('undefined writes keep the key issue #574', function () {
+
+        // net: setVia() is a write, deleteVia() is the deletion API. Writing
+        // undefined must not delete, otherwise a default option declared as
+        // undefined would vanish and set-option-from-attribute would stop
+        // accepting later attribute changes for it.
+        it('setVia() should keep an existing object key when writing undefined', function () {
+            const subject = {a: {b: 1}};
+
+            new Pathfinder(subject).setVia('a.b', undefined);
+
+            expect(Object.hasOwn(subject.a, 'b')).to.be.true;
+            expect(subject.a.b).to.equal(undefined);
+        });
+
+        it('setVia() should create a key when writing undefined to a new path', function () {
+            const subject = {};
+
+            new Pathfinder(subject).setVia('a.b', undefined);
+
+            expect(Object.hasOwn(subject.a, 'b')).to.be.true;
+            expect(subject.a.b).to.equal(undefined);
+        });
+
+        it('exists() should report a key written as undefined', function () {
+            const subject = {a: {b: 1}};
+            const pathfinder = new Pathfinder(subject);
+
+            pathfinder.setVia('a.b', undefined);
+
+            expect(pathfinder.exists('a.b')).to.be.true;
+            expect(pathfinder.exists('a.c')).to.be.false;
+        });
+
+        it('deleteVia() should remove a key that was written as undefined', function () {
+            const subject = {a: {b: 1, c: 2}};
+            const pathfinder = new Pathfinder(subject);
+
+            pathfinder.setVia('a.b', undefined);
+            pathfinder.deleteVia('a.b');
+
+            expect(Object.hasOwn(subject.a, 'b')).to.be.false;
+            expect(subject.a).to.deep.equal({c: 2});
+        });
+
+        it('setVia() should keep an array slot when writing undefined', function () {
+            const subject = {a: [1, 2, 3]};
+
+            new Pathfinder(subject).setVia('a.1', undefined);
+
+            expect(subject.a.length).to.equal(3);
+            expect(Object.hasOwn(subject.a, '1')).to.be.true;
+            expect(subject.a[1]).to.equal(undefined);
+        });
+
+        it('deleteVia() should clear an array slot', function () {
+            const subject = {a: [1, 2, 3]};
+
+            new Pathfinder(subject).deleteVia('a.1');
+
+            expect(subject.a.length).to.equal(3);
+            expect(Object.hasOwn(subject.a, '1')).to.be.false;
+        });
+    });
+
+    describe('getVia default value issue #576', function () {
+
+        function subject() {
+            return {
+                data: {
+                    calculated: false,
+                    space: 0,
+                    label: '',
+                    button: {},
+                    list: [1, 2],
+                },
+            };
+        }
+
+        // net: without a second argument the throwing contract is unchanged
+        it('should keep throwing past a non traversable value when no default is given', function () {
+            expect(() => new Pathfinder(subject()).getVia('data.label.deeper'))
+                .to.throw(Error, 'the journey is not at its end');
+        });
+
+        it('should keep resolving a missing leaf to undefined when no default is given', function () {
+            expect(new Pathfinder(subject()).getVia('data.missing')).to.equal(undefined);
+        });
+
+        // regression: the second argument was accepted and silently ignored
+        it('should return the default instead of throwing past a non traversable value', function () {
+            expect(new Pathfinder(subject()).getVia('data.label.deeper', 'fallback')).to.equal('fallback');
+        });
+
+        it('should return the default for a missing mid path segment', function () {
+            expect(new Pathfinder(subject()).getVia('data.button.unseeded.width', 0)).to.equal(0);
+            expect(new Pathfinder(subject()).getVia('missing.deep.path', 'fallback')).to.equal('fallback');
+        });
+
+        it('should return the default for a missing leaf', function () {
+            expect(new Pathfinder(subject()).getVia('data.button.unseeded', 0)).to.equal(0);
+            expect(new Pathfinder(subject()).getVia('data.missing', 'fallback')).to.equal('fallback');
+        });
+
+        it('should return the default for a malformed path instead of throwing', function () {
+            expect(new Pathfinder(subject()).getVia(undefined, 'fallback')).to.equal('fallback');
+            expect(new Pathfinder(subject()).getVia('data.list.1suffix', 'fallback')).to.equal('fallback');
+        });
+
+        it('should return the resolved value and not the default when the path exists', function () {
+            expect(new Pathfinder(subject()).getVia('data.calculated', true)).to.equal(false);
+            expect(new Pathfinder(subject()).getVia('data.space', 99)).to.equal(0);
+            expect(new Pathfinder(subject()).getVia('data.label', 'fallback')).to.equal('');
+            expect(new Pathfinder(subject()).getVia('data.list.0', 99)).to.equal(1);
+        });
+
+        it('should return the default for a key whose value is undefined', function () {
+            expect(new Pathfinder({a: {b: undefined}}).getVia('a.b', 'fallback')).to.equal('fallback');
+        });
+
+        it('should return the default for a null prototype subject without a match', function () {
+            const nullProto = Object.create(null);
+            nullProto.leaf = 1;
+
+            expect(new Pathfinder({nullProto}).getVia('nullProto.leaf', 9)).to.equal(1);
+            expect(new Pathfinder({nullProto}).getVia('nullProto.missing', 9)).to.equal(9);
+        });
+    });
 });