@tehw0lf/yaft 0.0.15 → 0.0.17

package/src/test/providers.spec.ts

@@ -1,218 +0,0 @@
-import { Feature, FeatureProvider } from '../FeatureToggle';
-import { LocalStorageFeatureProvider } from '../examples/LocalStorageFeatureProvider';
-import { LocalStorageBooleanProvider } from '../examples/LocalStorageBooleanProvider';
-
-describe('Feature Providers', () => {
-  describe('LocalStorageFeatureProvider', () => {
-    let provider: LocalStorageFeatureProvider;
-
-    beforeEach(() => {
-      provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'myMethodToggle': {
-              key: 'myMethodToggle',
-              value: 'true',
-              activeAt: '',
-              disabledAt: ''
-            },
-            'myClassToggle': {
-              key: 'myClassToggle',
-              value: 'false',
-              activeAt: '',
-              disabledAt: ''
-            },
-            'myOtherMethodToggle': {
-              key: 'myOtherMethodToggle',
-              value: 'false',
-              activeAt: '',
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-    });
-
-    it('should load configuration from file on construction', () => {
-      expect(provider.data).toBeDefined();
-      expect(typeof provider.data).toBe('object');
-    });
-
-    it('should return correct isEnabled for existing features', () => {
-      expect(provider.isEnabled('myMethodToggle')).toBe(true);
-      expect(provider.isEnabled('myClassToggle')).toBe(false);
-      expect(provider.isEnabled('myOtherMethodToggle')).toBe(false);
-    });
-
-    it('should return false for non-existent features', () => {
-      expect(provider.isEnabled('nonExistentFeature')).toBe(false);
-      expect(provider.isEnabled('')).toBe(false);
-    });
-
-    it('should handle null/undefined features', () => {
-      const mockProvider = new LocalStorageFeatureProvider('./non-existent-file.json');
-      expect(mockProvider.isEnabled('anyKey')).toBe(false);
-    });
-
-    describe('time-based feature evaluation', () => {
-      let timeProvider: LocalStorageFeatureProvider;
-
-      beforeEach(() => {
-        const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
-        const futureDate = new Date(Date.now() + 86400000).toISOString(); // 1 day from now
-        
-        // Mock require to return time-based features
-        const originalRequire = require;
-        jest.doMock('./time-test-features.json', () => ({
-          'activeFeature': {
-            key: 'activeFeature',
-            value: 'true',
-            activeAt: pastDate,
-            disabledAt: futureDate
-          },
-          'disabledFeature': {
-            key: 'disabledFeature',
-            value: 'true',
-            activeAt: pastDate,
-            disabledAt: pastDate // Already disabled
-          },
-          'futureFeature': {
-            key: 'futureFeature',
-            value: 'true',
-            activeAt: futureDate, // Not yet active
-            disabledAt: ''
-          }
-        }), { virtual: true });
-
-        timeProvider = new LocalStorageFeatureProvider('./time-test-features.json');
-      });
-
-      afterEach(() => {
-        jest.clearAllMocks();
-      });
-
-      it('should respect activeAt timestamps', () => {
-        // This test would need actual time-based test data
-        // For now, test the logic with the existing test data
-        expect(timeProvider.isEnabled).toBeDefined();
-      });
-
-      it('should respect disabledAt timestamps', () => {
-        // This test would need actual time-based test data
-        expect(timeProvider.isEnabled).toBeDefined();
-      });
-    });
-  });
-
-  describe('LocalStorageBooleanProvider', () => {
-    let provider: LocalStorageBooleanProvider;
-
-    beforeEach(() => {
-      provider = new (class extends LocalStorageBooleanProvider {
-        constructor() {
-          super('');
-          this.data = { 'myToggle': true };
-        }
-      })();
-    });
-
-    it('should load boolean configuration from file', () => {
-      expect(provider.data).toBeDefined();
-      expect(typeof provider.data).toBe('object');
-    });
-
-    it('should return correct boolean values', () => {
-      expect(provider.isEnabled('myToggle')).toBe(true);
-    });
-
-    it('should return false for non-existent boolean features', () => {
-      expect(provider.isEnabled('nonExistentToggle')).toBe(false);
-    });
-
-    it('should handle various boolean representations', () => {
-      // Test with mock data containing different boolean formats
-      const mockProvider = new (class extends LocalStorageBooleanProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'trueString': true,
-            'falseString': false, 
-            'trueBoolean': true,
-            'falseBoolean': false,
-            'truthy': true,
-            'falsy': false
-          };
-        }
-      })();
-
-      expect(mockProvider.isEnabled('trueBoolean')).toBe(true);
-      expect(mockProvider.isEnabled('falseBoolean')).toBe(false);
-    });
-  });
-
-  describe('FeatureProvider Interface', () => {
-    it('should define correct interface structure', () => {
-      class TestProvider implements FeatureProvider<boolean> {
-        data: Record<string, boolean> = {};
-        
-        getConfig(configPathOrUrl: string): void {
-          this.data = { test: true };
-        }
-
-        isEnabled(key: string): boolean {
-          return this.data[key] || false;
-        }
-      }
-
-      const provider = new TestProvider();
-      provider.getConfig('test-path');
-      
-      expect(provider.isEnabled('test')).toBe(true);
-      expect(provider.isEnabled('missing')).toBe(false);
-    });
-
-    it('should support optional properties', () => {
-      class TestProviderWithOptional implements FeatureProvider<Feature> {
-        apiUrl = 'https://api.example.com';
-        baseUUID = 'test-uuid';
-        data: Record<string, Feature> = {};
-
-        getConfig(configPathOrUrl: string): void {}
-        
-        getCollectionHash(configPathOrUrl: string): void {}
-
-        isEnabled(key: string): boolean {
-          return false;
-        }
-      }
-
-      const provider = new TestProviderWithOptional();
-      expect(provider.apiUrl).toBe('https://api.example.com');
-      expect(provider.baseUUID).toBe('test-uuid');
-      expect(provider.getCollectionHash).toBeDefined();
-    });
-  });
-
-  describe('Provider Error Handling', () => {
-    it('should handle file not found gracefully', () => {
-      const provider = new LocalStorageFeatureProvider('./non-existent-file.json');
-      expect(provider.data).toEqual({});
-      expect(provider.isEnabled('anyKey')).toBe(false);
-    });
-
-    it('should handle invalid JSON gracefully', () => {
-      // Mock require to throw error
-      const originalConsoleError = console.error;
-      console.error = jest.fn();
-
-      try {
-        const provider = new LocalStorageFeatureProvider('./invalid-json-file.json');
-        expect(provider.data).toEqual({});
-        expect(console.error).toHaveBeenCalled();
-      } finally {
-        console.error = originalConsoleError;
-      }
-    });
-  });
-});

