@ucptools/validator 1.0.0 → 1.0.1

package/tests/integration/benchmark.test.ts

@@ -1,207 +0,0 @@
-/**
- * Integration Tests for Benchmark Functionality
- * Tests Issue #2: Industry Benchmark Comparison
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { getDb, benchmarkStats, benchmarkSummary } from '../../src/db/index.js';
-import { eq, sql } from 'drizzle-orm';
-
-// Skip tests if DATABASE_URL is not set
-const skipIfNoDb = !process.env.DATABASE_URL;
-
-describe.skipIf(skipIfNoDb)('Benchmark Integration (Issue #2)', () => {
-  describe('Benchmark Stats Table Structure', () => {
-    it('should have all required score buckets (0-100 in increments of 10)', async () => {
-      const db = getDb();
-      const stats = await db.select().from(benchmarkStats);
-
-      const buckets = stats.map((s) => s.scoreBucket).sort((a, b) => a - b);
-      const expectedBuckets = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
-
-      expect(buckets).toEqual(expectedBuckets);
-    });
-
-    it('should have non-negative counts for all buckets', async () => {
-      const db = getDb();
-      const stats = await db.select().from(benchmarkStats);
-
-      for (const stat of stats) {
-        expect(stat.count).toBeGreaterThanOrEqual(0);
-      }
-    });
-  });
-
-  describe('Benchmark Summary Table', () => {
-    it('should have exactly one summary row', async () => {
-      const db = getDb();
-      const summary = await db.select().from(benchmarkSummary);
-
-      expect(summary).toHaveLength(1);
-      expect(summary[0].id).toBe(1);
-    });
-
-    it('should have valid totalValidations count', async () => {
-      const db = getDb();
-      const summary = await db.select().from(benchmarkSummary);
-
-      expect(summary[0].totalValidations).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should have valid avgScore', async () => {
-      const db = getDb();
-      const summary = await db.select().from(benchmarkSummary);
-
-      if (summary[0].avgScore !== null) {
-        const avgScore = parseFloat(summary[0].avgScore);
-        expect(avgScore).toBeGreaterThanOrEqual(0);
-        expect(avgScore).toBeLessThanOrEqual(100);
-      }
-    });
-
-    it('should have updatedAt timestamp', async () => {
-      const db = getDb();
-      const summary = await db.select().from(benchmarkSummary);
-
-      expect(summary[0].updatedAt).toBeInstanceOf(Date);
-    });
-  });
-
-  describe('Benchmark Recording Logic', () => {
-    // Save original values to restore after tests
-    let originalBucketCount: number;
-    let originalTotalValidations: number;
-    const testBucket = 70;
-
-    beforeAll(async () => {
-      const db = getDb();
-
-      // Get original values
-      const bucketResult = await db
-        .select()
-        .from(benchmarkStats)
-        .where(eq(benchmarkStats.scoreBucket, testBucket));
-      originalBucketCount = bucketResult[0]?.count || 0;
-
-      const summaryResult = await db.select().from(benchmarkSummary);
-      originalTotalValidations = summaryResult[0]?.totalValidations || 0;
-    });
-
-    afterAll(async () => {
-      // Restore original values
-      const db = getDb();
-
-      await db
-        .update(benchmarkStats)
-        .set({ count: originalBucketCount })
-        .where(eq(benchmarkStats.scoreBucket, testBucket));
-
-      await db
-        .update(benchmarkSummary)
-        .set({ totalValidations: originalTotalValidations })
-        .where(eq(benchmarkSummary.id, 1));
-    });
-
-    it('should increment bucket count when score is recorded', async () => {
-      const db = getDb();
-
-      // Get current count
-      const beforeResult = await db
-        .select()
-        .from(benchmarkStats)
-        .where(eq(benchmarkStats.scoreBucket, testBucket));
-      const beforeCount = beforeResult[0]?.count || 0;
-
-      // Increment (simulating what validate.js does)
-      await db
-        .update(benchmarkStats)
-        .set({ count: sql`${benchmarkStats.count} + 1` })
-        .where(eq(benchmarkStats.scoreBucket, testBucket));
-
-      // Verify increment
-      const afterResult = await db
-        .select()
-        .from(benchmarkStats)
-        .where(eq(benchmarkStats.scoreBucket, testBucket));
-
-      expect(afterResult[0].count).toBe(beforeCount + 1);
-    });
-
-    it('should increment total validations in summary', async () => {
-      const db = getDb();
-
-      // Get current total
-      const beforeResult = await db.select().from(benchmarkSummary);
-      const beforeTotal = beforeResult[0]?.totalValidations || 0;
-
-      // Increment
-      await db
-        .update(benchmarkSummary)
-        .set({ totalValidations: sql`${benchmarkSummary.totalValidations} + 1` })
-        .where(eq(benchmarkSummary.id, 1));
-
-      // Verify
-      const afterResult = await db.select().from(benchmarkSummary);
-      expect(afterResult[0].totalValidations).toBe(beforeTotal + 1);
-    });
-  });
-
-  describe('Percentile Calculation', () => {
-    it('should be calculable from bucket data', async () => {
-      const db = getDb();
-
-      // Get all buckets with cumulative counts
-      const stats = await db
-        .select()
-        .from(benchmarkStats)
-        .orderBy(benchmarkStats.scoreBucket);
-
-      // Calculate cumulative
-      let cumulative = 0;
-      const withCumulative = stats.map((s) => {
-        cumulative += s.count;
-        return { ...s, cumulative };
-      });
-
-      // Total is the last cumulative
-      const total = cumulative;
-
-      if (total > 0) {
-        // For a score of 70, calculate percentile
-        const bucket70 = withCumulative.find((s) => s.scoreBucket === 70);
-
-        if (bucket70) {
-          const belowCount = withCumulative
-            .filter((s) => s.scoreBucket < 70)
-            .reduce((sum, s) => sum + s.count, 0);
-
-          const percentile = Math.round((belowCount / total) * 100);
-
-          expect(percentile).toBeGreaterThanOrEqual(0);
-          expect(percentile).toBeLessThanOrEqual(100);
-        }
-      }
-    });
-  });
-});
-
-describe.skipIf(skipIfNoDb)('Validate API Benchmark Response', () => {
-  it('should include benchmark data in validation response format', () => {
-    // This tests the expected response structure from api/validate.js
-    const mockBenchmarkResponse = {
-      percentile: 75,
-      comparison: 'Your site scores better than 75% of sites analyzed',
-      total_sites_analyzed: 100,
-      average_score: 65,
-    };
-
-    expect(mockBenchmarkResponse).toHaveProperty('percentile');
-    expect(mockBenchmarkResponse).toHaveProperty('comparison');
-    expect(mockBenchmarkResponse).toHaveProperty('total_sites_analyzed');
-    expect(mockBenchmarkResponse).toHaveProperty('average_score');
-
-    expect(typeof mockBenchmarkResponse.percentile).toBe('number');
-    expect(mockBenchmarkResponse.percentile).toBeGreaterThanOrEqual(0);
-    expect(mockBenchmarkResponse.percentile).toBeLessThanOrEqual(100);
-  });
-});

package/tests/integration/database.test.ts

@@ -1,163 +0,0 @@
-/**
- * Integration Tests for Database
- * Tests database connectivity and schema
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { getDb, merchants, benchmarkStats, benchmarkSummary } from '../../src/db/index.js';
-import { eq, sql } from 'drizzle-orm';
-
-// Skip tests if DATABASE_URL is not set
-const skipIfNoDb = !process.env.DATABASE_URL;
-
-describe.skipIf(skipIfNoDb)('Database Integration', () => {
-  describe('Connection', () => {
-    it('should connect to the database successfully', async () => {
-      const db = getDb();
-      expect(db).toBeDefined();
-
-      // Simple query to verify connection
-      const result = await db.execute(sql`SELECT 1 as test`);
-      expect(result).toBeDefined();
-    });
-
-    it('should use lazy initialization', () => {
-      // getDb should return the same instance
-      const db1 = getDb();
-      const db2 = getDb();
-      expect(db1).toBe(db2);
-    });
-  });
-
-  describe('Merchants Table', () => {
-    const testDomain = `test-${Date.now()}.example.com`;
-
-    afterAll(async () => {
-      // Clean up test data
-      const db = getDb();
-      await db.delete(merchants).where(eq(merchants.domain, testDomain));
-    });
-
-    it('should insert a merchant', async () => {
-      const db = getDb();
-
-      const result = await db
-        .insert(merchants)
-        .values({
-          domain: testDomain,
-          displayName: 'Test Merchant',
-          description: 'A test merchant for integration testing',
-          category: 'test',
-          countryCode: 'US',
-          ucpScore: 75,
-          ucpGrade: 'C',
-          transports: 'REST',
-          isPublic: true,
-          isVerified: false,
-        })
-        .returning();
-
-      expect(result).toHaveLength(1);
-      expect(result[0].domain).toBe(testDomain);
-      expect(result[0].id).toBeDefined();
-    });
-
-    it('should query merchants', async () => {
-      const db = getDb();
-
-      const result = await db
-        .select()
-        .from(merchants)
-        .where(eq(merchants.domain, testDomain));
-
-      expect(result).toHaveLength(1);
-      expect(result[0].displayName).toBe('Test Merchant');
-      expect(result[0].ucpScore).toBe(75);
-    });
-
-    it('should update a merchant', async () => {
-      const db = getDb();
-
-      await db
-        .update(merchants)
-        .set({ ucpScore: 85, ucpGrade: 'B' })
-        .where(eq(merchants.domain, testDomain));
-
-      const result = await db
-        .select()
-        .from(merchants)
-        .where(eq(merchants.domain, testDomain));
-
-      expect(result[0].ucpScore).toBe(85);
-      expect(result[0].ucpGrade).toBe('B');
-    });
-
-    it('should enforce unique domain constraint', async () => {
-      const db = getDb();
-
-      await expect(
-        db.insert(merchants).values({
-          domain: testDomain,
-          displayName: 'Duplicate Merchant',
-        })
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('Benchmark Stats Table (Issue #2)', () => {
-    it('should have score buckets from 0 to 100', async () => {
-      const db = getDb();
-
-      const result = await db.select().from(benchmarkStats);
-
-      expect(result.length).toBe(11); // 0, 10, 20, ..., 100
-
-      const buckets = result.map((r) => r.scoreBucket).sort((a, b) => a - b);
-      expect(buckets).toEqual([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]);
-    });
-
-    it('should have count field for each bucket', async () => {
-      const db = getDb();
-
-      const result = await db.select().from(benchmarkStats);
-
-      for (const row of result) {
-        expect(typeof row.count).toBe('number');
-        expect(row.count).toBeGreaterThanOrEqual(0);
-      }
-    });
-  });
-
-  describe('Benchmark Summary Table (Issue #2)', () => {
-    it('should have a summary row', async () => {
-      const db = getDb();
-
-      const result = await db.select().from(benchmarkSummary);
-
-      expect(result.length).toBe(1);
-      expect(result[0].id).toBe(1);
-    });
-
-    it('should track total validations', async () => {
-      const db = getDb();
-
-      const result = await db.select().from(benchmarkSummary);
-
-      expect(typeof result[0].totalValidations).toBe('number');
-      expect(result[0].totalValidations).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should track average score', async () => {
-      const db = getDb();
-
-      const result = await db.select().from(benchmarkSummary);
-
-      // avgScore can be null or a string (decimal type)
-      if (result[0].avgScore !== null) {
-        const avgScore = parseFloat(result[0].avgScore);
-        expect(avgScore).toBeGreaterThanOrEqual(0);
-        expect(avgScore).toBeLessThanOrEqual(100);
-      }
-    });
-  });
-});

package/tests/integration/directory-api.test.ts

@@ -1,268 +0,0 @@
-/**
- * Integration Tests for Directory API Endpoints
- * Tests Issue #1: UCP Merchant Directory
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { getDb, merchants } from '../../src/db/index.js';
-import { eq } from 'drizzle-orm';
-import {
-  listMerchants,
-  submitMerchant,
-  getMerchantByDomain,
-  getDirectoryStats,
-  revalidateMerchant,
-} from '../../src/services/directory.js';
-
-// Skip tests if DATABASE_URL is not set
-const skipIfNoDb = !process.env.DATABASE_URL;
-
-describe.skipIf(skipIfNoDb)('Directory API Integration', () => {
-  const testDomains: string[] = [];
-
-  // Helper to create a unique test domain
-  const createTestDomain = () => {
-    const domain = `api-test-${Date.now()}-${Math.random().toString(36).slice(2)}.example.com`;
-    testDomains.push(domain);
-    return domain;
-  };
-
-  afterAll(async () => {
-    // Clean up all test data
-    const db = getDb();
-    for (const domain of testDomains) {
-      await db.delete(merchants).where(eq(merchants.domain, domain));
-    }
-  });
-
-  describe('listMerchants', () => {
-    it('should return empty list when no merchants exist', async () => {
-      const result = await listMerchants({ search: 'nonexistent-unique-query-xyz' });
-
-      expect(result.merchants).toHaveLength(0);
-      expect(result.pagination.total).toBe(0);
-    });
-
-    it('should return correct pagination structure', async () => {
-      const result = await listMerchants({ page: 1, limit: 10 });
-
-      expect(result.pagination).toHaveProperty('page');
-      expect(result.pagination).toHaveProperty('limit');
-      expect(result.pagination).toHaveProperty('total');
-      expect(result.pagination).toHaveProperty('totalPages');
-    });
-
-    it('should return filter options', async () => {
-      const result = await listMerchants({});
-
-      expect(result.filters).toHaveProperty('categories');
-      expect(result.filters).toHaveProperty('countries');
-      expect(Array.isArray(result.filters.categories)).toBe(true);
-      expect(Array.isArray(result.filters.countries)).toBe(true);
-    });
-
-    it('should filter by category', async () => {
-      const db = getDb();
-      const domain1 = createTestDomain();
-      const domain2 = createTestDomain();
-
-      // Create test merchants with different categories
-      await db.insert(merchants).values([
-        { domain: domain1, displayName: 'Fashion Store', category: 'fashion', isPublic: true },
-        { domain: domain2, displayName: 'Tech Store', category: 'electronics', isPublic: true },
-      ]);
-
-      const fashionResult = await listMerchants({ category: 'fashion' });
-      const electronicsResult = await listMerchants({ category: 'electronics' });
-
-      const fashionDomains = fashionResult.merchants.map((m) => m.domain);
-      const electronicsDomains = electronicsResult.merchants.map((m) => m.domain);
-
-      expect(fashionDomains).toContain(domain1);
-      expect(fashionDomains).not.toContain(domain2);
-      expect(electronicsDomains).toContain(domain2);
-      expect(electronicsDomains).not.toContain(domain1);
-    });
-
-    it('should search by domain and display name', async () => {
-      const db = getDb();
-      const domain = createTestDomain();
-
-      await db.insert(merchants).values({
-        domain,
-        displayName: 'Unique Searchable Store XYZ123',
-        isPublic: true,
-      });
-
-      // Search by display name
-      const nameResult = await listMerchants({ search: 'XYZ123' });
-      expect(nameResult.merchants.some((m) => m.domain === domain)).toBe(true);
-
-      // Search by domain
-      const domainResult = await listMerchants({ search: domain.split('.')[0] });
-      expect(domainResult.merchants.some((m) => m.domain === domain)).toBe(true);
-    });
-
-    it('should only return public merchants', async () => {
-      const db = getDb();
-      const publicDomain = createTestDomain();
-      const privateDomain = createTestDomain();
-
-      await db.insert(merchants).values([
-        { domain: publicDomain, displayName: 'Public Store', isPublic: true },
-        { domain: privateDomain, displayName: 'Private Store', isPublic: false },
-      ]);
-
-      const result = await listMerchants({});
-      const domains = result.merchants.map((m) => m.domain);
-
-      expect(domains).toContain(publicDomain);
-      expect(domains).not.toContain(privateDomain);
-    });
-
-    it('should sort by score descending by default', async () => {
-      const db = getDb();
-      const domain1 = createTestDomain();
-      const domain2 = createTestDomain();
-      const domain3 = createTestDomain();
-
-      await db.insert(merchants).values([
-        { domain: domain1, displayName: 'Low Score', ucpScore: 30, isPublic: true },
-        { domain: domain2, displayName: 'High Score', ucpScore: 90, isPublic: true },
-        { domain: domain3, displayName: 'Mid Score', ucpScore: 60, isPublic: true },
-      ]);
-
-      const result = await listMerchants({});
-
-      // Find positions of our test merchants
-      const positions = {
-        high: result.merchants.findIndex((m) => m.domain === domain2),
-        mid: result.merchants.findIndex((m) => m.domain === domain3),
-        low: result.merchants.findIndex((m) => m.domain === domain1),
-      };
-
-      // High score should come before mid, mid before low
-      if (positions.high !== -1 && positions.mid !== -1) {
-        expect(positions.high).toBeLessThan(positions.mid);
-      }
-      if (positions.mid !== -1 && positions.low !== -1) {
-        expect(positions.mid).toBeLessThan(positions.low);
-      }
-    });
-  });
-
-  describe('getMerchantByDomain', () => {
-    it('should return null for non-existent domain', async () => {
-      const result = await getMerchantByDomain('nonexistent-domain-xyz.com');
-      expect(result).toBeNull();
-    });
-
-    it('should find merchant by domain', async () => {
-      const db = getDb();
-      const domain = createTestDomain();
-
-      await db.insert(merchants).values({
-        domain,
-        displayName: 'Test Store',
-        ucpScore: 75,
-      });
-
-      const result = await getMerchantByDomain(domain);
-
-      expect(result).not.toBeNull();
-      expect(result?.domain).toBe(domain);
-      expect(result?.displayName).toBe('Test Store');
-    });
-
-    it('should be case-insensitive', async () => {
-      const db = getDb();
-      const domain = createTestDomain();
-
-      await db.insert(merchants).values({
-        domain: domain.toLowerCase(),
-        displayName: 'Case Test Store',
-      });
-
-      const result = await getMerchantByDomain(domain.toUpperCase());
-
-      expect(result).not.toBeNull();
-    });
-  });
-
-  describe('getDirectoryStats', () => {
-    it('should return stats structure', async () => {
-      const stats = await getDirectoryStats();
-
-      expect(stats).toHaveProperty('totalMerchants');
-      expect(stats).toHaveProperty('verifiedMerchants');
-      expect(stats).toHaveProperty('avgScore');
-      expect(stats).toHaveProperty('totalCategories');
-      expect(stats).toHaveProperty('totalCountries');
-      expect(stats).toHaveProperty('gradeDistribution');
-      expect(stats).toHaveProperty('topCategories');
-      expect(stats).toHaveProperty('recentAdditions');
-    });
-
-    it('should return valid numeric values', async () => {
-      const stats = await getDirectoryStats();
-
-      expect(typeof stats.totalMerchants).toBe('number');
-      expect(stats.totalMerchants).toBeGreaterThanOrEqual(0);
-
-      // verifiedMerchants may be string from SQL aggregate, coerce to number
-      const verifiedCount = Number(stats.verifiedMerchants);
-      expect(verifiedCount).toBeGreaterThanOrEqual(0);
-      expect(verifiedCount).toBeLessThanOrEqual(stats.totalMerchants);
-
-      expect(typeof stats.avgScore).toBe('number');
-      expect(stats.avgScore).toBeGreaterThanOrEqual(0);
-      expect(stats.avgScore).toBeLessThanOrEqual(100);
-    });
-
-    it('should return arrays for distributions', async () => {
-      const stats = await getDirectoryStats();
-
-      expect(Array.isArray(stats.gradeDistribution)).toBe(true);
-      expect(Array.isArray(stats.topCategories)).toBe(true);
-      expect(Array.isArray(stats.recentAdditions)).toBe(true);
-    });
-  });
-
-  describe('submitMerchant', () => {
-    it('should reject domain without UCP profile', async () => {
-      const result = await submitMerchant({
-        domain: 'example.com', // example.com doesn't have UCP
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    it('should reject duplicate domain', async () => {
-      const db = getDb();
-      const domain = createTestDomain();
-
-      // First, insert directly
-      await db.insert(merchants).values({
-        domain,
-        displayName: 'Original Store',
-      });
-
-      // Then try to submit via service
-      const result = await submitMerchant({ domain });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('already registered');
-    });
-
-    it('should clean domain before validation', async () => {
-      // Test that https://, trailing slash, and uppercase are handled
-      const result = await submitMerchant({
-        domain: 'HTTPS://EXAMPLE.COM/',
-      });
-
-      // Should fail for UCP validation, not domain parsing
-      expect(result.error).not.toContain('parse');
-    });
-  });
-});