@eltonssouza/development-utility-kit 1.0.0

package/dashboard/test/sprint1.test.js

@@ -0,0 +1,406 @@
+'use strict';
+
+/**
+ * Sprint 1 failing tests — written before implementation (TDD RED phase).
+ * Uses Node.js built-in test runner (node:test) + supertest for HTTP assertions.
+ * Run: node --test dashboard/test/sprint1.test.js
+ */
+
+const { test, describe, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const PUBLIC_DIR = path.join(REPO_ROOT, 'dashboard', 'public');
+
+// ── T-001 / T-005: HTML structure + CSS classes ───────────────────────────────
+
+describe('T-001: index.html tab structure', () => {
+  let html;
+  before(() => {
+    html = fs.readFileSync(path.join(PUBLIC_DIR, 'index.html'), 'utf8');
+  });
+
+  test('contains exactly 3 data-tab attributes', () => {
+    const matches = html.match(/data-tab=/g) || [];
+    assert.equal(matches.length, 3, 'Expected 3 data-tab attributes');
+  });
+
+  test('has data-tab="dashboard"', () => {
+    assert.ok(html.includes('data-tab="dashboard"'), 'Missing data-tab="dashboard"');
+  });
+
+  test('has data-tab="manual"', () => {
+    assert.ok(html.includes('data-tab="manual"'), 'Missing data-tab="manual"');
+  });
+
+  test('has data-tab="docs"', () => {
+    assert.ok(html.includes('data-tab="docs"'), 'Missing data-tab="docs"');
+  });
+
+  test('has .tab-nav element', () => {
+    assert.ok(html.includes('class="tab-nav"') || html.includes("class='tab-nav'"), 'Missing tab-nav class');
+  });
+
+  test('has lang selector with PT and EN options', () => {
+    assert.ok(html.includes('lang-selector') || html.includes('kud_lang'), 'Missing lang selector');
+  });
+
+  test('has marked CDN script tag', () => {
+    assert.ok(html.includes('cdn.jsdelivr.net/npm/marked'), 'Missing marked CDN script');
+  });
+
+  test('has onerror fallback for marked CDN', () => {
+    assert.ok(html.includes('onerror'), 'Missing onerror fallback on marked script tag');
+  });
+
+  test('marked CDN script references vendor/marked.min.js as fallback', () => {
+    assert.ok(html.includes('vendor/marked.min.js'), 'Missing vendor/marked.min.js reference');
+  });
+
+  test('has panel for #dashboard', () => {
+    assert.ok(
+      html.includes('id="panel-dashboard"') || html.includes('id="tab-dashboard"'),
+      'Missing dashboard panel'
+    );
+  });
+
+  test('has panel for #manual', () => {
+    assert.ok(
+      html.includes('id="panel-manual"') || html.includes('id="tab-manual"'),
+      'Missing manual panel'
+    );
+  });
+
+  test('has panel for #docs', () => {
+    assert.ok(
+      html.includes('id="panel-docs"') || html.includes('id="tab-docs"'),
+      'Missing docs panel'
+    );
+  });
+
+  test('existing 3 cards preserved', () => {
+    assert.ok(html.includes('id="projects-card"'), 'Missing projects-card');
+    assert.ok(html.includes('id="models-card"'), 'Missing models-card');
+    assert.ok(html.includes('id="rtk-card"'), 'Missing rtk-card');
+  });
+});
+
+describe('T-001: vendor/marked.min.js exists', () => {
+  test('file exists with size > 10000 bytes', () => {
+    const vendorPath = path.join(PUBLIC_DIR, 'vendor', 'marked.min.js');
+    assert.ok(fs.existsSync(vendorPath), 'vendor/marked.min.js does not exist');
+    const stat = fs.statSync(vendorPath);
+    assert.ok(stat.size > 10000, `vendor/marked.min.js too small: ${stat.size} bytes`);
+  });
+});
+
+// ── T-002: app.js tab engine + language + polling ─────────────────────────────
+
+describe('T-002: app.js tab engine', () => {
+  let js;
+  before(() => {
+    js = fs.readFileSync(path.join(PUBLIC_DIR, 'app.js'), 'utf8');
+  });
+
+  test('contains activateTab function', () => {
+    assert.ok(js.includes('activateTab'), 'Missing activateTab function');
+  });
+
+  test('references tab-nav (at least 2 occurrences of activateTab or tab-nav)', () => {
+    const count = (js.match(/activateTab|tab-nav/g) || []).length;
+    assert.ok(count >= 2, `Expected >= 2 occurrences of activateTab|tab-nav, got ${count}`);
+  });
+
+  test('contains kud_lang localStorage key (at least 2 occurrences)', () => {
+    const count = (js.match(/kud_lang/g) || []).length;
+    assert.ok(count >= 2, `Expected >= 2 occurrences of kud_lang, got ${count}`);
+  });
+
+  test('contains hashchange listener', () => {
+    assert.ok(js.includes('hashchange'), 'Missing hashchange listener');
+  });
+
+  test('contains DOMContentLoaded handler', () => {
+    assert.ok(js.includes('DOMContentLoaded'), 'Missing DOMContentLoaded handler');
+  });
+
+  test('contains translation-banner reference', () => {
+    const count = (js.match(/translation-banner/g) || []).length;
+    assert.ok(count >= 1, `Expected >= 1 occurrence of translation-banner, got ${count}`);
+  });
+
+  test('contains buildToc or generateToc function', () => {
+    const count = (js.match(/buildToc|generateToc/g) || []).length;
+    assert.ok(count >= 1, `Expected >= 1 occurrence of buildToc|generateToc, got ${count}`);
+  });
+
+  test('polling pauses when dashboard tab is not active', () => {
+    // Must reference pausing/clearing interval or conditional check
+    assert.ok(
+      js.includes('clearInterval') || js.includes('pause') || js.includes('activeTab'),
+      'Missing polling pause logic'
+    );
+  });
+
+  test('contains localStorage.setItem for kud_lang', () => {
+    assert.ok(js.includes("localStorage.setItem"), 'Missing localStorage.setItem');
+  });
+
+  test('contains localStorage.getItem for kud_lang', () => {
+    assert.ok(js.includes("localStorage.getItem"), 'Missing localStorage.getItem');
+  });
+});
+
+// ── T-003: /api/docs/* endpoints ──────────────────────────────────────────────
+
+describe('T-003: /api/docs/* server endpoints', () => {
+  let request;
+  let serverModule;
+
+  before(async () => {
+    // We test the Express app directly without starting a real server
+    // by requiring the app factory (we need to refactor server.js to export app,
+    // or we test via supertest with a dynamic port)
+    const supertest = require('supertest');
+
+    // Create a minimal test server that only has the docs routes
+    // by loading the actual server module — but server.js auto-starts.
+    // So we test via HTTP against a running server, or we extract the app.
+    // For TDD: these tests will FAIL until server.js exports `app` OR
+    // we test with a live server.
+    // Strategy: require server-app module that exports Express app without listening.
+    const appPath = path.join(REPO_ROOT, 'dashboard', 'server-app.js');
+    assert.ok(fs.existsSync(appPath), 'server-app.js must exist (extracted Express app for testing)');
+    const { app } = require(appPath);
+    request = supertest(app);
+  });
+
+  test('GET /api/docs/skills returns 200 with JSON array', async () => {
+    const res = await request.get('/api/docs/skills');
+    assert.equal(res.status, 200);
+    assert.ok(Array.isArray(res.body), 'Response body must be an array');
+    assert.ok(res.body.length >= 5, `Expected >= 5 skills, got ${res.body.length}`);
+  });
+
+  test('GET /api/docs/skills entries have required fields', async () => {
+    const res = await request.get('/api/docs/skills');
+    assert.equal(res.status, 200);
+    for (const entry of res.body) {
+      assert.ok(entry.name, 'Missing name field');
+      assert.ok(entry.path, 'Missing path field');
+    }
+  });
+
+  test('GET /api/docs/agents returns 200 with JSON array', async () => {
+    const res = await request.get('/api/docs/agents');
+    assert.equal(res.status, 200);
+    assert.ok(Array.isArray(res.body), 'Response body must be an array');
+    assert.ok(res.body.length >= 5, `Expected >= 5 agents, got ${res.body.length}`);
+  });
+
+  test('GET /api/docs/agents entries have required fields', async () => {
+    const res = await request.get('/api/docs/agents');
+    assert.equal(res.status, 200);
+    for (const entry of res.body) {
+      assert.ok(entry.name, 'Missing name field');
+      assert.ok(entry.path, 'Missing path field');
+    }
+  });
+
+  test('GET /api/docs/adrs returns 200 with JSON array sorted by number', async () => {
+    const res = await request.get('/api/docs/adrs');
+    assert.equal(res.status, 200);
+    assert.ok(Array.isArray(res.body), 'Response body must be an array');
+    assert.ok(res.body.length > 0, 'ADRs array must not be empty');
+    const nums = res.body.map((x) => x.number);
+    for (let i = 1; i < nums.length; i++) {
+      assert.ok(nums[i] >= nums[i - 1], `ADRs not sorted: ${nums[i - 1]} > ${nums[i]}`);
+    }
+  });
+
+  test('GET /api/docs/adrs entries have required fields', async () => {
+    const res = await request.get('/api/docs/adrs');
+    assert.equal(res.status, 200);
+    for (const entry of res.body) {
+      assert.ok(typeof entry.number === 'number', 'Missing/invalid number field');
+      assert.ok(entry.slug, 'Missing slug field');
+      assert.ok(entry.path, 'Missing path field');
+    }
+  });
+
+  test('GET /api/docs/file with valid whitelisted path returns 200', async () => {
+    const res = await request.get('/api/docs/file?path=.claude/agents/analyst.md');
+    assert.equal(res.status, 200);
+    assert.ok(res.text.length > 0, 'Response body must not be empty');
+  });
+
+  test('GET /api/docs/file with path traversal .. returns 403', async () => {
+    const res = await request.get('/api/docs/file?path=../../package.json');
+    assert.equal(res.status, 403);
+  });
+
+  test('GET /api/docs/file with absolute path /etc/passwd returns 403', async () => {
+    const res = await request.get('/api/docs/file?path=/etc/passwd');
+    assert.equal(res.status, 403);
+  });
+
+  test('GET /api/docs/file with Windows drive letter returns 403', async () => {
+    const res = await request.get('/api/docs/file?path=C:\\Windows\\system32\\drivers\\etc\\hosts');
+    assert.equal(res.status, 403);
+  });
+
+  test('GET /api/docs/file with path outside whitelist returns 403', async () => {
+    const res = await request.get('/api/docs/file?path=bin/cli.js');
+    assert.equal(res.status, 403);
+  });
+
+  test('GET /api/docs/file with manifest.json (in whitelist) returns 200', async () => {
+    const res = await request.get('/api/docs/file?path=dashboard/public/content/manifest.json');
+    assert.equal(res.status, 200);
+  });
+
+  test('GET /api/docs/file with SKILL.md (in whitelist) returns 200', async () => {
+    const res = await request.get('/api/docs/file?path=.claude/skills/caveman/SKILL.md');
+    assert.equal(res.status, 200);
+  });
+});
+
+// ── T-004: manifest.json + content directories ────────────────────────────────
+
+describe('T-004: manifest.json and content directories', () => {
+  const contentDir = path.join(PUBLIC_DIR, 'content');
+  const manifestPath = path.join(contentDir, 'manifest.json');
+
+  test('manifest.json exists', () => {
+    assert.ok(fs.existsSync(manifestPath), 'manifest.json does not exist');
+  });
+
+  test('manifest.json is valid JSON', () => {
+    const raw = fs.readFileSync(manifestPath, 'utf8');
+    assert.doesNotThrow(() => JSON.parse(raw), 'manifest.json is not valid JSON');
+  });
+
+  test('manifest.json has 5 manual entries', () => {
+    const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    assert.equal(m.manual.length, 5, `Expected 5 manual entries, got ${m.manual.length}`);
+  });
+
+  test('manifest.json has 5 docs entries', () => {
+    const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    assert.equal(m.docs.length, 5, `Expected 5 docs entries, got ${m.docs.length}`);
+  });
+
+  test('manual entries have required fields', () => {
+    const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    for (const entry of m.manual) {
+      assert.ok(entry.slug || entry.id, 'Manual entry missing slug/id');
+      assert.ok(entry.title_pt, 'Manual entry missing title_pt');
+      assert.ok(entry.title_en, 'Manual entry missing title_en');
+    }
+  });
+
+  test('docs entries have required fields', () => {
+    const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    for (const entry of m.docs) {
+      assert.ok(entry.slug || entry.id, 'Docs entry missing slug/id');
+      assert.ok(entry.title_pt, 'Docs entry missing title_pt');
+      assert.ok(entry.title_en, 'Docs entry missing title_en');
+    }
+  });
+
+  test('manual/ directory exists', () => {
+    assert.ok(fs.existsSync(path.join(contentDir, 'manual')), 'manual/ directory does not exist');
+  });
+
+  test('docs/ directory exists', () => {
+    assert.ok(fs.existsSync(path.join(contentDir, 'docs')), 'docs/ directory does not exist');
+  });
+
+  test('at least 20 .md files in content/', () => {
+    function countMd(dir) {
+      let count = 0;
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) count += countMd(full);
+        else if (entry.name.endsWith('.md')) count++;
+      }
+      return count;
+    }
+    const count = countMd(contentDir);
+    assert.ok(count >= 20, `Expected >= 20 .md files in content/, got ${count}`);
+  });
+});
+
+// ── T-005: CSS classes ────────────────────────────────────────────────────────
+
+describe('T-005: style.css new UI classes', () => {
+  let css;
+  before(() => {
+    css = fs.readFileSync(path.join(PUBLIC_DIR, 'style.css'), 'utf8');
+  });
+
+  test('contains .tab-nav', () => {
+    assert.ok(css.includes('.tab-nav'), 'Missing .tab-nav in style.css');
+  });
+
+  test('contains .tab-panel', () => {
+    assert.ok(css.includes('.tab-panel'), 'Missing .tab-panel in style.css');
+  });
+
+  test('contains .lang-selector', () => {
+    assert.ok(css.includes('.lang-selector'), 'Missing .lang-selector in style.css');
+  });
+
+  test('contains .accordion', () => {
+    assert.ok(css.includes('.accordion'), 'Missing .accordion in style.css');
+  });
+
+  test('contains .toc-sidebar', () => {
+    assert.ok(css.includes('.toc-sidebar'), 'Missing .toc-sidebar in style.css');
+  });
+
+  test('contains .translation-banner', () => {
+    assert.ok(css.includes('.translation-banner'), 'Missing .translation-banner in style.css');
+  });
+
+  test('all 5+ required selectors present (combined check)', () => {
+    const required = ['.tab-nav', '.accordion', '.toc-sidebar', '.translation-banner', '.lang-selector'];
+    const found = required.filter((sel) => css.includes(sel));
+    assert.ok(found.length >= 5, `Expected >= 5 selectors, found: ${found.join(', ')}`);
+  });
+
+  test('contains responsive rule for <= 768px hiding toc-sidebar', () => {
+    assert.ok(
+      css.includes('768px') && (css.includes('toc-sidebar') || css.includes('accordion')),
+      'Missing responsive 768px rule for toc-sidebar or accordion'
+    );
+  });
+});
+
+// ── T-006: Non-regression ─────────────────────────────────────────────────────
+
+describe('T-006: non-regression — /api/stats still works', () => {
+  let request;
+
+  before(async () => {
+    const supertest = require('supertest');
+    const appPath = path.join(REPO_ROOT, 'dashboard', 'server-app.js');
+    assert.ok(fs.existsSync(appPath), 'server-app.js must exist');
+    const { app } = require(appPath);
+    request = supertest(app);
+  });
+
+  test('GET /api/stats returns 200', async () => {
+    const res = await request.get('/api/stats');
+    assert.equal(res.status, 200);
+  });
+
+  test('GET /api/stats returns projects and models fields', async () => {
+    const res = await request.get('/api/stats');
+    assert.equal(res.status, 200);
+    assert.ok(Object.prototype.hasOwnProperty.call(res.body, 'projects'), 'Missing projects field');
+    assert.ok(Object.prototype.hasOwnProperty.call(res.body, 'models'), 'Missing models field');
+  });
+});