package/src/test/test-boolean.json

@@ -1 +0,0 @@
-{ "myToggle": true }

package/src/test/test-feature.json

@@ -1,20 +0,0 @@
-{
-  "myClassToggle": {
-    "key": "myClassToggle",
-    "value": "false",
-    "activeAt": "",
-    "disabledAt": ""
-  },
-  "myMethodToggle": {
-    "key": "myMethodToggle",
-    "value": "true",
-    "activeAt": "",
-    "disabledAt": ""
-  },
-  "myOtherMethodToggle": {
-    "key": "myOtherMethodToggle",
-    "value": "false",
-    "activeAt": "",
-    "disabledAt": ""
-  }
-}

package/src/test/test-setup.ts

@@ -1,2 +0,0 @@
-import 'reflect-metadata';
-

package/src/test/time-based-logic.spec.ts

@@ -1,169 +0,0 @@
-import { Feature } from '../FeatureToggle';
-import { LocalStorageFeatureProvider } from '../examples/LocalStorageFeatureProvider';
-
-describe('Time-based Feature Evaluation Logic', () => {
-  describe('Current Time Logic', () => {
-    it('should handle feature with value=true and no dates (always enabled)', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'always-enabled': {
-              key: 'always-enabled',
-              value: 'true',
-              activeAt: '',
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-
-      expect(provider.isEnabled('always-enabled')).toBe(true);
-    });
-
-    it('should handle feature with value=false (always disabled)', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'always-disabled': {
-              key: 'always-disabled',
-              value: 'false',
-              activeAt: '',
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-
-      expect(provider.isEnabled('always-disabled')).toBe(false);
-    });
-
-    it('should disable feature if disabledAt is in the past', () => {
-      const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
-
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'past-disabled': {
-              key: 'past-disabled',
-              value: 'true',
-              activeAt: '',
-              disabledAt: pastDate
-            }
-          };
-        }
-      })();
-
-      expect(provider.isEnabled('past-disabled')).toBe(false);
-    });
-
-    it('should enable feature if activeAt is in the past and no disabledAt', () => {
-      const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
-
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'past-active': {
-              key: 'past-active',
-              value: 'true',
-              activeAt: pastDate,
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-
-      expect(provider.isEnabled('past-active')).toBe(true);
-    });
-
-    it('BUG: should NOT enable feature if activeAt is in the future', () => {
-      const futureDate = new Date(Date.now() + 86400000).toISOString(); // 1 day from now
-
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'future-active': {
-              key: 'future-active',
-              value: 'true',
-              activeAt: futureDate,
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-
-      // CURRENT BUGGY BEHAVIOR: Returns true because it falls through to line 28
-      // Date.now() >= Date.parse(futureDate) is false, so it skips line 26
-      // Falls through to: return JSON.parse(feature.value); which returns true
-
-      // EXPECTED BEHAVIOR: Should return false because feature is not yet active
-      expect(provider.isEnabled('future-active')).toBe(false);
-    });
-
-    it('should enable feature if within activeAt and disabledAt window', () => {
-      const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
-      const futureDate = new Date(Date.now() + 86400000).toISOString(); // 1 day from now
-
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'windowed-feature': {
-              key: 'windowed-feature',
-              value: 'true',
-              activeAt: pastDate,
-              disabledAt: futureDate
-            }
-          };
-        }
-      })();
-
-      expect(provider.isEnabled('windowed-feature')).toBe(true);
-    });
-
-    it('should handle NaN dates gracefully (empty strings)', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'empty-dates': {
-              key: 'empty-dates',
-              value: 'true',
-              activeAt: '',
-              disabledAt: ''
-            }
-          };
-        }
-      })();
-
-      // Date.parse('') returns NaN
-      // Date.now() >= NaN is false for both checks
-      // Should fall through to: return JSON.parse(feature.value);
-      expect(provider.isEnabled('empty-dates')).toBe(true);
-    });
-
-    it('should handle invalid date strings gracefully', () => {
-      const provider = new (class extends LocalStorageFeatureProvider {
-        constructor() {
-          super('');
-          this.data = {
-            'invalid-dates': {
-              key: 'invalid-dates',
-              value: 'true',
-              activeAt: 'not-a-date',
-              disabledAt: 'also-not-a-date'
-            }
-          };
-        }
-      })();
-
-      // Date.parse('not-a-date') returns NaN
-      // Similar behavior to empty strings
-      expect(provider.isEnabled('invalid-dates')).toBe(true);
-    });
-  });
-});

