guardrail-core 1.0.0 → 2.0.0

package/src/__tests__/tier-config.test.ts

@@ -1,289 +0,0 @@
-/**
- * Tier Configuration Drift Prevention Tests
- * 
- * These tests ensure that tier definitions remain consistent across
- * all parts of the codebase. If a tier is added/removed in one place
- * but not others, these tests will fail.
- */
-
-import {
-    FEATURES,
-    PURCHASABLE_TIERS,
-    TIERS,
-    TIER_CONFIG,
-    TIER_ORDER,
-    Tier,
-    compareTiers,
-    getMinimumTierForFeature,
-    getPricingPageTiers,
-    getRateLimiterTiers,
-    getTierConfig,
-    isTierHigher,
-    isValidTier,
-    tierHasFeature
-} from '../tier-config';
-
-describe('Tier Configuration', () => {
-  describe('Tier Enum Consistency', () => {
-    it('should have exactly 6 tiers', () => {
-      expect(TIERS).toHaveLength(6);
-    });
-
-    it('should include all required tiers', () => {
-      const requiredTiers = ['free', 'starter', 'pro', 'compliance', 'enterprise', 'unlimited'];
-      for (const tier of requiredTiers) {
-        expect(TIERS).toContain(tier);
-      }
-    });
-
-    it('should have TIER_CONFIG for every tier in TIERS', () => {
-      for (const tier of TIERS) {
-        expect(TIER_CONFIG[tier]).toBeDefined();
-        expect(TIER_CONFIG[tier].id).toBe(tier);
-        expect(TIER_CONFIG[tier].name).toBeTruthy();
-      }
-    });
-
-    it('should have TIER_ORDER match TIERS', () => {
-      expect(TIER_ORDER).toHaveLength(TIERS.length);
-      for (const tier of TIERS) {
-        expect(TIER_ORDER).toContain(tier);
-      }
-    });
-
-    it('should have purchasable tiers be a subset of all tiers', () => {
-      for (const tier of PURCHASABLE_TIERS) {
-        expect(TIERS).toContain(tier);
-      }
-    });
-
-    it('should not include free or unlimited in purchasable tiers', () => {
-      expect(PURCHASABLE_TIERS).not.toContain('free');
-      expect(PURCHASABLE_TIERS).not.toContain('unlimited');
-    });
-  });
-
-  describe('Tier Configuration Completeness', () => {
-    it('should have all required fields for each tier', () => {
-      for (const tier of TIERS) {
-        const config = TIER_CONFIG[tier];
-        
-        // Required fields
-        expect(config.id).toBe(tier);
-        expect(typeof config.name).toBe('string');
-        expect(typeof config.price).toBe('number');
-        expect(typeof config.annualPrice).toBe('number');
-        expect(typeof config.description).toBe('string');
-        expect(Array.isArray(config.features)).toBe(true);
-        
-        // Limits
-        expect(typeof config.limits.scansPerMonth).toBe('number');
-        expect(typeof config.limits.realityRunsPerMonth).toBe('number');
-        expect(typeof config.limits.aiAgentRunsPerMonth).toBe('number');
-        expect(typeof config.limits.projects).toBe('number');
-        expect(typeof config.limits.teamMembers).toBe('number');
-        expect(typeof config.limits.complianceFrameworks).toBe('number');
-        
-        // Rate limits
-        expect(typeof config.rateLimit.requestsPerMinute).toBe('number');
-        expect(typeof config.rateLimit.burstLimit).toBe('number');
-        expect(typeof config.rateLimit.windowMs).toBe('number');
-        
-        // Upsell
-        expect(typeof config.upsell.message).toBe('string');
-        expect(TIERS).toContain(config.upsell.nextTier);
-      }
-    });
-
-    it('should have features be valid Feature types', () => {
-      for (const tier of TIERS) {
-        const config = TIER_CONFIG[tier];
-        for (const feature of config.features) {
-          expect(FEATURES).toContain(feature);
-        }
-      }
-    });
-
-    it('should have increasing limits as tiers increase', () => {
-      const orderedTiers: Tier[] = ['free', 'starter', 'pro', 'compliance', 'enterprise'];
-      
-      for (let i = 1; i < orderedTiers.length; i++) {
-        const prevTierKey = orderedTiers[i - 1]!;
-        const currTierKey = orderedTiers[i]!;
-        const prevTier = TIER_CONFIG[prevTierKey];
-        const currTier = TIER_CONFIG[currTierKey];
-        
-        // Scans should increase or stay unlimited
-        if (prevTier.limits.scansPerMonth !== -1) {
-          expect(currTier.limits.scansPerMonth).toBeGreaterThanOrEqual(prevTier.limits.scansPerMonth);
-        }
-      }
-    });
-
-    it('should have increasing rate limits as tiers increase', () => {
-      const orderedTiers: Tier[] = ['free', 'starter', 'pro', 'compliance', 'enterprise'];
-      
-      for (let i = 1; i < orderedTiers.length; i++) {
-        const prevTierKey = orderedTiers[i - 1]!;
-        const currTierKey = orderedTiers[i]!;
-        const prevTier = TIER_CONFIG[prevTierKey];
-        const currTier = TIER_CONFIG[currTierKey];
-        
-        expect(currTier.rateLimit.requestsPerMinute).toBeGreaterThanOrEqual(
-          prevTier.rateLimit.requestsPerMinute
-        );
-      }
-    });
-  });
-
-  describe('Pricing Consistency', () => {
-    it('should have free tier at $0', () => {
-      expect(TIER_CONFIG.free.price).toBe(0);
-      expect(TIER_CONFIG.free.annualPrice).toBe(0);
-    });
-
-    it('should have starter at $29/mo', () => {
-      expect(TIER_CONFIG.starter.price).toBe(29);
-    });
-
-    it('should have pro at $99/mo', () => {
-      expect(TIER_CONFIG.pro.price).toBe(99);
-    });
-
-    it('should have compliance at $199/mo', () => {
-      expect(TIER_CONFIG.compliance.price).toBe(199);
-    });
-
-    it('should have annual pricing be exactly 20% off monthly*12', () => {
-      // IMPORTANT: This test ensures the "Save 20%" marketing claim is accurate.
-      // If this test fails, either:
-      // 1. Update annual prices to be exactly 20% off (monthly * 12 * 0.8)
-      // 2. Update the "Save 20%" copy in the UI to match the actual discount
-      const EXPECTED_DISCOUNT = 0.20; // 20% off
-      const TOLERANCE = 0.005; // Allow 0.5% tolerance for rounding
-
-      for (const tier of PURCHASABLE_TIERS) {
-        const config = TIER_CONFIG[tier];
-        if (config.price > 0) {
-          const monthlyTotal = config.price * 12;
-          const expectedAnnual = monthlyTotal * (1 - EXPECTED_DISCOUNT);
-          const actualDiscount = (monthlyTotal - config.annualPrice) / monthlyTotal;
-
-          // Assert the discount is within tolerance of 20%
-          expect(actualDiscount).toBeGreaterThanOrEqual(EXPECTED_DISCOUNT - TOLERANCE);
-          expect(actualDiscount).toBeLessThanOrEqual(EXPECTED_DISCOUNT + TOLERANCE);
-
-          // Also verify the annual price is close to expected (within $2 for rounding)
-          expect(config.annualPrice).toBeGreaterThanOrEqual(expectedAnnual - 2);
-          expect(config.annualPrice).toBeLessThanOrEqual(expectedAnnual + 2);
-        }
-      }
-    });
-  });
-
-  describe('Helper Functions', () => {
-    it('isValidTier should validate tier strings', () => {
-      expect(isValidTier('free')).toBe(true);
-      expect(isValidTier('starter')).toBe(true);
-      expect(isValidTier('pro')).toBe(true);
-      expect(isValidTier('compliance')).toBe(true);
-      expect(isValidTier('enterprise')).toBe(true);
-      expect(isValidTier('unlimited')).toBe(true);
-      expect(isValidTier('invalid')).toBe(false);
-      expect(isValidTier('team')).toBe(false); // Legacy tier should not be valid
-    });
-
-    it('getTierConfig should return correct config', () => {
-      expect(getTierConfig('pro').name).toBe('Pro');
-      expect(getTierConfig('compliance').name).toBe('Compliance');
-    });
-
-    it('compareTiers should correctly order tiers', () => {
-      expect(compareTiers('free', 'pro')).toBeLessThan(0);
-      expect(compareTiers('pro', 'free')).toBeGreaterThan(0);
-      expect(compareTiers('pro', 'pro')).toBe(0);
-      expect(compareTiers('starter', 'compliance')).toBeLessThan(0);
-    });
-
-    it('isTierHigher should correctly compare tiers', () => {
-      expect(isTierHigher('pro', 'free')).toBe(true);
-      expect(isTierHigher('free', 'pro')).toBe(false);
-      expect(isTierHigher('compliance', 'starter')).toBe(true);
-    });
-
-    it('getMinimumTierForFeature should find correct tier', () => {
-      expect(getMinimumTierForFeature('scan')).toBe('free');
-      expect(getMinimumTierForFeature('reality')).toBe('starter');
-      expect(getMinimumTierForFeature('ai-agent')).toBe('pro');
-      expect(getMinimumTierForFeature('compliance:soc2')).toBe('compliance');
-    });
-
-    it('tierHasFeature should check features correctly', () => {
-      expect(tierHasFeature('free', 'scan')).toBe(true);
-      expect(tierHasFeature('free', 'reality')).toBe(false);
-      expect(tierHasFeature('starter', 'reality')).toBe(true);
-      expect(tierHasFeature('unlimited', 'compliance:soc2')).toBe(true);
-    });
-  });
-
-  describe('Pricing Page Integration', () => {
-    it('getPricingPageTiers should return 4 tiers for display', () => {
-      const pricingTiers = getPricingPageTiers();
-      expect(pricingTiers).toHaveLength(4);
-    });
-
-    it('getPricingPageTiers should include free, starter, pro, compliance', () => {
-      const pricingTiers = getPricingPageTiers();
-      const tierIds = pricingTiers.map(t => t.id);
-      
-      expect(tierIds).toContain('free');
-      expect(tierIds).toContain('starter');
-      expect(tierIds).toContain('pro');
-      expect(tierIds).toContain('compliance');
-    });
-
-    it('getPricingPageTiers should mark pro as popular', () => {
-      const pricingTiers = getPricingPageTiers();
-      const proTier = pricingTiers.find(t => t.id === 'pro');
-      
-      expect(proTier?.popular).toBe(true);
-    });
-
-    it('getPricingPageTiers prices should match TIER_CONFIG', () => {
-      const pricingTiers = getPricingPageTiers();
-      
-      for (const tier of pricingTiers) {
-        const config = TIER_CONFIG[tier.id as Tier];
-        expect(tier.price).toBe(config.price);
-        expect(tier.annual).toBe(config.annualPrice);
-        expect(tier.name).toBe(config.name);
-      }
-    });
-  });
-
-  describe('Rate Limiter Integration', () => {
-    it('getRateLimiterTiers should return config for all tiers', () => {
-      const rateLimiterTiers = getRateLimiterTiers();
-      
-      for (const tier of TIERS) {
-        expect(rateLimiterTiers[tier]).toBeDefined();
-        expect(rateLimiterTiers[tier].name).toBe(TIER_CONFIG[tier].name);
-        expect(rateLimiterTiers[tier].baseLimit).toBe(TIER_CONFIG[tier].rateLimit.requestsPerMinute);
-        expect(rateLimiterTiers[tier].burstLimit).toBe(TIER_CONFIG[tier].rateLimit.burstLimit);
-        expect(rateLimiterTiers[tier].windowMs).toBe(TIER_CONFIG[tier].rateLimit.windowMs);
-      }
-    });
-  });
-
-  describe('No Legacy Tiers', () => {
-    it('should not have "team" tier (replaced by compliance)', () => {
-      expect(TIERS).not.toContain('team');
-      expect(TIER_CONFIG).not.toHaveProperty('team');
-    });
-
-    it('should not have "basic" tier', () => {
-      expect(TIERS).not.toContain('basic');
-      expect(TIER_CONFIG).not.toHaveProperty('basic');
-    });
-  });
-});

