@shaykec/claude-teach 0.2.0

package/src/gamification.test.js

@@ -0,0 +1,509 @@
+import { describe, it, expect } from 'vitest';
+import { BELTS, getBelt, getNextBelt, formatDashboard, suggestNext } from './gamification.js';
+
+/* ================================================================== */
+/*  BELTS constant                                                     */
+/* ================================================================== */
+
+describe('BELTS', () => {
+  it('should contain exactly 7 belts', () => {
+    expect(BELTS).toHaveLength(7);
+  });
+
+  it('should have ascending minXP thresholds', () => {
+    for (let i = 1; i < BELTS.length; i++) {
+      expect(BELTS[i].minXP).toBeGreaterThan(BELTS[i - 1].minXP);
+    }
+  });
+
+  it('should have the correct belt names in order', () => {
+    const names = BELTS.map(b => b.name);
+    expect(names).toEqual(['White', 'Yellow', 'Green', 'Blue', 'Purple', 'Brown', 'Black']);
+  });
+
+  it('should start with White at 0 XP', () => {
+    expect(BELTS[0]).toMatchObject({ name: 'White', minXP: 0 });
+  });
+
+  it('should end with Black at 3000 XP', () => {
+    expect(BELTS[6]).toMatchObject({ name: 'Black', minXP: 3000 });
+  });
+
+  it('each belt should have a name, minXP, and badge', () => {
+    for (const belt of BELTS) {
+      expect(belt).toHaveProperty('name');
+      expect(belt).toHaveProperty('minXP');
+      expect(belt).toHaveProperty('badge');
+      expect(typeof belt.name).toBe('string');
+      expect(typeof belt.minXP).toBe('number');
+      expect(typeof belt.badge).toBe('string');
+    }
+  });
+});
+
+/* ================================================================== */
+/*  getBelt(xp)                                                        */
+/* ================================================================== */
+
+describe('getBelt', () => {
+  it('should return White belt for 0 XP', () => {
+    const belt = getBelt(0);
+    expect(belt.name).toBe('White');
+    expect(belt.display).toContain('White');
+  });
+
+  it('should return White belt for 49 XP', () => {
+    const belt = getBelt(49);
+    expect(belt.name).toBe('White');
+  });
+
+  it('should return Yellow belt for exactly 50 XP', () => {
+    const belt = getBelt(50);
+    expect(belt.name).toBe('Yellow');
+    expect(belt.display).toContain('Yellow');
+  });
+
+  it('should return Green belt for 150 XP', () => {
+    const belt = getBelt(150);
+    expect(belt.name).toBe('Green');
+  });
+
+  it('should return Blue belt for 400 XP', () => {
+    const belt = getBelt(400);
+    expect(belt.name).toBe('Blue');
+  });
+
+  it('should return Purple belt for 800 XP', () => {
+    const belt = getBelt(800);
+    expect(belt.name).toBe('Purple');
+  });
+
+  it('should return Brown belt for 1500 XP', () => {
+    const belt = getBelt(1500);
+    expect(belt.name).toBe('Brown');
+  });
+
+  it('should return Black belt (1st Dan) for exactly 3000 XP', () => {
+    const belt = getBelt(3000);
+    expect(belt.name).toBe('Black');
+    expect(belt.dan).toBe(1);
+    expect(belt.display).toContain('1st Dan');
+  });
+
+  it('should return Black belt (2nd Dan) for 6000 XP', () => {
+    const belt = getBelt(6000);
+    expect(belt.name).toBe('Black');
+    expect(belt.dan).toBe(2);
+    expect(belt.display).toContain('2nd Dan');
+  });
+
+  it('should return Black belt (3rd Dan) for 12000 XP', () => {
+    const belt = getBelt(12000);
+    expect(belt.name).toBe('Black');
+    expect(belt.dan).toBe(3);
+    expect(belt.display).toContain('3rd Dan');
+  });
+
+  it('should return Black belt (4th Dan) for 24000 XP', () => {
+    const belt = getBelt(24000);
+    expect(belt.name).toBe('Black');
+    expect(belt.dan).toBe(4);
+    expect(belt.display).toContain('4th Dan');
+  });
+
+  it('should return Black belt (5th Dan) for 48000 XP', () => {
+    const belt = getBelt(48000);
+    expect(belt.name).toBe('Black');
+    expect(belt.dan).toBe(5);
+    expect(belt.display).toContain('5th Dan');
+  });
+
+  it('should return White belt for negative XP', () => {
+    const belt = getBelt(-10);
+    expect(belt.name).toBe('White');
+  });
+
+  it('should stay at Brown belt for 2999 XP', () => {
+    const belt = getBelt(2999);
+    expect(belt.name).toBe('Brown');
+  });
+
+  it('should include badge in display for non-Black belts', () => {
+    const belt = getBelt(150);
+    expect(belt.display).toContain(belt.badge);
+    expect(belt.display).toContain('Belt');
+  });
+
+  it('should return a display string for every XP level', () => {
+    for (const xp of [0, 50, 150, 400, 800, 1500, 3000, 6000]) {
+      const belt = getBelt(xp);
+      expect(typeof belt.display).toBe('string');
+      expect(belt.display.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+/* ================================================================== */
+/*  getNextBelt(xp)                                                    */
+/* ================================================================== */
+
+describe('getNextBelt', () => {
+  it('should return Yellow as next belt for 0 XP', () => {
+    const next = getNextBelt(0);
+    expect(next.name).toBe('Yellow');
+    expect(next.minXP).toBe(50);
+  });
+
+  it('should return Green as next belt for 50 XP', () => {
+    const next = getNextBelt(50);
+    expect(next.name).toBe('Green');
+    expect(next.minXP).toBe(150);
+  });
+
+  it('should return Blue as next belt for 150 XP', () => {
+    const next = getNextBelt(150);
+    expect(next.name).toBe('Blue');
+    expect(next.minXP).toBe(400);
+  });
+
+  it('should return Purple as next belt for 400 XP', () => {
+    const next = getNextBelt(400);
+    expect(next.name).toBe('Purple');
+    expect(next.minXP).toBe(800);
+  });
+
+  it('should return Brown as next belt for 800 XP', () => {
+    const next = getNextBelt(800);
+    expect(next.name).toBe('Brown');
+    expect(next.minXP).toBe(1500);
+  });
+
+  it('should return Black as next belt for 1500 XP', () => {
+    const next = getNextBelt(1500);
+    expect(next.name).toBe('Black');
+    expect(next.minXP).toBe(3000);
+  });
+
+  it('should return next dan target for 3000 XP (already Black)', () => {
+    const next = getNextBelt(3000);
+    expect(next).not.toBeNull();
+    expect(next.minXP).toBe(6000);
+  });
+
+  it('should return next dan target for 6000 XP', () => {
+    const next = getNextBelt(6000);
+    expect(next).not.toBeNull();
+    expect(next.minXP).toBe(12000);
+  });
+
+  it('should return next dan target for 12000 XP', () => {
+    const next = getNextBelt(12000);
+    expect(next).not.toBeNull();
+    expect(next.minXP).toBe(24000);
+  });
+
+  it('should return next dan target for 24000 XP', () => {
+    const next = getNextBelt(24000);
+    expect(next).not.toBeNull();
+    expect(next.minXP).toBe(48000);
+  });
+
+  it('should return null when maxed out (48000+ XP)', () => {
+    const next = getNextBelt(48000);
+    expect(next).toBeNull();
+  });
+
+  it('should return null for very high XP beyond all dans', () => {
+    const next = getNextBelt(100000);
+    expect(next).toBeNull();
+  });
+
+  it('should return White for negative XP (since -5 < 0 which is White minXP)', () => {
+    const next = getNextBelt(-5);
+    // Negative XP is below White's minXP of 0, so White is the first belt with minXP > xp
+    expect(next.name).toBe('White');
+    expect(next.minXP).toBe(0);
+  });
+
+  it('should return Green for 49 XP (still in White, Yellow is next at 50 — but 49 < 50)', () => {
+    const next = getNextBelt(49);
+    expect(next.name).toBe('Yellow');
+    expect(next.minXP).toBe(50);
+  });
+});
+
+/* ================================================================== */
+/*  formatDashboard(progress, registry)                                */
+/* ================================================================== */
+
+describe('formatDashboard', () => {
+  it('should return a string containing the belt name and XP', () => {
+    const progress = { user: { xp: 200, modules_completed: 1 }, modules: {} };
+    const registry = { modules: [{ slug: 'git' }, { slug: 'hooks' }] };
+    const result = formatDashboard(progress, registry);
+    expect(typeof result).toBe('string');
+    expect(result).toContain('Green');
+    expect(result).toContain('200');
+  });
+
+  it('should handle zero XP progress', () => {
+    const progress = { user: { xp: 0, modules_completed: 0 }, modules: {} };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    expect(result).toContain('White');
+    expect(result).toContain('0');
+  });
+
+  it('should handle empty progress gracefully (missing user)', () => {
+    const progress = { modules: {} };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    expect(typeof result).toBe('string');
+    expect(result).toContain('White');
+  });
+
+  it('should handle completely empty progress object', () => {
+    const progress = {};
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    expect(typeof result).toBe('string');
+  });
+
+  it('should handle null/undefined registry gracefully', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const result = formatDashboard(progress, null);
+    expect(typeof result).toBe('string');
+  });
+
+  it('should show module count from registry', () => {
+    const progress = { user: { xp: 0, modules_completed: 2 }, modules: {} };
+    const registry = { modules: [{}, {}, {}] };
+    const result = formatDashboard(progress, registry);
+    expect(result).toContain('2/3');
+  });
+
+  it('should show progress bar when next belt exists', () => {
+    const progress = { user: { xp: 25, modules_completed: 0 }, modules: {} };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    // The progress bar uses characters like [, ], %, █, ░
+    expect(result).toContain('%');
+  });
+
+  it('should show per-module breakdown when modules exist', () => {
+    const progress = {
+      user: { xp: 100 },
+      modules: {
+        git: { status: 'completed', xp_earned: 50, quiz_score: '4/5' },
+        hooks: { status: 'in-progress', xp_earned: 30 },
+      },
+    };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    expect(result).toContain('git');
+    expect(result).toContain('50 XP');
+    expect(result).toContain('quiz: 4/5');
+    expect(result).toContain('hooks');
+  });
+
+  it('should show completed icon for completed modules', () => {
+    const progress = {
+      user: { xp: 50 },
+      modules: {
+        git: { status: 'completed', xp_earned: 50 },
+      },
+    };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    // Completed modules get a checkmark
+    expect(result).toContain('✓');
+  });
+
+  it('should show in-progress icon for in-progress modules', () => {
+    const progress = {
+      user: { xp: 30 },
+      modules: {
+        git: { status: 'in-progress', xp_earned: 30 },
+      },
+    };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    expect(result).toContain('◐');
+  });
+
+  it('should include dashboard border/frame', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = { modules: [] };
+    const result = formatDashboard(progress, registry);
+    expect(result).toContain('ClaudeTeach Dashboard');
+    expect(result).toContain('╔');
+    expect(result).toContain('╚');
+  });
+});
+
+/* ================================================================== */
+/*  suggestNext(progress, registry)                                    */
+/* ================================================================== */
+
+describe('suggestNext', () => {
+  it('should return a string', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = { modules: [] };
+    const result = suggestNext(progress, registry);
+    expect(typeof result).toBe('string');
+  });
+
+  it('should include current belt and XP in output', () => {
+    const progress = { user: { xp: 200 }, modules: {} };
+    const registry = { modules: [] };
+    const result = suggestNext(progress, registry);
+    expect(result).toContain('Green');
+    expect(result).toContain('200');
+  });
+
+  it('should include next belt info when not maxed', () => {
+    const progress = { user: { xp: 200 }, modules: {} };
+    const registry = { modules: [] };
+    const result = suggestNext(progress, registry);
+    expect(result).toContain('Blue');
+    expect(result).toContain('400');
+  });
+
+  it('should suggest in-progress modules first', () => {
+    const progress = {
+      user: { xp: 50 },
+      modules: {
+        git: { status: 'in-progress', walkthrough_step: 3 },
+      },
+    };
+    const registry = {
+      modules: [
+        { slug: 'git', title: 'Git Basics', difficulty: 'beginner' },
+        { slug: 'hooks', title: 'Git Hooks', difficulty: 'intermediate' },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    expect(result).toContain('Continue where you left off');
+    expect(result).toContain('git');
+    expect(result).toContain('step 3');
+  });
+
+  it('should suggest uncompleted modules sorted by difficulty', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = {
+      modules: [
+        { slug: 'advanced-git', title: 'Advanced Git', difficulty: 'advanced', xp: { read: 30 } },
+        { slug: 'git', title: 'Git Basics', difficulty: 'beginner', xp: { read: 10 } },
+        { slug: 'hooks', title: 'Hooks', difficulty: 'intermediate', xp: { read: 20 } },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    expect(result).toContain('Recommended next');
+    // Beginner should appear before advanced in the output
+    const gitPos = result.indexOf('git');
+    const advPos = result.indexOf('advanced-git');
+    expect(gitPos).toBeLessThan(advPos);
+  });
+
+  it('should respect prerequisites — skip modules whose prereqs are not met', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = {
+      modules: [
+        { slug: 'git', title: 'Git Basics', difficulty: 'beginner', prerequisites: [] },
+        { slug: 'advanced-git', title: 'Advanced Git', difficulty: 'advanced', prerequisites: ['git'] },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    expect(result).toContain('git');
+    // advanced-git should NOT appear since prerequisite 'git' is not completed
+    expect(result).not.toContain('advanced-git');
+  });
+
+  it('should include modules whose prerequisites are all completed', () => {
+    const progress = {
+      user: { xp: 50 },
+      modules: {
+        git: { status: 'completed', xp_earned: 50 },
+      },
+    };
+    const registry = {
+      modules: [
+        { slug: 'git', title: 'Git Basics', difficulty: 'beginner', prerequisites: [] },
+        { slug: 'advanced-git', title: 'Advanced Git', difficulty: 'advanced', prerequisites: ['git'] },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    expect(result).toContain('advanced-git');
+  });
+
+  it('should handle empty progress with empty registry', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = { modules: [] };
+    const result = suggestNext(progress, registry);
+    expect(typeof result).toBe('string');
+    expect(result).toContain('White');
+  });
+
+  it('should handle missing user in progress', () => {
+    const progress = { modules: {} };
+    const registry = { modules: [] };
+    const result = suggestNext(progress, registry);
+    expect(typeof result).toBe('string');
+  });
+
+  it('should not suggest completed modules', () => {
+    const progress = {
+      user: { xp: 100 },
+      modules: {
+        git: { status: 'completed', xp_earned: 50 },
+      },
+    };
+    const registry = {
+      modules: [
+        { slug: 'git', title: 'Git Basics', difficulty: 'beginner' },
+        { slug: 'hooks', title: 'Git Hooks', difficulty: 'intermediate' },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    // The "Recommended next" section should only contain hooks, not git
+    const recommendedIdx = result.indexOf('Recommended next');
+    if (recommendedIdx !== -1) {
+      const afterRecommended = result.slice(recommendedIdx);
+      expect(afterRecommended).toContain('hooks');
+      // git only appears in the belt/xp header, not in recommendations
+    }
+  });
+
+  it('should show at most 3 suggestions', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = {
+      modules: [
+        { slug: 'mod1', title: 'Mod 1', difficulty: 'beginner' },
+        { slug: 'mod2', title: 'Mod 2', difficulty: 'beginner' },
+        { slug: 'mod3', title: 'Mod 3', difficulty: 'beginner' },
+        { slug: 'mod4', title: 'Mod 4', difficulty: 'beginner' },
+        { slug: 'mod5', title: 'Mod 5', difficulty: 'beginner' },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    const recommendedIdx = result.indexOf('Recommended next');
+    const afterRecommended = result.slice(recommendedIdx);
+    expect(afterRecommended).toContain('mod1');
+    expect(afterRecommended).toContain('mod2');
+    expect(afterRecommended).toContain('mod3');
+    expect(afterRecommended).not.toContain('mod4');
+    expect(afterRecommended).not.toContain('mod5');
+  });
+
+  it('should show XP info for suggested modules that have xp data', () => {
+    const progress = { user: { xp: 0 }, modules: {} };
+    const registry = {
+      modules: [
+        { slug: 'git', title: 'Git Basics', difficulty: 'beginner', xp: { read: 10, walkthrough: 20 } },
+      ],
+    };
+    const result = suggestNext(progress, registry);
+    // Total XP = 10 + 20 = 30
+    expect(result).toContain('30 XP');
+  });
+});