package/src/test/yaft.demo.spec.ts

@@ -1,53 +0,0 @@
-import { FeatureToggle, FeatureToggleBase } from "..";
-import { LocalStorageFeatureProvider } from "../examples/LocalStorageFeatureProvider";
-
-FeatureToggleBase.featureProvider = new LocalStorageFeatureProvider(
-  "../test/test-feature.json"
-);
-
-class Demo3 {
-  constructor() {}
-
-  async five() {
-    return Promise.resolve(9);
-  }
-}
-
-@FeatureToggle("myClassToggle", Demo3)
-class Demo2 {
-  constructor() {}
-
-  async five() {
-    return Promise.resolve(5);
-  }
-}
-
-function myFallback() {
-  console.log("hiyaa");
-}
-
-export class Demo {
-  demo: Demo2;
-  constructor() {
-    this.demo = new Demo2();
-  }
-
-  @FeatureToggle("myMethodToggle")
-  method() {
-    console.log("Hello world!");
-    this.demo.five().then((val) => console.log(val));
-  }
-
-  @FeatureToggle("myOtherMethodToggle", myFallback)
-  othermethod() {
-    console.log("Hello other world!");
-  }
-}
-
-describe("YaFT Demo", () => {
-  it("should create test", () => {
-    const test = new Demo();
-    test.method();
-    test.othermethod();
-  });
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "ES2022",
-    "experimentalDecorators": true,
-    "declaration": true,
-    "rootDir": "./src",
-    "outDir": "./dist/yaft",
-    "types": ["node"],
-    "lib": ["ES2022"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["**/*.spec.ts", "**/*.test.ts", "**/test/**/*"]
-}

package/tsconfig.spec.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "module": "esnext",
-    "types": ["jest", "node"]
-  },
-  "files": ["src/test/test-setup.ts"],
-  "include": ["**/*.spec.ts", "**/*.d.ts", "jest.config.ts"]
-}