@tehw0lf/yaft 0.0.12 → 0.0.16

package/src/test/error-handling.spec.ts

@@ -1,396 +0,0 @@
-import { FeatureToggle, FeatureToggleBase, FeatureProvider, Feature } from '../FeatureToggle';
-import { LocalStorageFeatureProvider } from '../examples/LocalStorageFeatureProvider';
-import { ApiServiceFeatureProvider } from '../examples/ApiServiceFeatureProvider';
-import axios from 'axios';
-
-// Mock axios for API provider tests
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-mockedAxios.get = jest.fn();
-
-describe('Error Handling and Edge Cases', () => {
-  let mockProvider: FeatureProvider<boolean>;
-
-  beforeEach(() => {
-    mockProvider = {
-      data: {},
-      getConfig: jest.fn(),
-      isEnabled: jest.fn()
-    };
-    FeatureToggleBase.featureProvider = mockProvider;
-    jest.clearAllMocks();
-    // Reset axios mock
-    (mockedAxios.get as jest.Mock).mockReset();
-  });
-
-  describe('Provider Initialization Errors', () => {
-    it('should handle missing provider gracefully', () => {
-      FeatureToggleBase.featureProvider = null as any;
-
-      expect(() => {
-        class TestClass {
-          @FeatureToggle('test')
-          method() {}
-        }
-      }).toThrow('FeatureToggleProvider not set');
-    });
-
-    it('should handle undefined provider gracefully', () => {
-      FeatureToggleBase.featureProvider = undefined as any;
-
-      expect(() => {
-        class TestClass {
-          @FeatureToggle('test')
-          method() {}
-        }
-      }).toThrow('FeatureToggleProvider not set');
-    });
-  });
-
-  describe('LocalStorageFeatureProvider Error Handling', () => {
-    it('should handle non-existent configuration files', () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      
-      const provider = new LocalStorageFeatureProvider('./non-existent-file.json');
-      
-      expect(provider.data).toEqual({});
-      expect(provider.isEnabled('anyKey')).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        'Failed to load configuration from local file:',
-        expect.objectContaining({
-          code: 'MODULE_NOT_FOUND'
-        })
-      );
-      
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle corrupted JSON files', () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      const originalRequire = require;
-      
-      // Mock require to throw JSON parsing error
-      (global as any).require = jest.fn(() => {
-        throw new SyntaxError('Unexpected token in JSON');
-      });
-
-      const provider = new LocalStorageFeatureProvider('./corrupted.json');
-      
-      expect(provider.data).toEqual({});
-      expect(provider.isEnabled('anyKey')).toBe(false);
-      expect(consoleSpy).toHaveBeenCalled();
-      
-      // Restore
-      (global as any).require = originalRequire;
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle features with malformed date strings', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'malformedDates': {
-              key: 'malformedDates',
-              value: 'true',
-              activeAt: 'invalid-date',
-              disabledAt: 'also-invalid-date'
-            }
-          };
-        }
-      })();
-
-      // Date.parse returns NaN for invalid dates, which should be handled
-      const result = provider.isEnabled('malformedDates');
-      expect(typeof result).toBe('boolean');
-    });
-
-    it('should handle features with null/undefined date values', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'nullDates': {
-              key: 'nullDates',
-              value: 'true',
-              activeAt: null as any,
-              disabledAt: undefined as any
-            }
-          };
-        }
-      })();
-
-      const result = provider.isEnabled('nullDates');
-      expect(typeof result).toBe('boolean');
-    });
-
-    it('should handle features with invalid boolean values', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'invalidBoolean': {
-              key: 'invalidBoolean',
-              value: 'not-a-boolean',
-              activeAt: '',
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-
-      // New behavior: safely returns false for any value that is not "true"
-      expect(provider.isEnabled('invalidBoolean')).toBe(false);
-    });
-  });
-
-  describe('ApiServiceFeatureProvider Error Handling', () => {
-    it('should handle network failures gracefully', async () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      mockedAxios.get.mockRejectedValue(new Error('Network error'));
-
-      const provider = new ApiServiceFeatureProvider('https://api.test.com', 'test-uuid');
-      
-      // Allow async operations to complete
-      await new Promise(resolve => setTimeout(resolve, 0));
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        'Failed to fetch feature toggle from API:',
-        expect.any(Error)
-      );
-      
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle API returning invalid data format', async () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      mockedAxios.get
-        .mockResolvedValueOnce({ data: { value: 'invalid-hash' } }) // collection hash
-        .mockResolvedValueOnce({ data: { value: 'not-an-object' } }); // features
-
-      const provider = new ApiServiceFeatureProvider('https://api.test.com', 'test-uuid');
-      
-      await new Promise(resolve => setTimeout(resolve, 0));
-      
-      // Should handle gracefully without crashing
-      expect(provider.data).toBeDefined();
-      
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle HTTP error responses', async () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      mockedAxios.get.mockRejectedValue({
-        response: { status: 404, statusText: 'Not Found' }
-      });
-
-      const provider = new ApiServiceFeatureProvider('https://api.test.com', 'test-uuid');
-      
-      await new Promise(resolve => setTimeout(resolve, 0));
-      
-      expect(consoleSpy).toHaveBeenCalled();
-      
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle timeout errors', async () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      mockedAxios.get.mockRejectedValue({ code: 'ECONNABORTED', message: 'timeout' });
-
-      const provider = new ApiServiceFeatureProvider('https://api.test.com', 'test-uuid');
-      
-      await new Promise(resolve => setTimeout(resolve, 0));
-      
-      expect(consoleSpy).toHaveBeenCalled();
-      
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('Decorator Edge Cases', () => {
-    beforeEach(() => {
-      (mockProvider.isEnabled as jest.Mock).mockReturnValue(false);
-    });
-
-    it('should handle methods throwing errors in fallbacks', () => {
-      function errorFallback() {
-        throw new Error('Fallback error');
-      }
-
-      class TestClass {
-        @FeatureToggle('disabled', errorFallback)
-        method() {
-          return 'original';
-        }
-      }
-
-      const instance = new TestClass();
-      
-      expect(() => {
-        instance.method();
-      }).toThrow('Fallback error');
-    });
-
-    it('should handle async methods throwing errors', async () => {
-      (mockProvider.isEnabled as jest.Mock).mockReturnValue(true);
-
-      class TestClass {
-        @FeatureToggle('enabled')
-        async asyncMethod() {
-          throw new Error('Async error');
-        }
-      }
-
-      const instance = new TestClass();
-      
-      await expect(instance.asyncMethod()).rejects.toThrow('Async error');
-    });
-
-    it('should handle circular reference in fallback class', () => {
-      class CircularClass {
-        constructor() {
-          (this as any).self = this;
-        }
-      }
-
-      @FeatureToggle('disabled', CircularClass)
-      class TestClass {
-        constructor() {}
-      }
-
-      expect(() => {
-        new TestClass();
-      }).not.toThrow();
-    });
-
-    it('should handle fallback class constructor throwing errors', () => {
-      class ErrorClass {
-        constructor() {
-          throw new Error('Constructor error');
-        }
-      }
-
-      @FeatureToggle('disabled', ErrorClass)
-      class TestClass {
-        constructor() {}
-      }
-
-      expect(() => {
-        new TestClass();
-      }).toThrow('Constructor error');
-    });
-
-    it('should handle deeply nested method calls', () => {
-      (mockProvider.isEnabled as jest.Mock).mockReturnValue(true);
-
-      class TestClass {
-        @FeatureToggle('enabled')
-        level1() {
-          return this.level2();
-        }
-
-        level2() {
-          return this.level3();
-        }
-
-        level3() {
-          return 'deep result';
-        }
-      }
-
-      const instance = new TestClass();
-      expect(instance.level1()).toBe('deep result');
-    });
-  });
-
-  describe('Memory and Performance Edge Cases', () => {
-    it('should handle large number of decorated methods', () => {
-      (mockProvider.isEnabled as jest.Mock).mockReturnValue(true);
-
-      class TestClass {
-        @FeatureToggle('feature1') method1() { return 1; }
-        @FeatureToggle('feature2') method2() { return 2; }
-        @FeatureToggle('feature3') method3() { return 3; }
-        @FeatureToggle('feature4') method4() { return 4; }
-        @FeatureToggle('feature5') method5() { return 5; }
-        // ... many more methods would be here in a real test
-      }
-
-      const instance = new TestClass();
-
-      expect(instance.method1()).toBe(1);
-      expect(instance.method2()).toBe(2);
-      expect(instance.method3()).toBe(3);
-      expect(instance.method4()).toBe(4);
-      expect(instance.method5()).toBe(5);
-      expect(mockProvider.isEnabled).toHaveBeenCalledTimes(5);
-    });
-
-    it('should handle rapid instantiation of decorated classes', () => {
-      (mockProvider.isEnabled as jest.Mock).mockReturnValue(false);
-
-      @FeatureToggle('disabled')
-      class TestClass {
-        value = Math.random();
-      }
-
-      const instances = Array.from({ length: 100 }, () => new TestClass());
-      
-      expect(instances).toHaveLength(100);
-      expect(mockProvider.isEnabled).toHaveBeenCalledTimes(1); // Called once during decoration
-    });
-
-    it('should handle very long feature keys', () => {
-      const longKey = 'a'.repeat(10000);
-      (mockProvider.isEnabled as jest.Mock).mockReturnValue(true);
-
-      class TestClass {
-        @FeatureToggle(longKey)
-        method() {
-          return 'result';
-        }
-      }
-
-      const instance = new TestClass();
-      expect(instance.method()).toBe('result');
-      expect(mockProvider.isEnabled).toHaveBeenCalledWith(longKey);
-    });
-  });
-
-  describe('Type Safety Edge Cases', () => {
-    it('should handle mixed data types in providers', () => {
-      const mixedProvider = {
-        data: {
-          'stringFeature': 'true',
-          'booleanFeature': true,
-          'numberFeature': 1,
-          'objectFeature': { enabled: true },
-          'nullFeature': null,
-          'undefinedFeature': undefined
-        } as Record<string, unknown>,
-        getConfig: jest.fn(),
-        isEnabled: (key: string) => {
-          const value = mixedProvider.data[key];
-          if (value === null || value === undefined) return false;
-          return Boolean(value);
-        }
-      };
-
-      FeatureToggleBase.featureProvider = mixedProvider;
-
-      class TestClass {
-        @FeatureToggle('stringFeature') stringMethod() { return 'string'; }
-        @FeatureToggle('booleanFeature') booleanMethod() { return 'boolean'; }
-        @FeatureToggle('numberFeature') numberMethod() { return 'number'; }
-        @FeatureToggle('nullFeature') nullMethod() { return 'null'; }
-      }
-
-      const instance = new TestClass();
-      
-      expect(instance.stringMethod()).toBe('string');
-      expect(instance.booleanMethod()).toBe('boolean');
-      expect(instance.numberMethod()).toBe('number');
-      expect(instance.nullMethod()).toBeUndefined(); // null should be falsy
-    });
-  });
-});

