@soham20/smart-offline-sdk 0.2.1 → 1.0.1

package/src/SmartOfflineTestUtils.ts

@@ -0,0 +1,578 @@
+/**
+ * SmartOffline SDK - Test Utilities
+ *
+ * Provides comprehensive testing utilities for the SmartOffline SDK.
+ * These utilities can be used both in browser console and in test frameworks.
+ *
+ * Usage in browser console:
+ * ```javascript
+ * // Run all tests
+ * await runSmartOfflineTests()
+ *
+ * // Use cache inspector
+ * const inspector = new CacheInspector()
+ * await inspector.showAll()
+ * ```
+ */
+
+import type {
+  SmartOfflineConfig,
+  CacheEvent,
+  UsageData,
+} from "./SmartOfflineSetup";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface TestResult {
+  name: string;
+  passed: boolean;
+  message: string;
+  duration?: number;
+}
+
+export interface CacheInspectorData {
+  cachedItems: Array<{ url: string; size: number; contentType: string }>;
+  usageData: UsageData[];
+  logs: Array<{ type: string; url: string; timestamp: number }>;
+}
+
+// ============================================================================
+// ALGORITHM FUNCTIONS (for testing)
+// ============================================================================
+
+/**
+ * Matches URL against wildcard pattern
+ * This is the same algorithm used in smart-offline-sw.js
+ */
+export function matchesPattern(url: string, pattern: string): boolean {
+  if (!pattern.includes("*")) {
+    return url.includes(pattern);
+  }
+  const regexPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*");
+  return new RegExp(regexPattern).test(url);
+}
+
+/**
+ * Calculates if a URL should be treated as HIGH priority
+ * This is the core caching algorithm
+ */
+export function isHighPriority(
+  usage: UsageData | null,
+  url: string,
+  config: Partial<SmartOfflineConfig> = {},
+): boolean {
+  const defaultConfig: SmartOfflineConfig = {
+    pages: [],
+    apis: [],
+    debug: false,
+    frequencyThreshold: 3,
+    recencyThreshold: 24 * 60 * 60 * 1000,
+    maxResourceSize: Infinity,
+    networkQuality: "auto",
+    significance: {},
+    weights: { frequency: 1, recency: 1, size: 1 },
+    customPriorityFn: null,
+    enableDetailedLogs: false,
+    serviceWorkerPath: "/smart-offline-sw.js",
+    serviceWorkerScope: "/",
+  };
+
+  const finalConfig = { ...defaultConfig, ...config };
+
+  // Custom priority function takes precedence
+  if (
+    finalConfig.customPriorityFn &&
+    typeof finalConfig.customPriorityFn === "function"
+  ) {
+    try {
+      return finalConfig.customPriorityFn(usage, url, finalConfig) > 50;
+    } catch (e) {
+      console.error("Custom priority function error:", e);
+    }
+  }
+
+  // Check significance overrides
+  for (const pattern in finalConfig.significance) {
+    if (url.includes(pattern)) {
+      if (finalConfig.significance[pattern] === "high") return true;
+      if (finalConfig.significance[pattern] === "low") return false;
+    }
+  }
+
+  // No usage data = low priority
+  if (!usage) return false;
+
+  // Calculate weighted priority score
+  const weights = finalConfig.weights || { frequency: 1, recency: 1, size: 1 };
+
+  // Frequency score: 0-100 based on access count vs threshold
+  const frequencyScore = Math.min(
+    100,
+    (usage.count / finalConfig.frequencyThreshold) * 100,
+  );
+
+  // Recency score: 100 for just accessed, 0 for older than threshold
+  const timeSinceAccess = Date.now() - usage.lastAccessed;
+  const recencyScore = Math.max(
+    0,
+    100 - (timeSinceAccess / finalConfig.recencyThreshold) * 100,
+  );
+
+  // Weighted average
+  const totalWeight = weights.frequency + weights.recency;
+  const weightedScore =
+    (frequencyScore * weights.frequency + recencyScore * weights.recency) /
+    totalWeight;
+
+  return weightedScore > 50;
+}
+
+/**
+ * Determines if a URL should be cached based on pattern matching
+ */
+export function shouldCacheUrl(
+  url: string,
+  config: Partial<SmartOfflineConfig> = {},
+): { isPage: boolean; isAPI: boolean } {
+  const pages = config.pages || [];
+  const apis = config.apis || [];
+  const isPage = pages.some((p) => matchesPattern(url, p));
+  const isAPI = apis.some((a) => matchesPattern(url, a));
+  return { isPage, isAPI };
+}
+
+// ============================================================================
+// TEST SUITE CLASS
+// ============================================================================
+
+export class SmartOfflineTestSuite {
+  private results: TestResult[] = [];
+  private config: Partial<SmartOfflineConfig>;
+
+  constructor(config: Partial<SmartOfflineConfig> = {}) {
+    this.config = {
+      pages: ["/admin/*", "/admin/charts", "/admin/charts/*", "/grapher/*"],
+      apis: ["/admin/api/*"],
+      frequencyThreshold: 3,
+      recencyThreshold: 24 * 60 * 60 * 1000,
+      ...config,
+    };
+  }
+
+  /**
+   * Run all tests
+   */
+  async runAll(): Promise<TestResult[]> {
+    this.results = [];
+
+    // Algorithm tests
+    this.testPatternMatching();
+    this.testFrequencyPriority();
+    this.testRecencyPriority();
+    this.testWeightedScoring();
+    this.testSignificanceOverrides();
+
+    // Browser environment tests (if available)
+    if (typeof navigator !== "undefined" && "serviceWorker" in navigator) {
+      await this.testServiceWorkerActive();
+      await this.testCacheAPIAvailable();
+      await this.testIndexedDBAvailable();
+    }
+
+    return this.results;
+  }
+
+  /**
+   * Test pattern matching
+   */
+  private testPatternMatching(): void {
+    const tests = [
+      { url: "/admin/charts", pattern: "/admin/charts", expected: true },
+      { url: "/admin/charts/123", pattern: "/admin/charts/*", expected: true },
+      { url: "/grapher/gdp", pattern: "/grapher/*", expected: true },
+      { url: "/random", pattern: "/admin/*", expected: false },
+    ];
+
+    let passed = true;
+    let message = "All patterns matched correctly";
+
+    for (const test of tests) {
+      const result = matchesPattern(test.url, test.pattern);
+      if (result !== test.expected) {
+        passed = false;
+        message = `Pattern ${test.pattern} failed for ${test.url}`;
+        break;
+      }
+    }
+
+    this.results.push({
+      name: "Pattern Matching",
+      passed,
+      message,
+    });
+  }
+
+  /**
+   * Test frequency-based priority
+   */
+  private testFrequencyPriority(): void {
+    const highUsage: UsageData = {
+      url: "/test",
+      count: 5,
+      lastAccessed: Date.now(),
+    };
+
+    const lowUsage: UsageData = {
+      url: "/test",
+      count: 1,
+      lastAccessed: Date.now() - 25 * 60 * 60 * 1000,
+    };
+
+    const highResult = isHighPriority(highUsage, "/test", this.config);
+    const lowResult = isHighPriority(lowUsage, "/test", this.config);
+
+    this.results.push({
+      name: "Frequency Priority",
+      passed: highResult === true && lowResult === false,
+      message:
+        highResult === true && lowResult === false
+          ? "High frequency URLs correctly prioritized"
+          : `Expected high:true, low:false but got high:${highResult}, low:${lowResult}`,
+    });
+  }
+
+  /**
+   * Test recency-based priority
+   */
+  private testRecencyPriority(): void {
+    const recentUsage: UsageData = {
+      url: "/test",
+      count: 1,
+      lastAccessed: Date.now() - 1000,
+    };
+
+    const oldUsage: UsageData = {
+      url: "/test",
+      count: 1,
+      lastAccessed: Date.now() - 48 * 60 * 60 * 1000,
+    };
+
+    const recentResult = isHighPriority(recentUsage, "/test", this.config);
+    const oldResult = isHighPriority(oldUsage, "/test", this.config);
+
+    this.results.push({
+      name: "Recency Priority",
+      passed: recentResult === true && oldResult === false,
+      message:
+        recentResult === true && oldResult === false
+          ? "Recent URLs correctly prioritized"
+          : `Expected recent:true, old:false but got recent:${recentResult}, old:${oldResult}`,
+    });
+  }
+
+  /**
+   * Test weighted scoring
+   */
+  private testWeightedScoring(): void {
+    const configWithWeights: Partial<SmartOfflineConfig> = {
+      ...this.config,
+      frequencyThreshold: 10,
+      weights: { frequency: 10, recency: 1, size: 1 },
+    };
+
+    // High frequency should win with high frequency weight
+    const highFreq: UsageData = {
+      url: "/test",
+      count: 5,
+      lastAccessed: Date.now() - 20 * 60 * 60 * 1000,
+    };
+
+    const result = isHighPriority(highFreq, "/test", configWithWeights);
+
+    this.results.push({
+      name: "Weighted Scoring",
+      passed: result === true,
+      message:
+        result === true
+          ? "Weighted scoring works correctly"
+          : "Weighted scoring calculation may have issues",
+    });
+  }
+
+  /**
+   * Test significance overrides
+   */
+  private testSignificanceOverrides(): void {
+    const configWithSig: Partial<SmartOfflineConfig> = {
+      ...this.config,
+      significance: { "/important/": "high", "/logs/": "low" },
+    };
+
+    const importantResult = isHighPriority(
+      null,
+      "/important/page",
+      configWithSig,
+    );
+    const logsResult = isHighPriority(
+      { url: "/logs/access", count: 100, lastAccessed: Date.now() },
+      "/logs/access",
+      configWithSig,
+    );
+
+    this.results.push({
+      name: "Significance Overrides",
+      passed: importantResult === true && logsResult === false,
+      message:
+        importantResult === true && logsResult === false
+          ? "Significance overrides work correctly"
+          : `Expected important:true, logs:false but got important:${importantResult}, logs:${logsResult}`,
+    });
+  }
+
+  /**
+   * Test service worker is active
+   */
+  private async testServiceWorkerActive(): Promise<void> {
+    try {
+      const registration = await navigator.serviceWorker.getRegistration();
+      const passed = !!registration?.active;
+
+      this.results.push({
+        name: "Service Worker Active",
+        passed,
+        message: passed
+          ? `Service worker active at scope: ${registration?.scope}`
+          : "No active service worker found",
+      });
+    } catch (e) {
+      this.results.push({
+        name: "Service Worker Active",
+        passed: false,
+        message: `Error: ${e}`,
+      });
+    }
+  }
+
+  /**
+   * Test Cache API is available
+   */
+  private async testCacheAPIAvailable(): Promise<void> {
+    try {
+      const cache = await caches.open("smart-offline-test");
+      const keys = await cache.keys();
+      await caches.delete("smart-offline-test");
+
+      this.results.push({
+        name: "Cache API Available",
+        passed: true,
+        message: "Cache API is accessible",
+      });
+    } catch (e) {
+      this.results.push({
+        name: "Cache API Available",
+        passed: false,
+        message: `Error: ${e}`,
+      });
+    }
+  }
+
+  /**
+   * Test IndexedDB is available
+   */
+  private async testIndexedDBAvailable(): Promise<void> {
+    try {
+      const passed = await new Promise<boolean>((resolve) => {
+        const request = indexedDB.open("smart-offline-test-db", 1);
+        request.onsuccess = () => {
+          request.result.close();
+          indexedDB.deleteDatabase("smart-offline-test-db");
+          resolve(true);
+        };
+        request.onerror = () => resolve(false);
+      });
+
+      this.results.push({
+        name: "IndexedDB Available",
+        passed,
+        message: passed ? "IndexedDB is accessible" : "IndexedDB not available",
+      });
+    } catch (e) {
+      this.results.push({
+        name: "IndexedDB Available",
+        passed: false,
+        message: `Error: ${e}`,
+      });
+    }
+  }
+
+  /**
+   * Print results to console
+   */
+  printResults(): void {
+    console.info("\n========================================");
+    console.info("  SmartOffline SDK Test Results");
+    console.info("========================================\n");
+
+    for (const result of this.results) {
+      console.info(`${result.passed ? "✅" : "❌"} ${result.name}`);
+      console.info(`   ${result.message}\n`);
+    }
+
+    const passed = this.results.filter((r) => r.passed).length;
+    console.info("----------------------------------------");
+    console.info(`Total: ${passed}/${this.results.length} tests passed`);
+    console.info("========================================\n");
+  }
+}
+
+// ============================================================================
+// CACHE INSPECTOR
+// ============================================================================
+
+export class CacheInspector {
+  /**
+   * Get all cached items
+   */
+  async getCachedItems(): Promise<
+    Array<{ url: string; size: number; contentType: string }>
+  > {
+    try {
+      const cache = await caches.open("smart-offline-cache-v2");
+      const keys = await cache.keys();
+
+      const items = [];
+      for (const request of keys) {
+        const response = await cache.match(request);
+        if (response) {
+          items.push({
+            url: request.url,
+            size: parseInt(response.headers.get("content-length") || "0", 10),
+            contentType: response.headers.get("content-type") || "unknown",
+          });
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get usage tracking data
+   */
+  async getUsageData(): Promise<UsageData[]> {
+    return new Promise((resolve) => {
+      try {
+        const request = indexedDB.open("smart-offline-usage-v2", 1);
+        request.onsuccess = () => {
+          const db = request.result;
+          try {
+            const tx = db.transaction("usage", "readonly");
+            const store = tx.objectStore("usage");
+            const getAllReq = store.getAll();
+            getAllReq.onsuccess = () => resolve(getAllReq.result || []);
+            getAllReq.onerror = () => resolve([]);
+          } catch {
+            resolve([]);
+          }
+        };
+        request.onerror = () => resolve([]);
+      } catch {
+        resolve([]);
+      }
+    });
+  }
+
+  /**
+   * Get cache logs
+   */
+  async getLogs(): Promise<
+    Array<{ type: string; url: string; timestamp: number }>
+  > {
+    return new Promise((resolve) => {
+      try {
+        const request = indexedDB.open("smart-offline-logs-v2", 1);
+        request.onsuccess = () => {
+          const db = request.result;
+          try {
+            const tx = db.transaction("logs", "readonly");
+            const store = tx.objectStore("logs");
+            const getAllReq = store.getAll();
+            getAllReq.onsuccess = () => resolve(getAllReq.result || []);
+            getAllReq.onerror = () => resolve([]);
+          } catch {
+            resolve([]);
+          }
+        };
+        request.onerror = () => resolve([]);
+      } catch {
+        resolve([]);
+      }
+    });
+  }
+
+  /**
+   * Show all cache data in console
+   */
+  async showAll(): Promise<void> {
+    console.info("\n🔍 SmartOffline Cache Inspector\n");
+
+    const cachedItems = await this.getCachedItems();
+    console.info(`📦 Cached Items (${cachedItems.length}):`);
+    console.table(cachedItems);
+
+    const usageData = await this.getUsageData();
+    console.info(`\n📊 Usage Tracking (${usageData.length} URLs):`);
+    console.table(
+      usageData.map((u) => ({
+        url: u.url.replace(window.location.origin, ""),
+        count: u.count,
+        lastAccessed: new Date(u.lastAccessed).toLocaleString(),
+      })),
+    );
+
+    const logs = await this.getLogs();
+    console.info(`\n📝 Recent Logs (${logs.length}):`);
+    console.table(logs.slice(-20));
+  }
+
+  /**
+   * Get all data as object
+   */
+  async getAllData(): Promise<CacheInspectorData> {
+    return {
+      cachedItems: await this.getCachedItems(),
+      usageData: await this.getUsageData(),
+      logs: await this.getLogs(),
+    };
+  }
+}
+
+// ============================================================================
+// CONVENIENCE FUNCTION
+// ============================================================================
+
+/**
+ * Run all SmartOffline tests and print results
+ */
+export async function runSmartOfflineTests(
+  config?: Partial<SmartOfflineConfig>,
+): Promise<TestResult[]> {
+  const suite = new SmartOfflineTestSuite(config);
+  const results = await suite.runAll();
+  suite.printResults();
+  return results;
+}
+
+// Export for browser usage
+if (typeof window !== "undefined") {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const win = window as any;
+  win.SmartOfflineTestSuite = SmartOfflineTestSuite;
+  win.runSmartOfflineTests = runSmartOfflineTests;
+  win.CacheInspector = CacheInspector;
+}