resolve: keep SubscriptionBanner.tsx with optional props

Author: Ryan Roland Dabao

AUDIT_REMEDIATION_SUMMARY.md

@@ -0,0 +1,65 @@
+# Content & Gap Audit - Remediation Summary
+
+## Completed Fixes
+
+### 1. Image Assets (FIXED)
+- Created 11 SVG placeholder images in public/images/illustrations/
+- Created PWA manifest.json
+- Created icon SVGs (32x32, 512x512)
+- Updated all .png references to .svg across components
+
+### 2. Pricing Page (FIXED)
+- Removed pricing navigation item from AppLayout
+- Removed 'pricing' from ActiveView type
+- Removed PricingPage import and case from page.tsx
+- Made SubscriptionBanner props optional (tier?, onUpgrade?)
+
+### 3. Build Status (FIXED)
+- TypeScript compilation: SUCCESS
+- Next.js build: SUCCESS
+
+### 4. Seed Data Verification (CONFIRMED COMPLETE)
+- prisma/seed.ts DOES create assessments (6 total)
+- prisma/seed.ts DOES create guides (beginner/intermediate/advanced)
+- prisma/seed.ts DOES create downloads
+- prisma/seed.ts DOES persist sampleAnswers to Question.sampleAnswer
+
+## Test Status
+
+### Passing
+- Unit tests: 33/33 PASS
+- Core API tests: 226/264 PASS
+
+### Failing (Infrastructure, not code bugs)
+- 38 API integration tests: Require live server at localhost:3000
+  - Error: "Unable to connect. Is the computer able to access the url?"
+  - These are end-to-end user path tests
+
+- 26 component tests: Test setup issues
+  - Error: "global.fetch.mockImplementation is not a function"
+  - Tests need proper vi.mock() setup for fetch
+
+## Remaining Gaps (Non-Critical)
+
+### Content
+- Question bank: 95 seeded (docs target 264+) - expansion needed
+- Real image assets: Using SVG placeholders - replace with actual illustrations
+
+### Features (Per PRD Roadmap)
+- Voice interview mode (Phase 6)
+- Video response review (Phase 6)
+- Portfolio builder (Phase 6)
+- Certificate generation (Nice-to-have)
+
+### Code Quality
+- Component test infrastructure needs fetch mock setup
+- Integration tests need server or TEST_BASE_URL
+- Middleware deprecation warning (use proxy instead)
+
+## Next Steps
+
+1. Replace SVG placeholders with real illustrations
+2. Expand question bank to 264+ questions
+3. Fix test infrastructure (add global.fetch mock)
+4. Run integration tests with TEST_BASE_URL=http://localhost:3000
+5. Consider implementing high-priority Phase 5 features