package/src/test/evaluate.spec.ts

@@ -1,260 +0,0 @@
-import { Feature } from '../FeatureToggle';
-import { Clock, evaluate, parseTimestamp, systemClock } from '../evaluate';
-
-/**
- * Tests for the central evaluation rules.
- *
- * Every case carries its own `now`, so nothing here depends on when the suite
- * runs. This mirrors how the conformance suite supplies a `now` per case, and
- * is the reason the clock had to become injectable.
- */
-describe('evaluate', () => {
-  const NOW = Date.parse('2026-09-18T12:00:00Z');
-
-  const feature = (overrides: Partial<Feature> = {}): Feature => ({
-    key: 'f',
-    value: 'true',
-    activeAt: '',
-    disabledAt: '',
-    ...overrides,
-  });
-
-  describe('missing features', () => {
-    it('treats undefined as off', () => {
-      expect(evaluate(undefined, NOW)).toBe(false);
-    });
-
-    it('treats null as off', () => {
-      expect(evaluate(null, NOW)).toBe(false);
-    });
-  });
-
-  describe('value', () => {
-    it('is on for exactly "true"', () => {
-      expect(evaluate(feature({ value: 'true' }), NOW)).toBe(true);
-    });
-
-    // The backend stores the value as a string. Anything but "true" must read
-    // as off, or backend and client would silently disagree.
-    it.each(['false', 'TRUE', 'True', '1', '', 'yes'])(
-      'is off for %p',
-      (value) => {
-        expect(evaluate(feature({ value }), NOW)).toBe(false);
-      }
-    );
-
-    it('is off when the value is missing entirely', () => {
-      const withoutValue = { key: 'f', activeAt: '', disabledAt: '' } as Feature;
-      expect(evaluate(withoutValue, NOW)).toBe(false);
-    });
-  });
-
-  describe('activeAt', () => {
-    it('is off before activeAt', () => {
-      expect(
-        evaluate(feature({ activeAt: '2026-09-18T13:00:00Z' }), NOW)
-      ).toBe(false);
-    });
-
-    it('is on after activeAt', () => {
-      expect(
-        evaluate(feature({ activeAt: '2026-09-18T11:00:00Z' }), NOW)
-      ).toBe(true);
-    });
-
-    // The window is half-open: the comparison is `now < activeAt`.
-    it('is on at exactly activeAt', () => {
-      expect(
-        evaluate(feature({ activeAt: '2026-09-18T12:00:00Z' }), NOW)
-      ).toBe(true);
-    });
-  });
-
-  describe('disabledAt', () => {
-    it('is on before disabledAt', () => {
-      expect(
-        evaluate(feature({ disabledAt: '2026-09-18T13:00:00Z' }), NOW)
-      ).toBe(true);
-    });
-
-    it('is off after disabledAt', () => {
-      expect(
-        evaluate(feature({ disabledAt: '2026-09-18T11:00:00Z' }), NOW)
-      ).toBe(false);
-    });
-
-    // The comparison is `now >= disabledAt`, so the boundary is off -- the
-    // opposite of the activeAt boundary.
-    it('is off at exactly disabledAt', () => {
-      expect(
-        evaluate(feature({ disabledAt: '2026-09-18T12:00:00Z' }), NOW)
-      ).toBe(false);
-    });
-  });
-
-  describe('both bounds', () => {
-    const windowed = feature({
-      activeAt: '2026-09-18T10:00:00Z',
-      disabledAt: '2026-09-18T14:00:00Z',
-    });
-
-    it('is on inside the window', () => {
-      expect(evaluate(windowed, NOW)).toBe(true);
-    });
-
-    it('is off before the window', () => {
-      expect(evaluate(windowed, Date.parse('2026-09-18T09:00:00Z'))).toBe(false);
-    });
-
-    it('is off after the window', () => {
-      expect(evaluate(windowed, Date.parse('2026-09-18T15:00:00Z'))).toBe(false);
-    });
-
-    // Not a special case: the bounds simply never overlap.
-    it('is off everywhere when activeAt is after disabledAt', () => {
-      const inverted = feature({
-        activeAt: '2026-09-18T14:00:00Z',
-        disabledAt: '2026-09-18T10:00:00Z',
-      });
-
-      for (const at of [
-        '2026-09-18T09:00:00Z',
-        '2026-09-18T12:00:00Z',
-        '2026-09-18T16:00:00Z',
-      ]) {
-        expect(evaluate(inverted, Date.parse(at))).toBe(false);
-      }
-    });
-  });
-
-  describe('timezone offsets', () => {
-    it('converts an offset to the same instant as UTC', () => {
-      // 14:00+02:00 is 12:00Z, which is exactly NOW, so the activeAt boundary
-      // is inclusive and the feature is on.
-      expect(
-        evaluate(feature({ activeAt: '2026-09-18T14:00:00+02:00' }), NOW)
-      ).toBe(true);
-    });
-
-    it('respects a negative offset', () => {
-      // 08:00-05:00 is 13:00Z, one hour after NOW, so it is not active yet.
-      expect(
-        evaluate(feature({ activeAt: '2026-09-18T08:00:00-05:00' }), NOW)
-      ).toBe(false);
-    });
-  });
-
-  describe('unset and invalid bounds are ignored', () => {
-    it.each([
-      ['empty string', ''],
-      ['null', null],
-      ['undefined', undefined],
-    ])('ignores %s', (_label, value) => {
-      const f = feature({
-        activeAt: value as string,
-        disabledAt: value as string,
-      });
-      expect(evaluate(f, NOW)).toBe(true);
-    });
-
-    // Rejected on purpose: JavaScript reads a bare date as UTC midnight and an
-    // offset-less timestamp as local time, while most other languages read
-    // both as local. Accepting them would make a feature flip at a different
-    // instant depending on the port.
-    it.each([
-      ['a bare date', '2026-09-18'],
-      ['no offset', '2026-09-18T15:00:00'],
-      ['garbage', 'not-a-date'],
-      ['a unix timestamp', '1758196800'],
-      ['a slash date', '2026/09/18'],
-    ])('ignores %s in activeAt', (_label, value) => {
-      // Would be off if parsed as a future bound; ignoring it leaves the
-      // feature on.
-      expect(evaluate(feature({ activeAt: value }), NOW)).toBe(true);
-    });
-
-    // Date.parse does not reject an impossible calendar date, it rolls it
-    // over: 2027-02-30 becomes 2027-03-02. The date must therefore be in the
-    // future, or the rolled-over value lands in the past and the activeAt
-    // check passes for the wrong reason.
-    it.each([
-      ['a day past the end of February', '2027-02-30T00:00:00Z'],
-      ['the 31st of a 30-day month', '2027-04-31T00:00:00Z'],
-      ['month 13', '2027-13-01T00:00:00Z'],
-      ['day zero', '2027-01-00T00:00:00Z'],
-      ['February 29 in a non-leap year', '2027-02-29T00:00:00Z'],
-      ['hour 24', '2027-01-01T24:00:00Z'],
-      ['minute 60', '2027-01-01T00:60:00Z'],
-    ])('ignores %s', (_label, value) => {
-      expect(evaluate(feature({ activeAt: value }), NOW)).toBe(true);
-      expect(parseTimestamp(value)).toBeUndefined();
-    });
-
-    it('accepts February 29 in a leap year', () => {
-      expect(parseTimestamp('2028-02-29T00:00:00Z')).toBe(
-        Date.parse('2028-02-29T00:00:00Z')
-      );
-    });
-
-    // RFC 3339 permits second 60 for a leap second, but Date.parse returns
-    // NaN for it, so the value is ignored like any other unusable bound. The
-    // range check lets it through and the NaN guard catches it; asserted here
-    // so the two stay consistent.
-    it('ignores a leap second, which Date.parse cannot represent', () => {
-      expect(parseTimestamp('2026-12-31T23:59:60Z')).toBeUndefined();
-      expect(
-        evaluate(feature({ activeAt: '2026-12-31T23:59:60Z' }), NOW)
-      ).toBe(true);
-    });
-
-    it('never throws on malformed input', () => {
-      expect(() =>
-        evaluate(feature({ activeAt: 'x', disabledAt: 'y' }), NOW)
-      ).not.toThrow();
-    });
-  });
-
-  describe('fractional seconds', () => {
-    it('accepts them', () => {
-      expect(
-        evaluate(feature({ disabledAt: '2026-09-18T12:00:00.001Z' }), NOW)
-      ).toBe(true);
-    });
-  });
-});
-
-describe('parseTimestamp', () => {
-  it('returns the epoch milliseconds for a valid timestamp', () => {
-    expect(parseTimestamp('2026-09-18T12:00:00Z')).toBe(
-      Date.parse('2026-09-18T12:00:00Z')
-    );
-  });
-
-  it.each([undefined, null, ''])('returns undefined for %p', (value) => {
-    expect(parseTimestamp(value)).toBeUndefined();
-  });
-
-  it('returns undefined for a format without an offset', () => {
-    expect(parseTimestamp('2026-09-18T12:00:00')).toBeUndefined();
-  });
-
-  it('accepts a lowercase t and z', () => {
-    expect(parseTimestamp('2026-09-18t12:00:00z')).toBe(
-      Date.parse('2026-09-18T12:00:00Z')
-    );
-  });
-});
-
-describe('systemClock', () => {
-  it('reports the current time', () => {
-    const before = Date.now();
-    const reading = systemClock();
-    expect(reading).toBeGreaterThanOrEqual(before);
-    expect(reading).toBeLessThanOrEqual(Date.now());
-  });
-
-  it('is the default, so a provider works without one', () => {
-    const clock: Clock = () => 0;
-    expect(typeof clock()).toBe('number');
-  });
-});