gridpilot.gg/apps/website/lib/feature/FeatureFlagService.test.ts

import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { FeatureFlagService, MockFeatureFlagService, mockFeatureFlags } from './FeatureFlagService';

describe('FeatureFlagService', () => {
  describe('fromEnv() with alpha mode integration', () => {
    let originalMode: string | undefined;
    let originalFlags: string | undefined;

    beforeEach(() => {
      originalMode = process.env.NEXT_PUBLIC_GRIDPILOT_MODE;
      originalFlags = process.env.FEATURE_FLAGS;
    });

    afterEach(() => {
      if (originalMode !== undefined) {
        process.env.NEXT_PUBLIC_GRIDPILOT_MODE = originalMode;
      } else {
        delete process.env.NEXT_PUBLIC_GRIDPILOT_MODE;
      }
      
      if (originalFlags !== undefined) {
        process.env.FEATURE_FLAGS = originalFlags;
      } else {
        delete process.env.FEATURE_FLAGS;
      }
    });

    it('should enable all features when NEXT_PUBLIC_GRIDPILOT_MODE is alpha', () => {
      process.env.NEXT_PUBLIC_GRIDPILOT_MODE = 'alpha';
      
      const service = FeatureFlagService.fromEnv();
      
      expect(service.isEnabled('driver_profiles')).toBe(true);
      expect(service.isEnabled('team_profiles')).toBe(true);
      expect(service.isEnabled('wallets')).toBe(true);
      expect(service.isEnabled('sponsors')).toBe(true);
      expect(service.isEnabled('team_feature')).toBe(true);
      expect(service.isEnabled('alpha_features')).toBe(true);
    });

    it('should enable no features when NEXT_PUBLIC_GRIDPILOT_MODE is pre-launch', () => {
      process.env.NEXT_PUBLIC_GRIDPILOT_MODE = 'pre-launch';
      
      const service = FeatureFlagService.fromEnv();
      
      expect(service.isEnabled('driver_profiles')).toBe(false);
      expect(service.isEnabled('team_profiles')).toBe(false);
      expect(service.isEnabled('wallets')).toBe(false);
      expect(service.isEnabled('sponsors')).toBe(false);
      expect(service.isEnabled('team_feature')).toBe(false);
      expect(service.isEnabled('alpha_features')).toBe(false);
    });

    it('should enable no features when NEXT_PUBLIC_GRIDPILOT_MODE is not set', () => {
      delete process.env.NEXT_PUBLIC_GRIDPILOT_MODE;
      
      const service = FeatureFlagService.fromEnv();
      
      expect(service.isEnabled('driver_profiles')).toBe(false);
      expect(service.isEnabled('team_profiles')).toBe(false);
      expect(service.isEnabled('wallets')).toBe(false);
      expect(service.isEnabled('sponsors')).toBe(false);
      expect(service.isEnabled('team_feature')).toBe(false);
      expect(service.isEnabled('alpha_features')).toBe(false);
    });

    it('should allow FEATURE_FLAGS to override alpha mode', () => {
      process.env.NEXT_PUBLIC_GRIDPILOT_MODE = 'alpha';
      process.env.FEATURE_FLAGS = 'driver_profiles,wallets';
      
      const service = FeatureFlagService.fromEnv();
      
      expect(service.isEnabled('driver_profiles')).toBe(true);
      expect(service.isEnabled('wallets')).toBe(true);
      expect(service.isEnabled('team_profiles')).toBe(false);
      expect(service.isEnabled('sponsors')).toBe(false);
      expect(service.isEnabled('team_feature')).toBe(false);
    });

    it('should return correct list of enabled flags in alpha mode', () => {
      process.env.NEXT_PUBLIC_GRIDPILOT_MODE = 'alpha';
      
      const service = FeatureFlagService.fromEnv();
      const enabledFlags = service.getEnabledFlags();
      
      expect(enabledFlags).toContain('driver_profiles');
      expect(enabledFlags).toContain('team_profiles');
      expect(enabledFlags).toContain('wallets');
      expect(enabledFlags).toContain('sponsors');
      expect(enabledFlags).toContain('team_feature');
      expect(enabledFlags).toContain('alpha_features');
      expect(enabledFlags.length).toBe(6);
    });
  });

  describe('Constructor behavior', () => {
    it('should use provided flags array', () => {
      const service = new FeatureFlagService(['test_flag']);
      expect(service.isEnabled('test_flag')).toBe(true);
      expect(service.isEnabled('other_flag')).toBe(false);
    });

    it('should parse FEATURE_FLAGS environment variable', () => {
      process.env.FEATURE_FLAGS = 'flag1, flag2, flag3';
      const service = new FeatureFlagService();
      
      expect(service.isEnabled('flag1')).toBe(true);
      expect(service.isEnabled('flag2')).toBe(true);
      expect(service.isEnabled('flag3')).toBe(true);
      expect(service.isEnabled('flag4')).toBe(false);
      
      delete process.env.FEATURE_FLAGS;
    });

    it('should handle empty FEATURE_FLAGS', () => {
      process.env.FEATURE_FLAGS = '';
      const service = new FeatureFlagService();
      
      expect(service.isEnabled('any_flag')).toBe(false);
      expect(service.getEnabledFlags()).toEqual([]);
      
      delete process.env.FEATURE_FLAGS;
    });
  });
});

describe('MockFeatureFlagService', () => {
  it('should work with provided flags', () => {
    const service = new MockFeatureFlagService(['test_flag']);
    expect(service.isEnabled('test_flag')).toBe(true);
    expect(service.isEnabled('other_flag')).toBe(false);
  });

  it('should return empty array when no flags provided', () => {
    const service = new MockFeatureFlagService();
    expect(service.getEnabledFlags()).toEqual([]);
  });
});

describe('mockFeatureFlags default instance', () => {
  it('should have alpha_features enabled by default', () => {
    expect(mockFeatureFlags.isEnabled('alpha_features')).toBe(true);
  });
});