@tehw0lf/yaft 0.0.2 → 0.0.4

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

@@ -0,0 +1,391 @@
+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>;
+
+describe('Error Handling and Edge Cases', () => {
+  let mockProvider: FeatureProvider<boolean>;
+
+  beforeEach(() => {
+    mockProvider = {
+      data: {},
+      getConfig: jest.fn(),
+      isEnabled: jest.fn()
+    };
+    FeatureToggleBase.featureProvider = mockProvider;
+    jest.clearAllMocks();
+  });
+
+  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: ''
+            }
+          };
+        }
+      })();
+
+      expect(() => {
+        provider.isEnabled('invalidBoolean');
+      }).toThrow(); // JSON.parse should throw for invalid boolean strings
+    });
+  });
+
+  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.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
+        },
+        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/feature-data.spec.ts

@@ -0,0 +1,102 @@
+import { Feature } from '../FeatureToggle';
+
+describe('Feature Data Type', () => {
+  describe('Feature structure validation', () => {
+    it('should accept valid Feature objects', () => {
+      const validFeature: Feature = {
+        key: 'testFeature',
+        value: 'true',
+        activeAt: '2023-01-01T00:00:00Z',
+        disabledAt: '2023-12-31T23:59:59Z'
+      };
+
+      expect(validFeature.key).toBe('testFeature');
+      expect(validFeature.value).toBe('true');
+      expect(validFeature.activeAt).toBe('2023-01-01T00:00:00Z');
+      expect(validFeature.disabledAt).toBe('2023-12-31T23:59:59Z');
+    });
+
+    it('should accept Feature with empty date strings', () => {
+      const featureWithEmptyDates: Feature = {
+        key: 'testFeature',
+        value: 'false',
+        activeAt: '',
+        disabledAt: ''
+      };
+
+      expect(featureWithEmptyDates.activeAt).toBe('');
+      expect(featureWithEmptyDates.disabledAt).toBe('');
+    });
+
+    it('should accept boolean-like string values', () => {
+      const trueBooleanFeature: Feature = {
+        key: 'trueFeature',
+        value: 'true',
+        activeAt: '',
+        disabledAt: ''
+      };
+
+      const falseBooleanFeature: Feature = {
+        key: 'falseFeature', 
+        value: 'false',
+        activeAt: '',
+        disabledAt: ''
+      };
+
+      expect(JSON.parse(trueBooleanFeature.value)).toBe(true);
+      expect(JSON.parse(falseBooleanFeature.value)).toBe(false);
+    });
+
+    it('should handle various date formats', () => {
+      const isoDateFeature: Feature = {
+        key: 'isoFeature',
+        value: 'true',
+        activeAt: '2023-01-01T00:00:00.000Z',
+        disabledAt: '2023-12-31T23:59:59.999Z'
+      };
+
+      const simpleDateFeature: Feature = {
+        key: 'simpleFeature',
+        value: 'true', 
+        activeAt: '2023-01-01',
+        disabledAt: '2023-12-31'
+      };
+
+      expect(Date.parse(isoDateFeature.activeAt)).not.toBeNaN();
+      expect(Date.parse(isoDateFeature.disabledAt)).not.toBeNaN();
+      expect(Date.parse(simpleDateFeature.activeAt)).not.toBeNaN();
+      expect(Date.parse(simpleDateFeature.disabledAt)).not.toBeNaN();
+    });
+  });
+
+  describe('Feature collection structures', () => {
+    it('should handle Record<string, Feature> collections', () => {
+      const featureCollection: Record<string, Feature> = {
+        'feature1': {
+          key: 'feature1',
+          value: 'true',
+          activeAt: '',
+          disabledAt: ''
+        },
+        'feature2': {
+          key: 'feature2',
+          value: 'false',
+          activeAt: '2023-01-01',
+          disabledAt: '2023-12-31'
+        }
+      };
+
+      expect(Object.keys(featureCollection)).toHaveLength(2);
+      expect(featureCollection['feature1']).toBeDefined();
+      expect(featureCollection['feature2']).toBeDefined();
+      expect(featureCollection['nonexistent']).toBeUndefined();
+    });
+
+    it('should handle empty feature collections', () => {
+      const emptyCollection: Record<string, Feature> = {};
+
+      expect(Object.keys(emptyCollection)).toHaveLength(0);
+      expect(emptyCollection['anyKey']).toBeUndefined();
+    });
+  });
+});