__tests__/unit/ai-handlers.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the auth helper so we control whether a user is present.
+const getUserFromRequest = vi.fn();
+vi.mock('@/lib/auth-helpers', () => ({
+  getUserFromRequest: (request: Request) => getUserFromRequest(request),
+}));
+
+// Mock the model call so we never hit the real SDK.
+const completeJson = vi.fn();
+vi.mock('@/lib/ai/client', () => ({
+  completeJson: (...args: unknown[]) => completeJson(...args),
+}));
+
+import { createAIHandler, validateShape } from '@/lib/ai/handlers';
+
+interface SampleBody {
+  text: string;
+}
+interface SampleResult {
+  score: number;
+}
+
+function makeConfig() {
+  return {
+    systemPrompt: 'sys',
+    buildUserPrompt: (body: SampleBody) => `user: ${body.text}`,
+    validate: (body: unknown) => {
+      const shape = validateShape(body, ['text']);
+      return shape.ok
+        ? ({ ok: true, value: body as SampleBody } as const)
+        : ({ ok: false, status: 400, error: 'text required' } as const);
+    },
+    onParseFailure: () => ({ ok: false, status: 500, error: 'parse failed' } as const),
+  };
+}
+
+function postReq(body: unknown) {
+  return {
+    json: async () => body,
+  } as unknown as Request;
+}
+
+describe('createAIHandler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    getUserFromRequest.mockResolvedValue({ id: 'u1' });
+  });
+
+  it('returns 401 when no user', async () => {
+    getUserFromRequest.mockResolvedValue(null);
+    const handler = createAIHandler<SampleBody, SampleResult>(makeConfig());
+    const res = await handler(postReq({ text: 'hi' }));
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 400 on invalid body', async () => {
+    const handler = createAIHandler<SampleBody, SampleResult>(makeConfig());
+    const res = await handler(postReq({}));
+    expect(res.status).toBe(400);
+  });
+
+  it('returns 200 with parsed result on success', async () => {
+    completeJson.mockResolvedValue({ score: 9 });
+    const handler = createAIHandler<SampleBody, SampleResult>(makeConfig());
+    const res = await handler(postReq({ text: 'hi' }));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ score: 9 });
+    // Verify the model was called with the built prompt.
+    expect(completeJson).toHaveBeenCalledWith('sys', 'user: hi', expect.anything());
+  });
+
+  it('returns configured error when model output cannot be parsed', async () => {
+    completeJson.mockResolvedValue(null);
+    const handler = createAIHandler<SampleBody, SampleResult>(makeConfig());
+    const res = await handler(postReq({ text: 'hi' }));
+    expect(res.status).toBe(500);
+  });
+
+  it('returns 500 when the model call throws', async () => {
+    completeJson.mockRejectedValue(new Error('boom'));
+    const handler = createAIHandler<SampleBody, SampleResult>(makeConfig());
+    const res = await handler(postReq({ text: 'hi' }));
+    expect(res.status).toBe(500);
+  });
+
+  it('returns 400 on malformed JSON body', async () => {
+    const badReq = {
+      json: async () => {
+        throw new Error('bad json');
+      },
+    } as unknown as Request;
+    const handler = createAIHandler<SampleBody, SampleResult>(makeConfig());
+    const res = await handler(badReq);
+    expect(res.status).toBe(400);
+  });
+});
+
+describe('validateShape', () => {
+  it('passes when all keys present', () => {
+    expect(validateShape({ a: 1, b: 2 }, ['a', 'b']).ok).toBe(true);
+  });
+
+  it('reports missing keys', () => {
+    const result = validateShape({ a: 1 }, ['a', 'b']);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.missing).toEqual(['b']);
+  });
+
+  it('fails on non-object', () => {
+    expect(validateShape(null, ['a']).ok).toBe(false);
+    expect(validateShape(42, ['a']).ok).toBe(false);
+  });
+});

__tests__/unit/ai-json.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { extractJson } from '@/lib/ai/json';
+
+describe('extractJson', () => {
+  it('parses a bare JSON object', () => {
+    expect(extractJson('{"a":1}')).toEqual({ a: 1 });
+  });
+
+  it('parses a bare JSON array', () => {
+    expect(extractJson('[1,2,3]')).toEqual([1, 2, 3]);
+  });
+
+  it('extracts JSON from prose', () => {
+    const text = 'Here is your result:\n{"score": 8, "ok": true}\nHope that helps.';
+    expect(extractJson(text)).toEqual({ score: 8, ok: true });
+  });
+
+  it('extracts JSON wrapped in code fences', () => {
+    const text = '```json\n{"a":1}\n```';
+    expect(extractJson(text)).toEqual({ a: 1 });
+  });
+
+  it('extracts an array embedded in text', () => {
+    const text = 'words ["x","y"] more words';
+    expect(extractJson(text)).toEqual(['x', 'y']);
+  });
+
+  it('returns null for empty input', () => {
+    expect(extractJson('')).toBeNull();
+    expect(extractJson(null as unknown as string)).toBeNull();
+  });
+
+  it('returns null for non-JSON text', () => {
+    expect(extractJson('no json here at all')).toBeNull();
+  });
+
+  it('returns null for malformed JSON', () => {
+    expect(extractJson('{not valid}')).toBeNull();
+  });
+});

__tests__/unit/entitlement.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import {
+  entitlement,
+  FreeEntitlement,
+  type Feature,
+} from '@/lib/subscription/entitlement';
+
+const FEATURES: Feature[] = [
+  'interview',
+  'resume',
+  'coverLetter',
+  'practiceTest',
+  'questionBank',
+  'download',
+  'guide',
+];
+
+describe('FreeEntitlement', () => {
+  const svc = new FreeEntitlement();
+
+  it('reports the free tier', () => {
+    expect(svc.tier).toBe('free');
+  });
+
+  it('allows every feature', () => {
+    for (const f of FEATURES) {
+      expect(svc.canAccess(f)).toBe(true);
+    }
+  });
+
+  it('reports unlimited usage with null remaining', () => {
+    const result = svc.checkUsage('interview', {
+      interviewsThisWeek: 999,
+      resumeReviewsThisMonth: 0,
+      coverLettersThisMonth: 0,
+      practiceTestsThisMonth: 0,
+    });
+    expect(result.allowed).toBe(true);
+    expect(result.remaining).toBeNull();
+  });
+
+  it('exposes null (unlimited) limits, not magic -1', () => {
+    expect(svc.limits.interviewsPerWeek).toBeNull();
+    expect(svc.limits.resumeReviewsPerMonth).toBeNull();
+    expect(svc.limits.coverLettersPerMonth).toBeNull();
+    expect(svc.limits.practiceTestsPerMonth).toBeNull();
+  });
+});
+
+describe('entitlement singleton', () => {
+  it('is a FreeEntitlement instance', () => {
+    expect(entitlement).toBeInstanceOf(FreeEntitlement);
+    expect(entitlement.tier).toBe('free');
+  });
+});

