Fix up tests and build

Author: zackproser

src/app/api/articles/[slug]/__tests__/route.test.ts

@@ -3,20 +3,18 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { jest } from '@jest/globals';
 
-// Mock the importContentMetadata function
+// Mock the content-handlers functions
 jest.mock('@/lib/content-handlers', () => ({
-  importContentMetadata: jest.fn()
+  getContentItemByDirectorySlug: jest.fn()
 }));
 
 // Import the mocked function
-import { importContentMetadata } from '@/lib/content-handlers';
-
-// Mock the route handlers directly
-const mockGET = jest.fn();
+import { getContentItemByDirectorySlug } from '@/lib/content-handlers';
 
 // Mock the route module
+const mockGET = jest.fn() as jest.MockedFunction<any>;
 jest.mock('../route', () => ({
-  GET: (...args: any[]) => mockGET(...args)
+  GET: mockGET
 }));
 
 describe('Articles API', () => {
@@ -37,10 +35,8 @@ describe('Articles API', () => {
         tags: ['test', 'article']
       };
 
-      // Setup mock to return article data
-      mockGET.mockResolvedValue(
-        NextResponse.json(mockArticle, { status: 200 })
-      );
+      const mockResponse = NextResponse.json(mockArticle, { status: 200 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/articles/test-article');
       const params = { params: Promise.resolve({ slug: 'test-article' }) };
@@ -55,10 +51,8 @@ describe('Articles API', () => {
     });
 
     it('should return 404 for non-existent article', async () => {
-      // Setup mock to simulate article not found
-      mockGET.mockResolvedValue(
-        NextResponse.json({ error: 'Article not found' }, { status: 404 })
-      );
+      const mockResponse = NextResponse.json({ error: 'Article not found' }, { status: 404 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/articles/non-existent');
       const params = { params: Promise.resolve({ slug: 'non-existent' }) };
@@ -73,13 +67,8 @@ describe('Articles API', () => {
     });
 
     it('should handle errors gracefully', async () => {
-      // Setup mock to throw an error
-      mockGET.mockRejectedValue(new Error('Unexpected error'));
-      
-      // Setup error handler mock
-      mockGET.mockResolvedValueOnce(
-        NextResponse.json({ error: 'Internal server error' }, { status: 500 })
-      );
+      const mockResponse = NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/articles/error-article');
       const params = { params: Promise.resolve({ slug: 'error-article' }) };

src/app/api/articles/__tests__/route.test.ts

@@ -4,11 +4,11 @@ import { NextRequest, NextResponse } from 'next/server';
 import { jest } from '@jest/globals';
 
 // Mock the route handlers directly
-const mockGET = jest.fn();
+const mockGET = jest.fn() as jest.MockedFunction<any>;
 
 // Mock the route module
 jest.mock('../[slug]/route', () => ({
-  GET: (...args) => mockGET(...args)
+  GET: mockGET
 }));
 
 describe('Articles API', () => {
@@ -30,9 +30,8 @@ describe('Articles API', () => {
       };
 
       // Setup mock to return article data
-      mockGET.mockResolvedValue(
-        NextResponse.json(mockArticle, { status: 200 })
-      );
+      const mockResponse = NextResponse.json(mockArticle, { status: 200 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/articles/test-article');
       const params = { params: Promise.resolve({ slug: 'test-article' }) };
@@ -48,9 +47,8 @@ describe('Articles API', () => {
 
     it('should return 404 for non-existent article', async () => {
       // Setup mock to simulate article not found
-      mockGET.mockResolvedValue(
-        NextResponse.json({ error: 'Article not found' }, { status: 404 })
-      );
+      const mockResponse = NextResponse.json({ error: 'Article not found' }, { status: 404 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/articles/non-existent');
       const params = { params: Promise.resolve({ slug: 'non-existent' }) };

src/app/api/check-purchase/__tests__/route.test.ts

@@ -4,11 +4,11 @@ import { NextRequest, NextResponse } from 'next/server';
 import { jest } from '@jest/globals';
 
 // Mock the route handlers directly
-const mockGET = jest.fn();
+const mockGET = jest.fn() as jest.MockedFunction<any>;
 
 // Mock the route module
 jest.mock('../route', () => ({
-  GET: (...args) => mockGET(...args)
+  GET: mockGET
 }));
 
 describe('Check Purchase API', () => {
@@ -17,62 +17,57 @@ describe('Check Purchase API', () => {
   });
 
   describe('GET /api/check-purchase', () => {
-    it('should return 401 for unauthenticated users', async () => {
-      // Setup mock to simulate unauthorized response
-      mockGET.mockResolvedValue(
-        NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-      );
+    it('should return 401 for unauthorized request', async () => {
+      const mockResponse = NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/check-purchase');
 
       const { GET } = require('../route');
       const response = await GET(request);
 
       expect(response.status).toBe(401);
-      expect(await response.json()).toEqual({ error: 'Unauthorized' });
+      const data = await response.json();
+      expect(data).toEqual({ error: 'Unauthorized' });
       expect(mockGET).toHaveBeenCalledTimes(1);
     });
 
-    it('should return 400 if slug is missing', async () => {
-      // Setup mock to simulate bad request response
-      mockGET.mockResolvedValue(
-        NextResponse.json({ error: 'Missing slug parameter' }, { status: 400 })
-      );
+    it('should return 400 for missing slug parameter', async () => {
+      const mockResponse = NextResponse.json({ error: 'Missing slug parameter' }, { status: 400 });
+      mockGET.mockResolvedValue(mockResponse);
 
-      const request = new NextRequest('http://localhost:3000/api/check-purchase');
+      const request = new NextRequest('http://localhost:3000/api/check-purchase?type=blog');
 
       const { GET } = require('../route');
       const response = await GET(request);
 
       expect(response.status).toBe(400);
-      expect(await response.json()).toEqual({ error: 'Missing slug parameter' });
+      const data = await response.json();
+      expect(data).toEqual({ error: 'Missing slug parameter' });
       expect(mockGET).toHaveBeenCalledTimes(1);
     });
 
-    it('should return 400 if type is missing', async () => {
-      // Setup mock to simulate bad request response
-      mockGET.mockResolvedValue(
-        NextResponse.json({ error: 'Missing type parameter' }, { status: 400 })
-      );
+    it('should return 400 for missing type parameter', async () => {
+      const mockResponse = NextResponse.json({ error: 'Missing type parameter' }, { status: 400 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/check-purchase?slug=test-article');
 
       const { GET } = require('../route');
       const response = await GET(request);
 
       expect(response.status).toBe(400);
-      expect(await response.json()).toEqual({ error: 'Missing type parameter' });
+      const data = await response.json();
+      expect(data).toEqual({ error: 'Missing type parameter' });
       expect(mockGET).toHaveBeenCalledTimes(1);
     });
 
-    it('should return purchase status for authenticated users', async () => {
-      // Setup mock to simulate successful response
-      mockGET.mockResolvedValue(
-        NextResponse.json({ 
-          purchased: true,
-          purchaseDate: '2023-01-01T00:00:00Z'
-        }, { status: 200 })
-      );
+    it('should return purchase data for valid request', async () => {
+      const mockResponse = NextResponse.json({
+        purchased: true,
+        purchaseDate: '2023-01-01T00:00:00Z'
+      }, { status: 200 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/check-purchase?slug=test-article&type=blog');
 
@@ -81,47 +76,42 @@ describe('Check Purchase API', () => {
 
       expect(response.status).toBe(200);
       const data = await response.json();
-      expect(data).toHaveProperty('purchased');
-      expect(data.purchased).toBe(true);
-      expect(data).toHaveProperty('purchaseDate');
+      expect(data).toEqual({
+        purchased: true,
+        purchaseDate: '2023-01-01T00:00:00Z'
+      });
       expect(mockGET).toHaveBeenCalledTimes(1);
     });
 
-    it('should return not purchased status when user has not purchased the content', async () => {
-      // Setup mock to simulate not purchased response
-      mockGET.mockResolvedValue(
-        NextResponse.json({ 
-          purchased: false 
-        }, { status: 200 })
-      );
+    it('should return false for non-purchased content', async () => {
+      const mockResponse = NextResponse.json({
+        purchased: false
+      }, { status: 200 });
+      mockGET.mockResolvedValue(mockResponse);
 
-      const request = new NextRequest('http://localhost:3000/api/check-purchase?slug=unpurchased-article&type=blog');
+      const request = new NextRequest('http://localhost:3000/api/check-purchase?slug=free-article&type=blog');
 
       const { GET } = require('../route');
       const response = await GET(request);
 
       expect(response.status).toBe(200);
       const data = await response.json();
-      expect(data).toHaveProperty('purchased');
-      expect(data.purchased).toBe(false);
-      expect(data).not.toHaveProperty('purchaseDate');
+      expect(data).toEqual({ purchased: false });
       expect(mockGET).toHaveBeenCalledTimes(1);
     });
 
-    it('should handle database errors gracefully', async () => {
-      // Setup mock to simulate server error
-      mockGET.mockResolvedValue(
-        NextResponse.json({ error: 'Database error' }, { status: 500 })
-      );
+    it('should handle database errors', async () => {
+      const mockResponse = NextResponse.json({ error: 'Database error' }, { status: 500 });
+      mockGET.mockResolvedValue(mockResponse);
 
       const request = new NextRequest('http://localhost:3000/api/check-purchase?slug=test-article&type=blog');
 
       const { GET } = require('../route');
       const response = await GET(request);
 
       expect(response.status).toBe(500);
-      expect(await response.json()).toEqual({ error: 'Database error' });
-      expect(mockGET).toHaveBeenCalledTimes(1);
+      const data = await response.json();
+      expect(data).toEqual({ error: 'Database error' });
     });
   });
 });