package/src/__tests__/utils/hash-inline.test.ts

@@ -1,76 +0,0 @@
-// @ts-nocheck
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const crypto = require('node:crypto');
-
-// Inline hash function for testing
-function calculateHash(content) {
-  return crypto.createHash('sha256').update(content).digest('hex');
-}
-
-describe('Hash Utils', () => {
-  describe('calculateHash', () => {
-    it('should generate consistent hash for same input', () => {
-      const input = 'test-input';
-      const hash1 = calculateHash(input);
-      const hash2 = calculateHash(input);
-      
-      expect(hash1).toBe(hash2);
-      expect(hash1).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should generate different hashes for different inputs', () => {
-      const hash1 = calculateHash('input1');
-      const hash2 = calculateHash('input2');
-      
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should handle empty string', () => {
-      const hash = calculateHash('');
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should handle special characters', () => {
-      const input = 'test with spaces and symbols !@#$%^&*()';
-      const hash = calculateHash(input);
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should handle unicode characters', () => {
-      const input = '测试中文 🚀 emoji';
-      const hash = calculateHash(input);
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should handle very long strings', () => {
-      const input = 'a'.repeat(10000);
-      const hash = calculateHash(input);
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-  });
-
-  describe('Security Properties', () => {
-    it('should generate different hashes for similar inputs', () => {
-      const hash1 = calculateHash('password');
-      const hash2 = calculateHash('password ');
-      
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should be case-sensitive', () => {
-      const hash1 = calculateHash('Test');
-      const hash2 = calculateHash('test');
-      
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should produce fixed-length hashes', () => {
-      const inputs = ['a', 'abc', 'a long string with many characters'];
-      const hashes = inputs.map(calculateHash);
-      
-      hashes.forEach(hash => {
-        expect(hash.length).toBe(64);
-      });
-    });
-  });
-});

package/src/__tests__/utils/hash.test.ts

@@ -1,119 +0,0 @@
-// @ts-nocheck
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const crypto = require('node:crypto');
-
-// Hash function for testing
-function calculateHash(content) {
-  return crypto.createHash('sha256').update(content).digest('hex');
-}
-
-// Helper function to verify hash
-function verifyHash(input, hash) {
-  if (!input || !hash) return false;
-  const calculatedHash = crypto.createHash('sha256').update(input).digest('hex');
-  return calculatedHash === hash;
-}
-
-describe('Hash Utils', () => {
-  describe('calculateHash', () => {
-    it('should generate consistent hash for same input', () => {
-      const input = 'test-input';
-      const hash1 = calculateHash(input);
-      const hash2 = calculateHash(input);
-      
-      expect(hash1).toBe(hash2);
-      expect(hash1).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should generate different hashes for different inputs', () => {
-      const hash1 = calculateHash('input1');
-      const hash2 = calculateHash('input2');
-      
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should handle empty string', () => {
-      const hash = calculateHash('');
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should handle special characters', () => {
-      const input = 'test with spaces and symbols !@#$%^&*()';
-      const hash = calculateHash(input);
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should handle unicode characters', () => {
-      const input = '测试中文 🚀 emoji';
-      const hash = calculateHash(input);
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should handle very long strings', () => {
-      const input = 'a'.repeat(10000);
-      const hash = calculateHash(input);
-      expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-  });
-
-  describe('verifyHash', () => {
-    it('should verify correct hash', () => {
-      const input = 'test-input';
-      const hash = calculateHash(input);
-      
-      expect(verifyHash(input, hash)).toBe(true);
-    });
-
-    it('should reject incorrect hash', () => {
-      const input = 'test-input';
-      const wrongHash = calculateHash('different-input');
-      
-      expect(verifyHash(input, wrongHash)).toBe(false);
-    });
-
-    it('should reject empty hash', () => {
-      const input = 'test-input';
-      
-      expect(verifyHash(input, '')).toBe(false);
-    });
-
-    it('should reject invalid hash format', () => {
-      const input = 'test-input';
-      const invalidHash = 'invalid-hash';
-      
-      expect(verifyHash(input, invalidHash)).toBe(false);
-    });
-
-    it('should handle null/undefined inputs', () => {
-      const hash = calculateHash('test');
-      
-      expect(verifyHash(null, hash)).toBe(false);
-      expect(verifyHash(undefined, hash)).toBe(false);
-    });
-  });
-
-  describe('Security Properties', () => {
-    it('should generate different hashes for similar inputs', () => {
-      const hash1 = calculateHash('password');
-      const hash2 = calculateHash('password ');
-      
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should be case-sensitive', () => {
-      const hash1 = calculateHash('Test');
-      const hash2 = calculateHash('test');
-      
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should produce fixed-length hashes', () => {
-      const inputs = ['a', 'abc', 'a long string with many characters'];
-      const hashes = inputs.map(calculateHash);
-      
-      hashes.forEach(hash => {
-        expect(hash.length).toBe(64);
-      });
-    });
-  });
-});

package/src/__tests__/utils/simple.test.ts

@@ -1,10 +0,0 @@
-describe('Simple Test', () => {
-  it('should pass', () => {
-    expect(1 + 1).toBe(2);
-  });
-  
-  it('should handle async', async () => {
-    await new Promise(resolve => setTimeout(resolve, 10));
-    expect(true).toBe(true);
-  });
-});

package/src/__tests__/utils/utils-simple.test.ts

@@ -1,5 +0,0 @@
-describe("Simple Utils Test", () => {
-  it("should pass", () => {
-    expect(true).toBe(true);
-  });
-});