@xiboplayer/stats 0.1.0

package/src/stats-collector.test.js

@@ -0,0 +1,461 @@
+/**
+ * Tests for StatsCollector and formatStats
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { StatsCollector, formatStats } from './stats-collector.js';
+
+describe('StatsCollector', () => {
+  let collector;
+
+  beforeEach(async () => {
+    collector = new StatsCollector();
+    await collector.init();
+    await collector.clearAllStats();
+  });
+
+  afterEach(async () => {
+    if (collector && collector.db) {
+      await collector.clearAllStats();
+      collector.db.close();
+    }
+  });
+
+  describe('constructor and initialization', () => {
+    it('should create a new collector', () => {
+      const c = new StatsCollector();
+      expect(c).toBeDefined();
+      expect(c.db).toBeNull();
+      expect(c.inProgressStats).toBeInstanceOf(Map);
+    });
+
+    it('should initialize IndexedDB', async () => {
+      const c = new StatsCollector();
+      await c.init();
+      expect(c.db).toBeDefined();
+      expect(c.db.name).toBe('xibo-player-stats');
+      c.db.close();
+    });
+
+    it('should be idempotent (safe to call init multiple times)', async () => {
+      await collector.init();
+      await collector.init();
+      expect(collector.db).toBeDefined();
+    });
+
+    it('should handle missing IndexedDB gracefully', async () => {
+      const originalIndexedDB = global.indexedDB;
+      global.indexedDB = undefined;
+
+      const c = new StatsCollector();
+      await expect(c.init()).rejects.toThrow('IndexedDB not available');
+
+      global.indexedDB = originalIndexedDB;
+    });
+  });
+
+  describe('layout tracking', () => {
+    it('should start tracking a layout', async () => {
+      await collector.startLayout(123, 456);
+
+      const key = 'layout-123';
+      expect(collector.inProgressStats.has(key)).toBe(true);
+
+      const stat = collector.inProgressStats.get(key);
+      expect(stat.type).toBe('layout');
+      expect(stat.layoutId).toBe(123);
+      expect(stat.scheduleId).toBe(456);
+      expect(stat.start).toBeInstanceOf(Date);
+      expect(stat.end).toBeNull();
+      expect(stat.count).toBe(1);
+      expect(stat.submitted).toBe(0);
+    });
+
+    it('should warn on duplicate start', async () => {
+      await collector.startLayout(123, 456);
+      await collector.startLayout(123, 456);
+
+      // Should still have only one entry
+      expect(collector.inProgressStats.size).toBe(1);
+    });
+
+    it('should end tracking a layout', async () => {
+      await collector.startLayout(123, 456);
+
+      // Wait a bit to ensure duration > 0
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      await collector.endLayout(123, 456);
+
+      // Should be removed from in-progress
+      const key = 'layout-123';
+      expect(collector.inProgressStats.has(key)).toBe(false);
+
+      // Should be saved to database
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(1);
+      expect(stats[0].type).toBe('layout');
+      expect(stats[0].layoutId).toBe(123);
+      expect(stats[0].scheduleId).toBe(456);
+      expect(stats[0].duration).toBeGreaterThanOrEqual(0); // Allow 0 for fast execution
+      expect(stats[0].end).toBeInstanceOf(Date);
+    });
+
+    it('should handle end without start', async () => {
+      // Should not throw
+      await collector.endLayout(999, 888);
+
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(0);
+    });
+
+    it('should calculate duration correctly', async () => {
+      await collector.startLayout(123, 456);
+
+      // Wait 1 second
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      await collector.endLayout(123, 456);
+
+      const stats = await collector.getAllStats();
+      expect(stats[0].duration).toBeGreaterThanOrEqual(1);
+      expect(stats[0].duration).toBeLessThan(2);
+    });
+
+    it('should track multiple layouts simultaneously', async () => {
+      await collector.startLayout(123, 456);
+      await collector.startLayout(789, 456);
+
+      expect(collector.inProgressStats.size).toBe(2);
+
+      await collector.endLayout(123, 456);
+      expect(collector.inProgressStats.size).toBe(1);
+
+      await collector.endLayout(789, 456);
+      expect(collector.inProgressStats.size).toBe(0);
+
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(2);
+    });
+  });
+
+  describe('widget tracking', () => {
+    it('should start tracking a widget', async () => {
+      await collector.startWidget(111, 123, 456);
+
+      const key = 'media-111-123';
+      expect(collector.inProgressStats.has(key)).toBe(true);
+
+      const stat = collector.inProgressStats.get(key);
+      expect(stat.type).toBe('media');
+      expect(stat.mediaId).toBe(111);
+      expect(stat.layoutId).toBe(123);
+      expect(stat.scheduleId).toBe(456);
+      expect(stat.start).toBeInstanceOf(Date);
+      expect(stat.end).toBeNull();
+    });
+
+    it('should end tracking a widget', async () => {
+      await collector.startWidget(111, 123, 456);
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      await collector.endWidget(111, 123, 456);
+
+      const key = 'media-111-123';
+      expect(collector.inProgressStats.has(key)).toBe(false);
+
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(1);
+      expect(stats[0].type).toBe('media');
+      expect(stats[0].mediaId).toBe(111);
+      expect(stats[0].duration).toBeGreaterThanOrEqual(0); // Allow 0 for fast execution
+    });
+
+    it('should handle multiple widgets in same layout', async () => {
+      await collector.startWidget(111, 123, 456);
+      await collector.startWidget(222, 123, 456);
+      await collector.startWidget(333, 123, 456);
+
+      expect(collector.inProgressStats.size).toBe(3);
+
+      await collector.endWidget(111, 123, 456);
+      await collector.endWidget(222, 123, 456);
+      await collector.endWidget(333, 123, 456);
+
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(3);
+      expect(stats.every(s => s.type === 'media')).toBe(true);
+    });
+  });
+
+  describe('stats submission flow', () => {
+    it('should get unsubmitted stats', async () => {
+      // Create some stats
+      await collector.startLayout(123, 456);
+      await collector.endLayout(123, 456);
+
+      await collector.startLayout(789, 456);
+      await collector.endLayout(789, 456);
+
+      const stats = await collector.getStatsForSubmission();
+      expect(stats.length).toBe(2);
+      expect(stats.every(s => s.submitted === 0)).toBe(true);
+    });
+
+    it('should respect limit parameter', async () => {
+      // Create 5 stats
+      for (let i = 0; i < 5; i++) {
+        await collector.startLayout(100 + i, 456);
+        await collector.endLayout(100 + i, 456);
+      }
+
+      const stats = await collector.getStatsForSubmission(3);
+      expect(stats.length).toBe(3);
+    });
+
+    it('should return empty array when no unsubmitted stats', async () => {
+      const stats = await collector.getStatsForSubmission();
+      expect(stats).toEqual([]);
+    });
+
+    it('should clear submitted stats', async () => {
+      // Create stats
+      await collector.startLayout(123, 456);
+      await collector.endLayout(123, 456);
+
+      await collector.startLayout(789, 456);
+      await collector.endLayout(789, 456);
+
+      // Get stats
+      const stats = await collector.getStatsForSubmission();
+      expect(stats.length).toBe(2);
+
+      // Clear them
+      await collector.clearSubmittedStats(stats);
+
+      // Verify they're gone
+      const remaining = await collector.getAllStats();
+      expect(remaining.length).toBe(0);
+    });
+
+    it('should handle clearing empty array', async () => {
+      await collector.clearSubmittedStats([]);
+      // Should not throw
+    });
+
+    it('should handle clearing null', async () => {
+      await collector.clearSubmittedStats(null);
+      // Should not throw
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle operations without initialization', async () => {
+      const c = new StatsCollector();
+
+      // Should not throw, but should log warnings
+      await c.startLayout(123, 456);
+      await c.endLayout(123, 456);
+      await c.startWidget(111, 123, 456);
+      await c.endWidget(111, 123, 456);
+
+      const stats = await c.getStatsForSubmission();
+      expect(stats).toEqual([]);
+    });
+
+    it('should handle interrupted playback', async () => {
+      // Start layout but never end it
+      await collector.startLayout(123, 456);
+
+      // Create a new collector (simulating app restart)
+      const newCollector = new StatsCollector();
+      await newCollector.init();
+
+      // Should still be able to track new stats
+      await newCollector.startLayout(789, 456);
+      await newCollector.endLayout(789, 456);
+
+      const stats = await newCollector.getAllStats();
+      expect(stats.length).toBe(1);
+      expect(stats[0].layoutId).toBe(789);
+
+      newCollector.db.close();
+    });
+
+    it('should handle invalid stat IDs in clearSubmittedStats', async () => {
+      const invalidStats = [
+        { id: null, layoutId: 123 },
+        { id: undefined, layoutId: 456 },
+        { layoutId: 789 } // No id property
+      ];
+
+      // Should not throw
+      await collector.clearSubmittedStats(invalidStats);
+    });
+  });
+
+  describe('database operations', () => {
+    it('should get all stats', async () => {
+      // Create mixed stats
+      await collector.startLayout(123, 456);
+      await collector.endLayout(123, 456);
+
+      await collector.startWidget(111, 123, 456);
+      await collector.endWidget(111, 123, 456);
+
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(2);
+      expect(stats.some(s => s.type === 'layout')).toBe(true);
+      expect(stats.some(s => s.type === 'media')).toBe(true);
+    });
+
+    it('should clear all stats', async () => {
+      // Create stats
+      await collector.startLayout(123, 456);
+      await collector.endLayout(123, 456);
+
+      await collector.startWidget(111, 123, 456);
+      await collector.endWidget(111, 123, 456);
+
+      await collector.clearAllStats();
+
+      const stats = await collector.getAllStats();
+      expect(stats.length).toBe(0);
+      expect(collector.inProgressStats.size).toBe(0);
+    });
+  });
+});
+
+describe('formatStats', () => {
+  it('should format empty stats', () => {
+    const xml = formatStats([]);
+    expect(xml).toBe('<stats></stats>');
+  });
+
+  it('should format null stats', () => {
+    const xml = formatStats(null);
+    expect(xml).toBe('<stats></stats>');
+  });
+
+  it('should format layout stat', () => {
+    const stats = [{
+      type: 'layout',
+      layoutId: 123,
+      scheduleId: 456,
+      start: new Date('2026-02-10T12:00:00Z'),
+      end: new Date('2026-02-10T12:05:00Z'),
+      duration: 300,
+      count: 1
+    }];
+
+    const xml = formatStats(stats);
+    expect(xml).toContain('<stats>');
+    expect(xml).toContain('</stats>');
+    expect(xml).toContain('type="layout"');
+    expect(xml).toContain('layoutid="123"');
+    expect(xml).toContain('scheduleid="456"');
+    expect(xml).toContain('duration="300"');
+    expect(xml).toContain('count="1"');
+    expect(xml).toContain('fromdt=');
+    expect(xml).toContain('todt=');
+  });
+
+  it('should format media stat', () => {
+    const stats = [{
+      type: 'media',
+      mediaId: 789,
+      layoutId: 123,
+      scheduleId: 456,
+      start: new Date('2026-02-10T12:00:00Z'),
+      end: new Date('2026-02-10T12:01:00Z'),
+      duration: 60,
+      count: 1
+    }];
+
+    const xml = formatStats(stats);
+    expect(xml).toContain('type="media"');
+    expect(xml).toContain('mediaid="789"');
+    expect(xml).toContain('layoutid="123"');
+    expect(xml).toContain('duration="60"');
+  });
+
+  it('should format multiple stats', () => {
+    const stats = [
+      {
+        type: 'layout',
+        layoutId: 123,
+        scheduleId: 456,
+        start: new Date('2026-02-10T12:00:00Z'),
+        end: new Date('2026-02-10T12:05:00Z'),
+        duration: 300,
+        count: 1
+      },
+      {
+        type: 'media',
+        mediaId: 789,
+        layoutId: 123,
+        scheduleId: 456,
+        start: new Date('2026-02-10T12:00:00Z'),
+        end: new Date('2026-02-10T12:01:00Z'),
+        duration: 60,
+        count: 1
+      }
+    ];
+
+    const xml = formatStats(stats);
+    const statCount = (xml.match(/<stat /g) || []).length;
+    expect(statCount).toBe(2);
+  });
+
+  it('should escape XML special characters', () => {
+    const stats = [{
+      type: 'layout',
+      layoutId: 123,
+      scheduleId: 456,
+      start: new Date('2026-02-10T12:00:00Z'),
+      end: new Date('2026-02-10T12:00:00Z'),
+      duration: 0,
+      count: 1
+    }];
+
+    const xml = formatStats(stats);
+    // Should not contain unescaped characters
+    expect(xml).not.toContain('&amp;amp;');
+    expect(xml).not.toContain('&lt;lt;');
+  });
+
+  it('should format dates correctly', () => {
+    const stats = [{
+      type: 'layout',
+      layoutId: 123,
+      scheduleId: 456,
+      start: new Date('2026-02-10T12:34:56Z'),
+      end: new Date('2026-02-10T12:35:56Z'),
+      duration: 60,
+      count: 1
+    }];
+
+    const xml = formatStats(stats);
+    // Should contain date in YYYY-MM-DD HH:MM:SS format
+    expect(xml).toMatch(/fromdt="\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}"/);
+    expect(xml).toMatch(/todt="\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}"/);
+  });
+
+  it('should handle missing end date', () => {
+    const stats = [{
+      type: 'layout',
+      layoutId: 123,
+      scheduleId: 456,
+      start: new Date('2026-02-10T12:00:00Z'),
+      end: null,
+      duration: 0,
+      count: 1
+    }];
+
+    const xml = formatStats(stats);
+    // Should use start date for both fromdt and todt
+    expect(xml).toContain('fromdt=');
+    expect(xml).toContain('todt=');
+  });
+});

package/vitest.config.js

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: './vitest.setup.js'
+  }
+});

package/vitest.setup.js

@@ -0,0 +1,2 @@
+// Setup fake-indexeddb for testing
+import 'fake-indexeddb/auto';