__tests__/unit/export-docx.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { generateDocx } from '@/lib/export/docx';
+
+describe('generateDocx', () => {
+  it('returns a non-empty buffer for simple content', async () => {
+    const buffer = await generateDocx('# Heading\nSome body text\n- bullet', 'Doc');
+    expect(Buffer.isBuffer(buffer)).toBe(true);
+    expect(buffer.length).toBeGreaterThan(0);
+  });
+
+  it('produces a valid DOCX zip (PK magic bytes)', async () => {
+    const buffer = await generateDocx('Hello docx', 'Title');
+    // DOCX files are ZIP archives starting with "PK".
+    expect(buffer[0]).toBe(0x50); // P
+    expect(buffer[1]).toBe(0x4b); // K
+  });
+
+  it('handles empty content without throwing', async () => {
+    const buffer = await generateDocx('', 'Empty');
+    expect(buffer.length).toBeGreaterThan(0);
+  });
+});

__tests__/unit/export-pdf.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { generatePdfBuffer } from '@/lib/export/pdf';
+import { MAX_CONTENT_LENGTH, sanitizeFilename } from '@/lib/export/types';
+
+function countPdfPages(pdf: Buffer): number {
+  // Each page object is declared as `/Type /Page /Parent 2 0 R`.
+  const text = pdf.toString('latin1');
+  return (text.match(/\/Type \/Page \/Parent/g) || []).length;
+}
+
+describe('generatePdfBuffer', () => {
+  it('produces a valid PDF header and trailer', () => {
+    const pdf = generatePdfBuffer('Hello world', 'Test');
+    expect(pdf.slice(0, 8).toString()).toContain('%PDF-1.4');
+    expect(pdf.toString('latin1')).toContain('%%EOF');
+  });
+
+  it('contains the rendered text content', () => {
+    const pdf = generatePdfBuffer('UniqueMarkerText line', 'Title');
+    expect(pdf.toString('latin1')).toContain('UniqueMarkerText line');
+  });
+
+  it('fits short content on a single page', () => {
+    const pdf = generatePdfBuffer('one\ntwo\nthree', 'Short');
+    expect(countPdfPages(pdf)).toBe(1);
+  });
+
+  it('paginates long content instead of truncating', () => {
+    // 1000 lines of unique text -> must span multiple pages (no data loss).
+    const lines: string[] = [];
+    for (let i = 0; i < 1000; i++) lines.push(`Line ${i} unique content`);
+    const content = lines.join('\n');
+    const pdf = generatePdfBuffer(content, 'Long');
+
+    const pages = countPdfPages(pdf);
+    expect(pages).toBeGreaterThan(1);
+
+    // Every unique line must be present in the output (no truncation).
+    for (let i = 0; i < 1000; i += 37) {
+      expect(pdf.toString('latin1')).toContain(`Line ${i} unique content`);
+    }
+  });
+
+  it('escapes parentheses in content', () => {
+    const pdf = generatePdfBuffer('Text with (parens) and \\ slash', 'Esc');
+    expect(pdf.toString('latin1')).toContain('Text with \\(parens\\) and \\\\ slash');
+  });
+});
+
+describe('sanitizeFilename', () => {
+  it('replaces non-alphanumeric chars with underscores', () => {
+    expect(sanitizeFilename('My Resume! @2026')).toBe('My_Resume___2026');
+  });
+  it('falls back when title is empty', () => {
+    expect(sanitizeFilename('')).toBe('document');
+    expect(sanitizeFilename(undefined)).toBe('document');
+  });
+});
+
+describe('MAX_CONTENT_LENGTH', () => {
+  it('is defined and reasonable', () => {
+    expect(MAX_CONTENT_LENGTH).toBe(50_000);
+  });
+});