@shaykec/claude-teach 0.2.0

package/src/registry.test.js

@@ -0,0 +1,309 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { getModule } from './registry.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import yaml from 'js-yaml';
+
+/* ================================================================== */
+/*  getModule(registry, slug)                                          */
+/* ================================================================== */
+
+describe('getModule', () => {
+  const registry = {
+    modules: [
+      { slug: 'git', title: 'Git Basics', source: 'built-in', difficulty: 'beginner', capabilities: ['content', 'walkthrough'] },
+      { slug: 'hooks', title: 'Git Hooks', source: 'built-in', difficulty: 'intermediate', capabilities: ['content', 'quiz'] },
+      { slug: 'daily-workflow', title: 'Daily Workflow', source: 'built-in', difficulty: 'beginner', capabilities: ['content'] },
+    ],
+  };
+
+  it('should return the module for a known slug', () => {
+    const mod = getModule(registry, 'git');
+    expect(mod).not.toBeNull();
+    expect(mod.slug).toBe('git');
+    expect(mod.title).toBe('Git Basics');
+  });
+
+  it('should return null for an unknown slug', () => {
+    const mod = getModule(registry, 'nonexistent');
+    expect(mod).toBeNull();
+  });
+
+  it('should return the correct module when multiple exist', () => {
+    const mod = getModule(registry, 'hooks');
+    expect(mod.slug).toBe('hooks');
+    expect(mod.title).toBe('Git Hooks');
+  });
+
+  it('should handle empty modules array', () => {
+    const mod = getModule({ modules: [] }, 'git');
+    expect(mod).toBeNull();
+  });
+
+  it('should handle undefined modules', () => {
+    const mod = getModule({}, 'git');
+    expect(mod).toBeNull();
+  });
+
+  it('should throw when passed null registry (no null guard on registry itself)', () => {
+    // getModule uses registry.modules?.find — the optional chaining is on .modules,
+    // but registry itself being null causes a TypeError
+    expect(() => getModule(null, 'git')).toThrow(TypeError);
+  });
+
+  it('should return module with all expected fields', () => {
+    const mod = getModule(registry, 'git');
+    expect(mod).toHaveProperty('slug');
+    expect(mod).toHaveProperty('title');
+    expect(mod).toHaveProperty('source');
+    expect(mod).toHaveProperty('difficulty');
+    expect(mod).toHaveProperty('capabilities');
+  });
+
+  it('should match exact slug only (not partial)', () => {
+    const mod = getModule(registry, 'gi');
+    expect(mod).toBeNull();
+  });
+});
+
+/* ================================================================== */
+/*  Registry entry shape                                               */
+/* ================================================================== */
+
+describe('Registry entry structure', () => {
+  const sampleEntry = {
+    slug: 'git',
+    title: 'Git Basics',
+    description: 'Learn git fundamentals',
+    category: 'version-control',
+    difficulty: 'beginner',
+    tags: ['git', 'vcs'],
+    narrative: false,
+    prerequisites: [],
+    related: ['hooks'],
+    xp: { read: 10, walkthrough: 20 },
+    time: { read: 10 },
+    triggers: ['git-init'],
+    source: 'built-in',
+    capabilities: ['content', 'walkthrough'],
+    _path: '/some/path',
+  };
+
+  it('each entry should have a slug string', () => {
+    expect(typeof sampleEntry.slug).toBe('string');
+    expect(sampleEntry.slug.length).toBeGreaterThan(0);
+  });
+
+  it('each entry should have a title string', () => {
+    expect(typeof sampleEntry.title).toBe('string');
+  });
+
+  it('each entry should have a source field', () => {
+    expect(typeof sampleEntry.source).toBe('string');
+    expect(['built-in', 'local'].includes(sampleEntry.source) || sampleEntry.source.startsWith('pack:')).toBe(true);
+  });
+
+  it('each entry should have a capabilities array', () => {
+    expect(Array.isArray(sampleEntry.capabilities)).toBe(true);
+    expect(sampleEntry.capabilities.length).toBeGreaterThan(0);
+  });
+
+  it('capabilities should always include content', () => {
+    expect(sampleEntry.capabilities).toContain('content');
+  });
+
+  it('xp should be an object with numeric values', () => {
+    expect(typeof sampleEntry.xp).toBe('object');
+    for (const val of Object.values(sampleEntry.xp)) {
+      expect(typeof val).toBe('number');
+    }
+  });
+
+  it('prerequisites should be an array', () => {
+    expect(Array.isArray(sampleEntry.prerequisites)).toBe(true);
+  });
+
+  it('tags should be an array', () => {
+    expect(Array.isArray(sampleEntry.tags)).toBe(true);
+  });
+
+  it('difficulty should be one of beginner, intermediate, advanced', () => {
+    expect(['beginner', 'intermediate', 'advanced']).toContain(sampleEntry.difficulty);
+  });
+});
+
+/* ================================================================== */
+/*  buildRegistry — integration test with temp filesystem              */
+/* ================================================================== */
+
+describe('buildRegistry (filesystem)', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'teach-registry-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Helper: create a minimal module directory structure under
+   * <tmpDir>/packages/modules/<slug>/
+   */
+  function createModule(slug, meta = {}) {
+    const moduleDir = path.join(tmpDir, 'packages', 'modules', slug);
+    fs.mkdirSync(moduleDir, { recursive: true });
+
+    const defaults = {
+      slug,
+      title: slug.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+      description: `Description for ${slug}`,
+      category: 'test',
+      difficulty: 'beginner',
+      tags: [],
+      xp: { read: 10 },
+      time: { read: 5 },
+      prerequisites: [],
+      related: [],
+      triggers: [],
+    };
+
+    const merged = { ...defaults, ...meta };
+    fs.writeFileSync(path.join(moduleDir, 'module.yaml'), yaml.dump(merged), 'utf-8');
+    fs.writeFileSync(path.join(moduleDir, 'content.md'), `# ${merged.title}\n\nContent here.\n`, 'utf-8');
+
+    return moduleDir;
+  }
+
+  it('should return an object with a modules array', async () => {
+    // Even with no modules, buildRegistry should return { modules: [] }
+    // Need to create the packages/modules dir so it doesn't fail
+    fs.mkdirSync(path.join(tmpDir, 'packages', 'modules'), { recursive: true });
+
+    // Import buildRegistry dynamically to avoid side effects at module scope
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+    expect(registry).toHaveProperty('modules');
+    expect(Array.isArray(registry.modules)).toBe(true);
+  });
+
+  it('should discover modules from packages/modules/', async () => {
+    createModule('test-mod-a');
+    createModule('test-mod-b', { difficulty: 'intermediate' });
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    // At minimum should contain our two test modules (may also contain packs/local from home dir)
+    const slugs = registry.modules.map(m => m.slug);
+    expect(slugs).toContain('test-mod-a');
+    expect(slugs).toContain('test-mod-b');
+  });
+
+  it('should populate entry fields from module.yaml', async () => {
+    createModule('my-module', {
+      title: 'My Test Module',
+      description: 'A test',
+      category: 'testing',
+      difficulty: 'advanced',
+      tags: ['test'],
+      xp: { read: 15, quiz: 25 },
+    });
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'my-module');
+    expect(mod).toBeDefined();
+    expect(mod.title).toBe('My Test Module');
+    expect(mod.description).toBe('A test');
+    expect(mod.category).toBe('testing');
+    expect(mod.difficulty).toBe('advanced');
+    expect(mod.tags).toEqual(['test']);
+    expect(mod.xp).toEqual({ read: 15, quiz: 25 });
+    expect(mod.source).toBe('built-in');
+  });
+
+  it('should detect capabilities from existing files', async () => {
+    const moduleDir = createModule('cap-test');
+    // Add optional files
+    fs.writeFileSync(path.join(moduleDir, 'walkthrough.md'), '# Walkthrough\n', 'utf-8');
+    fs.writeFileSync(path.join(moduleDir, 'quiz.md'), '# Quiz\n', 'utf-8');
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'cap-test');
+    expect(mod.capabilities).toContain('content');
+    expect(mod.capabilities).toContain('walkthrough');
+    expect(mod.capabilities).toContain('quiz');
+    expect(mod.capabilities).not.toContain('exercises');
+    expect(mod.capabilities).not.toContain('quick-ref');
+  });
+
+  it('should sort modules by difficulty (beginner first)', async () => {
+    createModule('adv-mod', { difficulty: 'advanced' });
+    createModule('beg-mod', { difficulty: 'beginner' });
+    createModule('int-mod', { difficulty: 'intermediate' });
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    // Filter to only our test modules
+    const testMods = registry.modules.filter(m => ['adv-mod', 'beg-mod', 'int-mod'].includes(m.slug));
+    const slugOrder = testMods.map(m => m.slug);
+    expect(slugOrder.indexOf('beg-mod')).toBeLessThan(slugOrder.indexOf('int-mod'));
+    expect(slugOrder.indexOf('int-mod')).toBeLessThan(slugOrder.indexOf('adv-mod'));
+  });
+
+  it('should write registry.yaml for built-in modules', async () => {
+    createModule('persist-mod');
+
+    const { buildRegistry } = await import('./registry.js');
+    await buildRegistry(tmpDir);
+
+    const registryPath = path.join(tmpDir, 'packages', 'modules', 'registry.yaml');
+    expect(fs.existsSync(registryPath)).toBe(true);
+
+    const content = yaml.load(fs.readFileSync(registryPath, 'utf-8'));
+    expect(content).toHaveProperty('modules');
+    const slugs = content.modules.map(m => m.slug);
+    expect(slugs).toContain('persist-mod');
+  });
+
+  it('should use directory name as fallback slug', async () => {
+    const moduleDir = path.join(tmpDir, 'packages', 'modules', 'fallback-dir');
+    fs.mkdirSync(moduleDir, { recursive: true });
+
+    // Write module.yaml without a slug field
+    const meta = { title: 'Fallback Module', description: 'No slug' };
+    fs.writeFileSync(path.join(moduleDir, 'module.yaml'), yaml.dump(meta), 'utf-8');
+    fs.writeFileSync(path.join(moduleDir, 'content.md'), '# Fallback\n', 'utf-8');
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'fallback-dir');
+    expect(mod).toBeDefined();
+    expect(mod.title).toBe('Fallback Module');
+  });
+
+  it('should skip directories without module.yaml', async () => {
+    // Create a directory without module.yaml
+    const emptyDir = path.join(tmpDir, 'packages', 'modules', 'no-yaml');
+    fs.mkdirSync(emptyDir, { recursive: true });
+    fs.writeFileSync(path.join(emptyDir, 'random.txt'), 'not a module', 'utf-8');
+
+    // Create a valid module
+    createModule('valid-mod');
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const slugs = registry.modules.map(m => m.slug);
+    expect(slugs).toContain('valid-mod');
+    expect(slugs).not.toContain('no-yaml');
+  });
+});