@safeaccess/inline 0.1.1 → 0.1.3

package/tests/cache/simple-path-cache.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+import { SimplePathCache } from '../../src/cache/simple-path-cache.js';
+import { SegmentType } from '../../src/path-query/segment-type.js';
+import type { Segment } from '../../src/path-query/segment-type.js';
+
+describe(SimplePathCache.name, () => {
+    describe(`${SimplePathCache.name} > get`, () => {
+        it('returns null on cache miss', () => {
+            const cache = new SimplePathCache();
+
+            expect(cache.get('user.name')).toBeNull();
+        });
+
+        it('returns cached segments on hit', () => {
+            const cache = new SimplePathCache();
+            const segments: Segment[] = [{ type: SegmentType.Key, value: 'user' }];
+            cache.set('user', segments);
+
+            expect(cache.get('user')).toEqual(segments);
+        });
+
+        it('promotes the accessed entry to most-recently-used position', () => {
+            const cache = new SimplePathCache(3);
+
+            const s1: Segment[] = [{ type: SegmentType.Key, value: 'a' }];
+            const s2: Segment[] = [{ type: SegmentType.Key, value: 'b' }];
+            const s3: Segment[] = [{ type: SegmentType.Key, value: 'c' }];
+
+            cache.set('a', s1);
+            cache.set('b', s2);
+            cache.set('c', s3);
+
+            cache.get('a');
+
+            cache.set('d', [{ type: SegmentType.Key, value: 'd' }]);
+
+            expect(cache.has('a')).toBe(true);
+            expect(cache.has('b')).toBe(false);
+            expect(cache.has('c')).toBe(true);
+            expect(cache.has('d')).toBe(true);
+        });
+    });
+
+    describe(`${SimplePathCache.name} > set`, () => {
+        it('stores segments and makes them retrievable', () => {
+            const cache = new SimplePathCache();
+            const segments: Segment[] = [{ type: SegmentType.Key, value: 'name' }];
+
+            cache.set('name', segments);
+
+            expect(cache.get('name')).toEqual(segments);
+        });
+
+        it('evicts the least-recently-used entry when capacity is reached', () => {
+            const cache = new SimplePathCache(2);
+
+            cache.set('a', [{ type: SegmentType.Key, value: 'a' }]);
+            cache.set('b', [{ type: SegmentType.Key, value: 'b' }]);
+
+            cache.set('c', [{ type: SegmentType.Key, value: 'c' }]);
+
+            expect(cache.has('a')).toBe(false);
+            expect(cache.has('b')).toBe(true);
+            expect(cache.has('c')).toBe(true);
+        });
+
+        it('overwrites an existing entry without growing the cache beyond maxSize', () => {
+            const cache = new SimplePathCache(2);
+            const s1: Segment[] = [{ type: SegmentType.Key, value: 'v1' }];
+            const s2: Segment[] = [{ type: SegmentType.Key, value: 'v2' }];
+
+            cache.set('a', s1);
+            cache.set('a', s2);
+
+            expect(cache.get('a')).toEqual(s2);
+        });
+
+        it('handles maxSize of zero without error', () => {
+            const cache = new SimplePathCache(0);
+            const segments: Segment[] = [{ type: SegmentType.Key, value: 'a' }];
+
+            cache.set('a', segments);
+
+            expect(cache.has('a')).toBe(true);
+        });
+
+        it('evicts correctly with maxSize of 1', () => {
+            const cache = new SimplePathCache(1);
+
+            cache.set('a', [{ type: SegmentType.Key, value: 'a' }]);
+            cache.set('b', [{ type: SegmentType.Key, value: 'b' }]);
+
+            expect(cache.has('a')).toBe(false);
+            expect(cache.has('b')).toBe(true);
+        });
+    });
+
+    describe(`${SimplePathCache.name} > has`, () => {
+        it('returns true for a cached path', () => {
+            const cache = new SimplePathCache();
+            cache.set('foo', []);
+
+            expect(cache.has('foo')).toBe(true);
+        });
+
+        it('returns false for a path not in cache', () => {
+            const cache = new SimplePathCache();
+
+            expect(cache.has('missing')).toBe(false);
+        });
+    });
+
+    describe(`${SimplePathCache.name} > clear`, () => {
+        it('removes all entries from the cache', () => {
+            const cache = new SimplePathCache();
+            cache.set('a', []);
+            cache.set('b', []);
+
+            cache.clear();
+
+            expect(cache.has('a')).toBe(false);
+            expect(cache.has('b')).toBe(false);
+        });
+
+        it('returns the same instance for fluent chaining', () => {
+            const cache = new SimplePathCache();
+
+            expect(cache.clear()).toBe(cache);
+        });
+    });
+
+    describe(`${SimplePathCache.name} > mutation boundary tests`, () => {
+        it('does not evict when cache has remaining capacity', () => {
+            const cache = new SimplePathCache(3);
+            cache.set('a', [{ type: SegmentType.Key, value: 'a' }]);
+            cache.set('b', [{ type: SegmentType.Key, value: 'b' }]);
+
+            expect(cache.has('a')).toBe(true);
+            expect(cache.has('b')).toBe(true);
+        });
+
+        it('guards firstKey !== undefined when evicting from a non-empty cache', () => {
+            const cache = new SimplePathCache(1);
+            cache.set('a', [{ type: SegmentType.Key, value: 'a' }]);
+
+            expect(cache.has('a')).toBe(true);
+
+            cache.set('b', [{ type: SegmentType.Key, value: 'b' }]);
+
+            expect(cache.has('a')).toBe(false);
+            expect(cache.has('b')).toBe(true);
+            expect(cache.get('a')).toBeNull();
+            expect(cache.get('b')).toEqual([{ type: SegmentType.Key, value: 'b' }]);
+        });
+
+        it('does not crash when set is called on max-capacity cache and firstKey exists', () => {
+            const cache = new SimplePathCache(2);
+            cache.set('x', []);
+            cache.set('y', []);
+
+            cache.set('z', [{ type: SegmentType.Key, value: 'z' }]);
+
+            expect(cache.has('x')).toBe(false);
+            expect(cache.has('y')).toBe(true);
+            expect(cache.has('z')).toBe(true);
+        });
+    });
+});

