ai_web/server/filter.test.ts

import { describe, it, expect } from 'vitest';
import {
  getProductsByDateRangeAndCategory,
  getWebsitesByDateRangeAndCategory,
  getProductTrendByDateRangeAndCategory,
  getWebsiteTrendByDateRangeAndCategory,
  getCategoryDistributionByDateRange,
} from './db';

describe('Advanced Filtering Functions', () => {
  // Note: These tests verify that the filtering functions work correctly
  // Results may vary based on actual database content
  describe('Product Filtering', () => {
    it('should get products by date range', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const products = await getProductsByDateRangeAndCategory(startDate, endDate);
      expect(Array.isArray(products)).toBe(true);
    });

    it('should get products by category', async () => {
      const products = await getProductsByDateRangeAndCategory(undefined, undefined, 1);
      expect(Array.isArray(products)).toBe(true);
    });

    it('should get products by date range and category', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const products = await getProductsByDateRangeAndCategory(startDate, endDate, 1);
      expect(Array.isArray(products)).toBe(true);
    });
  });

  describe('Website Filtering', () => {
    it('should get websites by date range', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const websites = await getWebsitesByDateRangeAndCategory(startDate, endDate);
      expect(Array.isArray(websites)).toBe(true);
    });

    it('should get websites by category', async () => {
      const websites = await getWebsitesByDateRangeAndCategory(undefined, undefined, 1);
      expect(Array.isArray(websites)).toBe(true);
    });

    it('should get websites by date range and category', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const websites = await getWebsitesByDateRangeAndCategory(startDate, endDate, 1);
      expect(Array.isArray(websites)).toBe(true);
    });
  });

  describe('Trend Filtering', () => {
    it('should get product trend by date range', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const trend = await getProductTrendByDateRangeAndCategory(startDate, endDate);
      expect(Array.isArray(trend)).toBe(true);

      if (trend.length > 0) {
        expect(trend[0]).toHaveProperty('date');
        expect(trend[0]).toHaveProperty('count');
      }
    });

    it('should get product trend by date range and category', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const trend = await getProductTrendByDateRangeAndCategory(startDate, endDate, 1);
      expect(Array.isArray(trend)).toBe(true);
    });

    it('should get website trend by date range', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const trend = await getWebsiteTrendByDateRangeAndCategory(startDate, endDate);
      expect(Array.isArray(trend)).toBe(true);

      if (trend.length > 0) {
        expect(trend[0]).toHaveProperty('date');
        expect(trend[0]).toHaveProperty('count');
      }
    });

    it('should get website trend by date range and category', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const trend = await getWebsiteTrendByDateRangeAndCategory(startDate, endDate, 1);
      expect(Array.isArray(trend)).toBe(true);
    });
  });

  describe('Category Distribution Filtering', () => {
    it('should get category distribution by date range', async () => {
      const endDate = new Date();
      const startDate = new Date();
      startDate.setDate(startDate.getDate() - 30);

      const dist = await getCategoryDistributionByDateRange(startDate, endDate);
      expect(Array.isArray(dist)).toBe(true);

      if (dist.length > 0) {
        expect(dist[0]).toHaveProperty('categoryName');
        expect(dist[0]).toHaveProperty('productCount');
      }
    });

    it('should handle different date ranges', async () => {
      const endDate = new Date();
      
      // 7 days
      const startDate7 = new Date();
      startDate7.setDate(startDate7.getDate() - 7);
      const dist7 = await getCategoryDistributionByDateRange(startDate7, endDate);
      expect(Array.isArray(dist7)).toBe(true);

      // 90 days
      const startDate90 = new Date();
      startDate90.setDate(startDate90.getDate() - 90);
      const dist90 = await getCategoryDistributionByDateRange(startDate90, endDate);
      expect(Array.isArray(dist90)).toBe(true);
    });
  });

  describe('Edge Cases', () => {
    it('should handle empty date range', async () => {
      const products = await getProductsByDateRangeAndCategory();
      expect(Array.isArray(products)).toBe(true);
      expect(products.length).toBeGreaterThanOrEqual(0);
    });

    it('should handle future date range', async () => {
      const endDate = new Date();
      endDate.setDate(endDate.getDate() + 30);
      const startDate = new Date();
      startDate.setDate(startDate.getDate() + 20);

      const products = await getProductsByDateRangeAndCategory(startDate, endDate);
      expect(Array.isArray(products)).toBe(true);
      // Future dates may still return results if there are pre-dated items
      expect(products.length).toBeGreaterThanOrEqual(0);
    });

    it('should handle invalid category ID', async () => {
      const products = await getProductsByDateRangeAndCategory(undefined, undefined, 99999);
      expect(Array.isArray(products)).toBe(true);
      // Invalid category should return empty or minimal results
      expect(products.length).toBeGreaterThanOrEqual(0);
    });
  });
});