@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/tests/analytics-view.test.js

@@ -0,0 +1,466 @@
+const fs = require('fs-extra');
+const path = require('path');
+const analytics = require('../lib/learning/analytics');
+const storage = require('../lib/learning/storage');
+
+// Note: analytics-view.js is primarily an interactive CLI component that
+// requires user input via inquirer. These tests focus on integration testing
+// by verifying the analytics-view can successfully load and display data
+// without errors. Full UI testing would require mocking inquirer interactions.
+
+describe('Analytics View Integration', () => {
+  const tempDir = path.join(__dirname, 'temp-analytics-view-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('Data Loading', () => {
+    test('should successfully generate analytics data for display', async () => {
+      // Set up minimal test data
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            skips: [
+              { questionId: 'q1', text: 'Deploy?', category: 'deployment', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            answers: [
+              { questionId: 'q2', text: 'Testing?', category: 'testing', answer: 'Jest' }
+            ]
+          }
+        ]
+      };
+
+      const patterns = {
+        patterns: [
+          {
+            id: 'p1',
+            questionId: 'q1',
+            confidence: 90,
+            timesApplied: 5,
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString()
+          }
+        ]
+      };
+
+      const rules = {
+        rules: [
+          { id: 'r1', enabled: true, timesApplied: 10 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+      await storage.writeLearningData(tempDir, 'learned-rules.json', rules);
+
+      // Generate analytics data (this is what the view uses)
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Verify all required sections exist for view rendering
+      expect(analyticsData.overview).toBeTruthy();
+      expect(analyticsData.skipTrends).toBeTruthy();
+      expect(analyticsData.categoryPreferences).toBeTruthy();
+      expect(analyticsData.patternDistribution).toBeTruthy();
+      expect(analyticsData.decayStatus).toBeTruthy();
+      expect(analyticsData.effectiveness).toBeTruthy();
+      expect(analyticsData.sessionTimeline).toBeTruthy();
+      expect(analyticsData.impactfulPatterns).toBeTruthy();
+      expect(analyticsData.questionStats).toBeTruthy();
+    });
+
+    test('should handle empty learning data gracefully', async () => {
+      // No data files created, should return empty analytics
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      expect(analyticsData.overview.totalSessions).toBe(0);
+      expect(analyticsData.skipTrends).toEqual([]);
+      expect(analyticsData.categoryPreferences).toEqual([]);
+
+      // View should be able to handle this without errors
+      // (actual rendering would require mocking inquirer)
+    });
+
+    test('should provide complete data structure for all views', async () => {
+      // Set up comprehensive test data
+      const skipHistory = {
+        sessions: Array.from({ length: 10 }, (_, i) => ({
+          sessionId: `s${i}`,
+          timestamp: new Date(Date.now() - i * 7 * 24 * 60 * 60 * 1000).toISOString(),
+          skips: [
+            { questionId: `q${i}`, text: `Question ${i}`, category: 'deployment', reason: 'manual' }
+          ]
+        }))
+      };
+
+      const answerHistory = {
+        sessions: Array.from({ length: 10 }, (_, i) => ({
+          sessionId: `s${i}`,
+          timestamp: new Date(Date.now() - i * 7 * 24 * 60 * 60 * 1000).toISOString(),
+          answers: [
+            { questionId: `qa${i}`, text: `Answer ${i}`, category: 'testing', answer: `Answer ${i}`, wordCount: 10 }
+          ]
+        }))
+      };
+
+      const patterns = {
+        patterns: Array.from({ length: 5 }, (_, i) => ({
+          id: `p${i}`,
+          questionId: `q${i}`,
+          confidence: 70 + (i * 5),
+          timesApplied: 5 + i,
+          createdAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+          lastSeen: new Date(Date.now() - i * 24 * 60 * 60 * 1000).toISOString()
+        }))
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Verify main dashboard data
+      expect(analyticsData.overview.totalSessions).toBeGreaterThan(0);
+      expect(analyticsData.overview.learningAge).toBeGreaterThanOrEqual(0);
+
+      // Verify skip trends data (for trends view)
+      expect(analyticsData.skipTrends.length).toBeGreaterThan(0);
+      expect(analyticsData.skipTrends[0]).toHaveProperty('week');
+      expect(analyticsData.skipTrends[0]).toHaveProperty('totalSkips');
+      expect(analyticsData.skipTrends[0]).toHaveProperty('skipRate');
+
+      // Verify category preferences data (for category view)
+      expect(analyticsData.categoryPreferences.length).toBeGreaterThan(0);
+      expect(analyticsData.categoryPreferences[0]).toHaveProperty('category');
+      expect(analyticsData.categoryPreferences[0]).toHaveProperty('skipRate');
+      expect(analyticsData.categoryPreferences[0]).toHaveProperty('level');
+
+      // Verify pattern distribution data (for pattern health view)
+      expect(analyticsData.patternDistribution).toHaveProperty('totalPatterns');
+      expect(analyticsData.patternDistribution).toHaveProperty('distribution');
+      expect(analyticsData.patternDistribution).toHaveProperty('avgConfidence');
+
+      // Verify decay status data (for pattern health view)
+      expect(analyticsData.decayStatus).toHaveProperty('healthy');
+      expect(analyticsData.decayStatus).toHaveProperty('warning');
+      expect(analyticsData.decayStatus).toHaveProperty('critical');
+
+      // Verify effectiveness data (for main dashboard)
+      expect(analyticsData.effectiveness).toHaveProperty('timeSavedMinutes');
+      expect(analyticsData.effectiveness).toHaveProperty('patternAccuracy');
+      expect(analyticsData.effectiveness).toHaveProperty('overallEffectiveness');
+
+      // Verify session timeline data (for timeline view)
+      expect(analyticsData.sessionTimeline).toHaveProperty('totalSessions');
+      expect(analyticsData.sessionTimeline).toHaveProperty('avgSessionsPerWeek');
+      expect(analyticsData.sessionTimeline.sessions).toBeTruthy();
+
+      // Verify impactful patterns data (for impact view)
+      expect(analyticsData.impactfulPatterns.byTimeSaved).toBeTruthy();
+      expect(analyticsData.impactfulPatterns.byApplications).toBeTruthy();
+
+      // Verify question stats data (for questions view)
+      expect(analyticsData.questionStats.mostAnswered).toBeTruthy();
+      expect(analyticsData.questionStats.mostSkipped).toBeTruthy();
+      expect(analyticsData.questionStats.totalUniqueQuestions).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('Display Data Validation', () => {
+    test('should provide valid skip trend chart data', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            skips: [{ questionId: 'q1', reason: 'manual' }]
+          },
+          {
+            sessionId: 's2',
+            timestamp: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+            skips: [{ questionId: 'q2', reason: 'filtered' }]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Validate skip trends can be rendered in ASCII chart
+      for (const trend of analyticsData.skipTrends) {
+        expect(trend.week).toMatch(/^\d{4}-W\d{2}$/);
+        expect(trend.totalSkips).toBeGreaterThanOrEqual(0);
+        expect(trend.skipRate).toBeGreaterThanOrEqual(0);
+        expect(trend.skipRate).toBeLessThanOrEqual(100);
+      }
+    });
+
+    test('should provide valid category distribution data', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' },
+              { questionId: 'q2', category: 'testing', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Validate category preferences can be rendered in heatmap
+      for (const category of analyticsData.categoryPreferences) {
+        expect(category.category).toBeTruthy();
+        expect(category.total).toBeGreaterThan(0);
+        expect(category.skipRate).toBeGreaterThanOrEqual(0);
+        expect(category.skipRate).toBeLessThanOrEqual(100);
+        expect(['High Skip', 'Medium Skip', 'Low Skip']).toContain(category.level);
+      }
+    });
+
+    test('should provide valid pattern distribution percentages', async () => {
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 95, timesApplied: 10 },
+          { id: 'p2', confidence: 85, timesApplied: 5 },
+          { id: 'p3', confidence: 65, timesApplied: 2 },
+          { id: 'p4', confidence: 45, timesApplied: 1 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      const dist = analyticsData.patternDistribution.distribution;
+
+      // Validate distribution totals equal totalPatterns
+      const total = dist.high + dist.medium + dist.low + dist.veryLow;
+      expect(total).toBe(analyticsData.patternDistribution.totalPatterns);
+
+      // All counts should be non-negative
+      expect(dist.high).toBeGreaterThanOrEqual(0);
+      expect(dist.medium).toBeGreaterThanOrEqual(0);
+      expect(dist.low).toBeGreaterThanOrEqual(0);
+      expect(dist.veryLow).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should provide valid effectiveness percentages', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', reason: 'filtered' },
+              { questionId: 'q2', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 90, timesApplied: 10 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      const eff = analyticsData.effectiveness;
+
+      // All percentage fields should be 0-100
+      expect(eff.falsePositiveRate).toBeGreaterThanOrEqual(0);
+      expect(eff.falsePositiveRate).toBeLessThanOrEqual(100);
+      expect(eff.patternAccuracy).toBeGreaterThanOrEqual(0);
+      expect(eff.patternAccuracy).toBeLessThanOrEqual(100);
+      expect(eff.overallEffectiveness).toBeGreaterThanOrEqual(0);
+      expect(eff.overallEffectiveness).toBeLessThanOrEqual(100);
+
+      // Time saved should be positive
+      expect(eff.timeSavedMinutes).toBeGreaterThanOrEqual(0);
+      expect(eff.timeSavedHours).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('View Requirements', () => {
+    test('should provide impactful patterns sorted by time saved', async () => {
+      const patterns = {
+        patterns: [
+          { id: 'p1', questionId: 'q1', confidence: 90, timesApplied: 20 },
+          { id: 'p2', questionId: 'q2', confidence: 85, timesApplied: 5 },
+          { id: 'p3', questionId: 'q3', confidence: 95, timesApplied: 15 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Top patterns by time saved should be sorted descending
+      const byTimeSaved = analyticsData.impactfulPatterns.byTimeSaved;
+      expect(byTimeSaved.length).toBeGreaterThan(0);
+
+      if (byTimeSaved.length > 1) {
+        for (let i = 0; i < byTimeSaved.length - 1; i++) {
+          expect(byTimeSaved[i].timeSaved).toBeGreaterThanOrEqual(byTimeSaved[i + 1].timeSaved);
+        }
+      }
+    });
+
+    test('should provide impactful patterns sorted by applications', async () => {
+      const patterns = {
+        patterns: [
+          { id: 'p1', questionId: 'q1', confidence: 90, timesApplied: 20 },
+          { id: 'p2', questionId: 'q2', confidence: 85, timesApplied: 5 },
+          { id: 'p3', questionId: 'q3', confidence: 95, timesApplied: 15 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Top patterns by applications should be sorted descending
+      const byApplications = analyticsData.impactfulPatterns.byApplications;
+      expect(byApplications.length).toBeGreaterThan(0);
+
+      if (byApplications.length > 1) {
+        for (let i = 0; i < byApplications.length - 1; i++) {
+          expect(byApplications[i].timesApplied).toBeGreaterThanOrEqual(byApplications[i + 1].timesApplied);
+        }
+      }
+    });
+
+    test('should provide question statistics with top answers and skips', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', text: 'Deploy?', reason: 'manual' },
+              { questionId: 'q1', text: 'Deploy?', reason: 'manual' },
+              { questionId: 'q2', text: 'CI/CD?', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            answers: [
+              { questionId: 'qa1', text: 'Testing?', answer: 'Jest' },
+              { questionId: 'qa1', text: 'Testing?', answer: 'Jest' },
+              { questionId: 'qa1', text: 'Testing?', answer: 'Jest' },
+              { questionId: 'qa2', text: 'Framework?', answer: 'React' }
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Most answered questions should be sorted by count
+      const mostAnswered = analyticsData.questionStats.mostAnswered;
+      expect(mostAnswered.length).toBeGreaterThan(0);
+      expect(mostAnswered[0].count).toBeGreaterThanOrEqual(mostAnswered[mostAnswered.length - 1]?.count || 0);
+
+      // Most skipped questions should be sorted by count
+      const mostSkipped = analyticsData.questionStats.mostSkipped;
+      expect(mostSkipped.length).toBeGreaterThan(0);
+      expect(mostSkipped[0].count).toBeGreaterThanOrEqual(mostSkipped[mostSkipped.length - 1]?.count || 0);
+
+      // Should have unique question count
+      expect(analyticsData.questionStats.totalUniqueQuestions).toBeGreaterThan(0);
+    });
+
+    test('should provide session timeline with frequency metrics', async () => {
+      const skipHistory = {
+        sessions: Array.from({ length: 10 }, (_, i) => ({
+          sessionId: `s${i}`,
+          timestamp: new Date(Date.now() - i * 7 * 24 * 60 * 60 * 1000).toISOString(),
+          skips: []
+        }))
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      const timeline = analyticsData.sessionTimeline;
+
+      expect(timeline.totalSessions).toBe(10);
+      expect(timeline.avgSessionsPerWeek).toBeGreaterThan(0);
+      expect(timeline.sessions.length).toBeGreaterThan(0);
+
+      // Sessions should be sorted by date (most recent first)
+      if (timeline.sessions.length > 1) {
+        const dates = timeline.sessions.map(s => new Date(s.date).getTime());
+        for (let i = 0; i < dates.length - 1; i++) {
+          expect(dates[i]).toBeGreaterThanOrEqual(dates[i + 1]);
+        }
+      }
+    });
+  });
+
+  describe('Export Integration', () => {
+    test('should provide data compatible with both JSON and CSV export', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            skips: [{ questionId: 'q1', category: 'deployment', reason: 'manual' }]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const analyticsData = await analytics.generateAnalytics(tempDir);
+
+      // Data should be exportable (this validates data structure)
+      expect(analyticsData.version).toBe('1.0');
+      expect(analyticsData.exportedAt).toBeTruthy();
+      expect(analyticsData.overview).toBeTruthy();
+      expect(analyticsData.skipTrends).toBeTruthy();
+      expect(analyticsData.categoryPreferences).toBeTruthy();
+      expect(analyticsData.patternDistribution).toBeTruthy();
+      expect(analyticsData.decayStatus).toBeTruthy();
+      expect(analyticsData.effectiveness).toBeTruthy();
+
+      // All arrays should be valid for CSV export
+      expect(Array.isArray(analyticsData.skipTrends)).toBe(true);
+      expect(Array.isArray(analyticsData.categoryPreferences)).toBe(true);
+    });
+  });
+});