package/tests/core/accessor-factory.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from 'vitest';
+import { AccessorFactory } from '../../src/core/accessor-factory.js';
+import { DotNotationParser } from '../../src/core/dot-notation-parser.js';
+import { SecurityGuard } from '../../src/security/security-guard.js';
+import { SecurityParser } from '../../src/security/security-parser.js';
+import { ArrayAccessor } from '../../src/accessors/formats/array-accessor.js';
+import { ObjectAccessor } from '../../src/accessors/formats/object-accessor.js';
+import { JsonAccessor } from '../../src/accessors/formats/json-accessor.js';
+import { XmlAccessor } from '../../src/accessors/formats/xml-accessor.js';
+import { YamlAccessor } from '../../src/accessors/formats/yaml-accessor.js';
+import { IniAccessor } from '../../src/accessors/formats/ini-accessor.js';
+import { EnvAccessor } from '../../src/accessors/formats/env-accessor.js';
+import { NdjsonAccessor } from '../../src/accessors/formats/ndjson-accessor.js';
+import { AnyAccessor } from '../../src/accessors/formats/any-accessor.js';
+import { InvalidFormatException } from '../../src/exceptions/invalid-format-exception.js';
+import { FakeParseIntegration } from '../mocks/fake-parse-integration.js';
+
+function makeParser(): DotNotationParser {
+    return new DotNotationParser(new SecurityGuard(), new SecurityParser());
+}
+
+describe(AccessorFactory.name, () => {
+    describe('getParser', () => {
+        it('returns the parser passed to the constructor', () => {
+            const parser = makeParser();
+            const factory = new AccessorFactory(parser);
+            expect(factory.getParser()).toBe(parser);
+        });
+    });
+
+    describe('array', () => {
+        it('creates an ArrayAccessor from object data', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.array({ key: 'value' });
+            expect(accessor).toBeInstanceOf(ArrayAccessor);
+            expect(accessor.get('key')).toBe('value');
+        });
+
+        it('creates an ArrayAccessor from array data', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.array([1, 2, 3]);
+            expect(accessor).toBeInstanceOf(ArrayAccessor);
+            expect(accessor.get('0')).toBe(1);
+        });
+    });
+
+    describe('object', () => {
+        it('creates an ObjectAccessor from object data', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.object({ name: 'Alice' });
+            expect(accessor).toBeInstanceOf(ObjectAccessor);
+            expect(accessor.get('name')).toBe('Alice');
+        });
+    });
+
+    describe('json', () => {
+        it('creates a JsonAccessor from JSON string', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.json('{"key":"value"}');
+            expect(accessor).toBeInstanceOf(JsonAccessor);
+            expect(accessor.get('key')).toBe('value');
+        });
+    });
+
+    describe('xml', () => {
+        it('creates an XmlAccessor from XML string', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.xml('<root><key>value</key></root>');
+            expect(accessor).toBeInstanceOf(XmlAccessor);
+            expect(accessor.get('key')).toBe('value');
+        });
+    });
+
+    describe('yaml', () => {
+        it('creates a YamlAccessor from YAML string', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.yaml('key: value');
+            expect(accessor).toBeInstanceOf(YamlAccessor);
+            expect(accessor.get('key')).toBe('value');
+        });
+    });
+
+    describe('ini', () => {
+        it('creates an IniAccessor from INI string', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.ini('[section]\nkey=value');
+            expect(accessor).toBeInstanceOf(IniAccessor);
+            expect(accessor.get('section.key')).toBe('value');
+        });
+    });
+
+    describe('env', () => {
+        it('creates an EnvAccessor from dotenv string', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.env('APP_NAME=MyApp');
+            expect(accessor).toBeInstanceOf(EnvAccessor);
+            expect(accessor.get('APP_NAME')).toBe('MyApp');
+        });
+    });
+
+    describe('ndjson', () => {
+        it('creates an NdjsonAccessor from NDJSON string', () => {
+            const factory = new AccessorFactory(makeParser());
+            const accessor = factory.ndjson('{"id":1}\n{"id":2}');
+            expect(accessor).toBeInstanceOf(NdjsonAccessor);
+            expect(accessor.get('0.id')).toBe(1);
+        });
+    });
+
+    describe('any', () => {
+        it('creates an AnyAccessor with a provided integration', () => {
+            const integration = new FakeParseIntegration(true, { foo: 'bar' });
+            const factory = new AccessorFactory(makeParser(), integration);
+            const accessor = factory.any('raw');
+            expect(accessor).toBeInstanceOf(AnyAccessor);
+            expect(accessor.get('foo')).toBe('bar');
+        });
+
+        it('uses inline integration over default', () => {
+            const defaultInt = new FakeParseIntegration(true, { from: 'default' });
+            const overrideInt = new FakeParseIntegration(true, { from: 'override' });
+            const factory = new AccessorFactory(makeParser(), defaultInt);
+            const accessor = factory.any('raw', overrideInt);
+            expect(accessor.get('from')).toBe('override');
+        });
+
+        it('throws InvalidFormatException when no integration is available', () => {
+            const factory = new AccessorFactory(makeParser());
+            expect(() => factory.any('data')).toThrow(InvalidFormatException);
+        });
+
+        it('throws with guidance message when no integration is set', () => {
+            const factory = new AccessorFactory(makeParser());
+            expect(() => factory.any('data')).toThrow(
+                'AnyAccessor requires a ParseIntegrationInterface',
+            );
+        });
+
+        it('includes withParserIntegration guidance in the error message', () => {
+            const factory = new AccessorFactory(makeParser());
+            expect(() => factory.any('data')).toThrow(/withParserIntegration/);
+        });
+    });
+
+    describe('strict mode', () => {
+        it('applies strict mode to created accessors when configured', () => {
+            const factory = new AccessorFactory(makeParser(), null, false);
+            const accessor = factory.json('{"__proto__":"ok"}');
+            expect(accessor.get('__proto__')).toBe('ok');
+        });
+
+        it('does not apply strict mode when null', () => {
+            const factory = new AccessorFactory(makeParser(), null, null);
+            expect(() => factory.json('{"__proto__":"fail"}')).toThrow();
+        });
+    });
+});