@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/tests/analytics-exporter.test.js

@@ -0,0 +1,477 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { exportAnalytics } = require('../lib/learning/analytics-exporter');
+
+describe('Analytics Exporter', () => {
+  const tempDir = path.join(__dirname, 'temp-exporter-test');
+
+  const sampleAnalyticsData = {
+    version: '1.0',
+    exportedAt: new Date().toISOString(),
+    overview: {
+      totalSessions: 10,
+      totalSkips: 50,
+      manualSkips: 30,
+      filteredSkips: 20,
+      totalAnswers: 100,
+      activePatterns: 5,
+      activeRules: 3,
+      learningAge: 45
+    },
+    skipTrends: [
+      {
+        week: '2025-W01',
+        weekNumber: 1,
+        manualSkips: 5,
+        filteredSkips: 3,
+        totalSkips: 8,
+        skipRate: 40
+      },
+      {
+        week: '2025-W02',
+        weekNumber: 2,
+        manualSkips: 4,
+        filteredSkips: 2,
+        totalSkips: 6,
+        skipRate: 35
+      }
+    ],
+    categoryPreferences: [
+      {
+        category: 'deployment',
+        skips: 20,
+        answers: 10,
+        total: 30,
+        skipRate: 66.7,
+        level: 'High Skip'
+      },
+      {
+        category: 'testing',
+        skips: 5,
+        answers: 20,
+        total: 25,
+        skipRate: 20,
+        level: 'Low Skip'
+      }
+    ],
+    patternDistribution: {
+      totalPatterns: 15,
+      distribution: {
+        high: 5,
+        medium: 6,
+        low: 3,
+        veryLow: 1
+      },
+      avgConfidence: 78,
+      atRiskCount: 2
+    },
+    decayStatus: {
+      healthy: 10,
+      warning: 3,
+      critical: 2,
+      recentlyRenewed: 4,
+      avgAge: 35
+    },
+    effectiveness: {
+      timeSavedMinutes: 120,
+      timeSavedHours: 2,
+      questionsFiltered: 60,
+      falsePositives: 3,
+      falsePositiveRate: 5,
+      patternAccuracy: 87.5,
+      totalRuleApplications: 45,
+      avgApplicationsPerRule: 15,
+      overallEffectiveness: 85
+    }
+  };
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('JSON Export', () => {
+    test('should export analytics as JSON file', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      expect(result.format).toBe('json');
+      expect(result.file).toBeTruthy();
+      expect(result.size).toBeTruthy();
+
+      // Verify file exists
+      const fileExists = await fs.pathExists(result.file);
+      expect(fileExists).toBe(true);
+
+      // Verify file contains valid JSON
+      const content = await fs.readJSON(result.file);
+      expect(content.version).toBe('1.0');
+      expect(content.overview.totalSessions).toBe(10);
+      expect(content.skipTrends.length).toBe(2);
+    });
+
+    test('should create exports directory if it does not exist', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      const exportsPath = path.join(tempDir, '.adf', 'learning', 'exports');
+      const dirExists = await fs.pathExists(exportsPath);
+
+      expect(dirExists).toBe(true);
+      expect(result.file).toContain('exports');
+    });
+
+    test('should include timestamp in filename', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      const filename = path.basename(result.file);
+      expect(filename).toMatch(/^analytics-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.json$/);
+    });
+
+    test('should report file size in KB', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      expect(result.size).toMatch(/^\d+\.\d{2} KB$/);
+    });
+
+    test('should format JSON with proper indentation', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      const content = await fs.readFile(result.file, 'utf8');
+
+      // Should be pretty-printed with 2-space indentation
+      expect(content).toContain('  "version"');
+      expect(content).toContain('  "overview"');
+    });
+
+    test('should preserve all data fields', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+      const content = await fs.readJSON(result.file);
+
+      expect(content).toHaveProperty('version');
+      expect(content).toHaveProperty('exportedAt');
+      expect(content).toHaveProperty('overview');
+      expect(content).toHaveProperty('skipTrends');
+      expect(content).toHaveProperty('categoryPreferences');
+      expect(content).toHaveProperty('patternDistribution');
+      expect(content).toHaveProperty('decayStatus');
+      expect(content).toHaveProperty('effectiveness');
+    });
+  });
+
+  describe('CSV Export', () => {
+    test('should export analytics as multiple CSV files', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      expect(result.format).toBe('csv');
+      expect(result.files).toBeTruthy();
+      expect(result.files.length).toBe(5);
+
+      // Verify all files exist
+      for (const file of result.files) {
+        const fileExists = await fs.pathExists(file);
+        expect(fileExists).toBe(true);
+      }
+    });
+
+    test('should create overview CSV with correct headers', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      const overviewFile = result.files.find(f => f.includes('overview'));
+      const content = await fs.readFile(overviewFile, 'utf8');
+
+      expect(content).toContain('Metric,Value,Unit');
+      expect(content).toContain('Total Sessions,10,sessions');
+      expect(content).toContain('Total Skips,50,questions');
+      expect(content).toContain('Manual Skips,30,questions');
+      expect(content).toContain('Filtered Skips,20,questions');
+      expect(content).toContain('Total Answers,100,questions');
+      expect(content).toContain('Active Patterns,5,patterns');
+      expect(content).toContain('Active Rules,3,rules');
+      expect(content).toContain('Learning Age,45,days');
+    });
+
+    test('should create skip trends CSV with correct data', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      const trendsFile = result.files.find(f => f.includes('skip-trends'));
+      const content = await fs.readFile(trendsFile, 'utf8');
+
+      expect(content).toContain('Week,Week Number,Manual Skips,Filtered Skips,Total Skips,Skip Rate (%)');
+      expect(content).toContain('2025-W01,1,5,3,8,40');
+      expect(content).toContain('2025-W02,2,4,2,6,35');
+    });
+
+    test('should create categories CSV with correct data', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      const categoriesFile = result.files.find(f => f.includes('categories'));
+      const content = await fs.readFile(categoriesFile, 'utf8');
+
+      expect(content).toContain('Category,Skips,Answers,Total,Skip Rate (%),Level');
+      expect(content).toContain('deployment,20,10,30,66.7,High Skip');
+      expect(content).toContain('testing,5,20,25,20,Low Skip');
+    });
+
+    test('should create patterns CSV with distribution and decay data', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      const patternsFile = result.files.find(f => f.includes('patterns'));
+      const content = await fs.readFile(patternsFile, 'utf8');
+
+      expect(content).toContain('Metric,Value,Description');
+      expect(content).toContain('Total Patterns,15,All patterns');
+      expect(content).toContain('High Confidence (90%+),5,Very strong patterns');
+      expect(content).toContain('Medium Confidence (75-89%),6,Strong patterns');
+      expect(content).toContain('Low Confidence (50-74%),3,Weak patterns');
+      expect(content).toContain('Very Low Confidence (<50%),1,Very weak patterns');
+      expect(content).toContain('Average Confidence,78%,Mean confidence score');
+      expect(content).toContain('At Risk,2,Patterns at risk of removal');
+      expect(content).toContain('Decay Status');
+      expect(content).toContain('Healthy Patterns,10,Active and strong');
+      expect(content).toContain('Warning Patterns,3,Needs attention');
+      expect(content).toContain('Critical Patterns,2,May be removed soon');
+      expect(content).toContain('Recently Renewed,4,Last 30 days');
+      expect(content).toContain('Average Age,35 days,Mean pattern age');
+    });
+
+    test('should create effectiveness CSV with all metrics', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      const effectivenessFile = result.files.find(f => f.includes('effectiveness'));
+      const content = await fs.readFile(effectivenessFile, 'utf8');
+
+      expect(content).toContain('Metric,Value,Unit');
+      expect(content).toContain('Time Saved,120,minutes');
+      expect(content).toContain('Time Saved (Hours),2,hours');
+      expect(content).toContain('Questions Filtered,60,questions');
+      expect(content).toContain('False Positives,3,questions');
+      expect(content).toContain('False Positive Rate,5,%');
+      expect(content).toContain('Pattern Accuracy,87.5,%');
+      expect(content).toContain('Total Rule Applications,45,applications');
+      expect(content).toContain('Avg Applications Per Rule,15,applications');
+      expect(content).toContain('Overall Effectiveness,85,%');
+    });
+
+    test('should include timestamp in CSV filenames', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'csv');
+
+      for (const file of result.files) {
+        const filename = path.basename(file);
+        expect(filename).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}/);
+      }
+    });
+
+    test('should escape CSV values with special characters', async () => {
+      const dataWithSpecialChars = {
+        ...sampleAnalyticsData,
+        categoryPreferences: [
+          {
+            category: 'test,with,commas',
+            skips: 5,
+            answers: 10,
+            total: 15,
+            skipRate: 33.3,
+            level: 'Low Skip'
+          },
+          {
+            category: 'test"with"quotes',
+            skips: 3,
+            answers: 7,
+            total: 10,
+            skipRate: 30,
+            level: 'Low Skip'
+          }
+        ]
+      };
+
+      const result = await exportAnalytics(dataWithSpecialChars, tempDir, 'csv');
+
+      const categoriesFile = result.files.find(f => f.includes('categories'));
+      const content = await fs.readFile(categoriesFile, 'utf8');
+
+      expect(content).toContain('"test,with,commas"');
+      expect(content).toContain('"test""with""quotes"');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should throw error for unsupported format', async () => {
+      await expect(
+        exportAnalytics(sampleAnalyticsData, tempDir, 'xml')
+      ).rejects.toThrow('Unsupported export format: xml');
+    });
+
+    test('should default to JSON format if not specified', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir);
+
+      expect(result.format).toBe('json');
+      expect(result.file).toBeTruthy();
+    });
+
+    test('should handle empty analytics data gracefully', async () => {
+      const emptyData = {
+        version: '1.0',
+        exportedAt: new Date().toISOString(),
+        overview: {},
+        skipTrends: [],
+        categoryPreferences: [],
+        patternDistribution: {},
+        decayStatus: {},
+        effectiveness: {}
+      };
+
+      const result = await exportAnalytics(emptyData, tempDir, 'json');
+
+      expect(result.format).toBe('json');
+      expect(result.file).toBeTruthy();
+
+      const content = await fs.readJSON(result.file);
+      expect(content.version).toBe('1.0');
+    });
+
+    test('should handle missing optional fields', async () => {
+      const minimalData = {
+        version: '1.0',
+        exportedAt: new Date().toISOString(),
+        overview: {
+          totalSessions: 0,
+          totalSkips: 0,
+          totalAnswers: 0
+        },
+        skipTrends: [],
+        categoryPreferences: [],
+        patternDistribution: { totalPatterns: 0 },
+        decayStatus: {},
+        effectiveness: {}
+      };
+
+      const result = await exportAnalytics(minimalData, tempDir, 'csv');
+
+      expect(result.format).toBe('csv');
+      expect(result.files.length).toBe(5);
+
+      // All files should be created even with minimal data
+      for (const file of result.files) {
+        const fileExists = await fs.pathExists(file);
+        expect(fileExists).toBe(true);
+      }
+    });
+  });
+
+  describe('File Management', () => {
+    test('should create exports in .adf/learning/exports directory', async () => {
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      expect(result.file).toContain(path.join('.adf', 'learning', 'exports'));
+    });
+
+    test('should allow multiple exports without overwriting', async () => {
+      const result1 = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      // Wait 1 second to ensure different timestamp (timestamp is truncated to seconds)
+      await new Promise(resolve => setTimeout(resolve, 1100));
+
+      const result2 = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      expect(result1.file).not.toBe(result2.file);
+
+      const file1Exists = await fs.pathExists(result1.file);
+      const file2Exists = await fs.pathExists(result2.file);
+
+      expect(file1Exists).toBe(true);
+      expect(file2Exists).toBe(true);
+    });
+
+    test('should create valid paths on Windows', async () => {
+      // This test ensures path.join is used correctly for cross-platform compatibility
+      const result = await exportAnalytics(sampleAnalyticsData, tempDir, 'json');
+
+      expect(result.file).not.toContain('//');
+      expect(result.file).not.toContain('\\\\');
+
+      const fileExists = await fs.pathExists(result.file);
+      expect(fileExists).toBe(true);
+    });
+  });
+
+  describe('Data Integrity', () => {
+    test('should preserve numeric precision in JSON export', async () => {
+      const preciseData = {
+        ...sampleAnalyticsData,
+        categoryPreferences: [
+          {
+            category: 'test',
+            skips: 1,
+            answers: 3,
+            total: 4,
+            skipRate: 33.333333333,
+            level: 'Low Skip'
+          }
+        ]
+      };
+
+      const result = await exportAnalytics(preciseData, tempDir, 'json');
+      const content = await fs.readJSON(result.file);
+
+      expect(content.categoryPreferences[0].skipRate).toBe(33.333333333);
+    });
+
+    test('should preserve unicode characters in CSV export', async () => {
+      const unicodeData = {
+        ...sampleAnalyticsData,
+        categoryPreferences: [
+          {
+            category: '测试分类',
+            skips: 5,
+            answers: 10,
+            total: 15,
+            skipRate: 33.3,
+            level: 'Low Skip'
+          }
+        ]
+      };
+
+      const result = await exportAnalytics(unicodeData, tempDir, 'csv');
+
+      const categoriesFile = result.files.find(f => f.includes('categories'));
+      const content = await fs.readFile(categoriesFile, 'utf8');
+
+      expect(content).toContain('测试分类');
+    });
+
+    test('should handle very large datasets efficiently', async () => {
+      const largeData = {
+        ...sampleAnalyticsData,
+        skipTrends: Array.from({ length: 1000 }, (_, i) => ({
+          week: `2025-W${i + 1}`,
+          weekNumber: i + 1,
+          manualSkips: Math.floor(Math.random() * 10),
+          filteredSkips: Math.floor(Math.random() * 10),
+          totalSkips: Math.floor(Math.random() * 20),
+          skipRate: Math.random() * 100
+        })),
+        categoryPreferences: Array.from({ length: 100 }, (_, i) => ({
+          category: `category-${i}`,
+          skips: Math.floor(Math.random() * 50),
+          answers: Math.floor(Math.random() * 50),
+          total: Math.floor(Math.random() * 100),
+          skipRate: Math.random() * 100,
+          level: 'Medium Skip'
+        }))
+      };
+
+      const startTime = Date.now();
+      const result = await exportAnalytics(largeData, tempDir, 'json');
+      const endTime = Date.now();
+
+      // Should complete in reasonable time (< 2 seconds)
+      expect(endTime - startTime).toBeLessThan(2000);
+      expect(result.file).toBeTruthy();
+
+      const fileExists = await fs.pathExists(result.file);
+      expect(fileExists).toBe(true);
+    });
+  });
+});