torbo/flyer-crawler.projectium.com
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix for integration tests 404 ? not sure this is right

Browse Source
This commit is contained in:
Torben Sorensen
2025-12-23 19:08:53 -08:00
parent a6a484d432
commit 10a379c5e3
10 changed files with 313 additions and 392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/tests/integration/admin.integration.test.ts
View File

@@ -1,10 +1,16 @@
// src/tests/integration/admin.integration.test.ts // src/tests/integration/admin.integration.test.ts
import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest'; import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
import * as apiClient from '../../services/apiClient'; import supertest from 'supertest';
import app from '../../../server';
import { getPool } from '../../services/db/connection.db'; import { getPool } from '../../services/db/connection.db';
import type { UserProfile } from '../../types'; import type { UserProfile } from '../../types';
import { createAndLoginUser } from '../utils/testHelpers'; import { createAndLoginUser } from '../utils/testHelpers';
/**
* @vitest-environment node
*/
const request = supertest(app);
describe('Admin API Routes Integration Tests', () => { describe('Admin API Routes Integration Tests', () => {
let adminToken: string; let adminToken: string;
let adminUser: UserProfile; let adminUser: UserProfile;
@@ -42,8 +48,10 @@ describe('Admin API Routes Integration Tests', () => {
describe('GET /api/admin/stats', () => { describe('GET /api/admin/stats', () => {
it('should allow an admin to fetch application stats', async () => { it('should allow an admin to fetch application stats', async () => {
const response = await apiClient.getApplicationStats(adminToken); const response = await request
const stats = await response.json(); .get('/api/admin/stats')
.set('Authorization', `Bearer ${adminToken}`);
const stats = response.body;
expect(stats).toBeDefined(); expect(stats).toBeDefined();
expect(stats).toHaveProperty('flyerCount'); expect(stats).toHaveProperty('flyerCount');
expect(stats).toHaveProperty('userCount'); expect(stats).toHaveProperty('userCount');
@@ -51,18 +59,21 @@ describe('Admin API Routes Integration Tests', () => {
}); });
it('should forbid a regular user from fetching application stats', async () => { it('should forbid a regular user from fetching application stats', async () => {
const response = await apiClient.getApplicationStats(regularUserToken); const response = await request
expect(response.ok).toBe(false); .get('/api/admin/stats')
.set('Authorization', `Bearer ${regularUserToken}`);
expect(response.status).toBe(403); expect(response.status).toBe(403);
const errorData = await response.json(); const errorData = response.body;
expect(errorData.message).toBe('Forbidden: Administrator access required.'); expect(errorData.message).toBe('Forbidden: Administrator access required.');
}); });
}); });
describe('GET /api/admin/stats/daily', () => { describe('GET /api/admin/stats/daily', () => {
it('should allow an admin to fetch daily stats', async () => { it('should allow an admin to fetch daily stats', async () => {
const response = await apiClient.getDailyStats(adminToken); const response = await request
const dailyStats = await response.json(); .get('/api/admin/stats/daily')
.set('Authorization', `Bearer ${adminToken}`);
const dailyStats = response.body;
expect(dailyStats).toBeDefined(); expect(dailyStats).toBeDefined();
expect(Array.isArray(dailyStats)).toBe(true); expect(Array.isArray(dailyStats)).toBe(true);
// We just created users in beforeAll, so we should have data // We just created users in beforeAll, so we should have data
@@ -73,10 +84,11 @@ describe('Admin API Routes Integration Tests', () => {
}); });
it('should forbid a regular user from fetching daily stats', async () => { it('should forbid a regular user from fetching daily stats', async () => {
const response = await apiClient.getDailyStats(regularUserToken); const response = await request
expect(response.ok).toBe(false); .get('/api/admin/stats/daily')
.set('Authorization', `Bearer ${regularUserToken}`);
expect(response.status).toBe(403); expect(response.status).toBe(403);
const errorData = await response.json(); const errorData = response.body;
expect(errorData.message).toBe('Forbidden: Administrator access required.'); expect(errorData.message).toBe('Forbidden: Administrator access required.');
}); });
}); });
@@ -85,25 +97,30 @@ describe('Admin API Routes Integration Tests', () => {
it('should allow an admin to fetch suggested corrections', async () => { it('should allow an admin to fetch suggested corrections', async () => {
// This test just verifies access and correct response shape. // This test just verifies access and correct response shape.
// More detailed tests would require seeding corrections. // More detailed tests would require seeding corrections.
const response = await apiClient.getSuggestedCorrections(adminToken); const response = await request
const corrections = await response.json(); .get('/api/admin/corrections')
.set('Authorization', `Bearer ${adminToken}`);
const corrections = response.body;
expect(corrections).toBeDefined(); expect(corrections).toBeDefined();
expect(Array.isArray(corrections)).toBe(true); expect(Array.isArray(corrections)).toBe(true);
}); });
it('should forbid a regular user from fetching suggested corrections', async () => { it('should forbid a regular user from fetching suggested corrections', async () => {
const response = await apiClient.getSuggestedCorrections(regularUserToken); const response = await request
expect(response.ok).toBe(false); .get('/api/admin/corrections')
.set('Authorization', `Bearer ${regularUserToken}`);
expect(response.status).toBe(403); expect(response.status).toBe(403);
const errorData = await response.json(); const errorData = response.body;
expect(errorData.message).toBe('Forbidden: Administrator access required.'); expect(errorData.message).toBe('Forbidden: Administrator access required.');
}); });
}); });
describe('GET /api/admin/brands', () => { describe('GET /api/admin/brands', () => {
it('should allow an admin to fetch all brands', async () => { it('should allow an admin to fetch all brands', async () => {
const response = await apiClient.fetchAllBrands(adminToken); const response = await request
const brands = await response.json(); .get('/api/admin/brands')
.set('Authorization', `Bearer ${adminToken}`);
const brands = response.body;
expect(brands).toBeDefined(); expect(brands).toBeDefined();
expect(Array.isArray(brands)).toBe(true); expect(Array.isArray(brands)).toBe(true);
// Even if no brands exist, it should return an array. // Even if no brands exist, it should return an array.
@@ -112,10 +129,11 @@ describe('Admin API Routes Integration Tests', () => {
}); });
it('should forbid a regular user from fetching all brands', async () => { it('should forbid a regular user from fetching all brands', async () => {
const response = await apiClient.fetchAllBrands(regularUserToken); const response = await request
expect(response.ok).toBe(false); .get('/api/admin/brands')
.set('Authorization', `Bearer ${regularUserToken}`);
expect(response.status).toBe(403); expect(response.status).toBe(403);
const errorData = await response.json(); const errorData = response.body;
expect(errorData.message).toBe('Forbidden: Administrator access required.'); expect(errorData.message).toBe('Forbidden: Administrator access required.');
}); });
}); });
@@ -170,8 +188,10 @@ describe('Admin API Routes Integration Tests', () => {
it('should allow an admin to approve a correction', async () => { it('should allow an admin to approve a correction', async () => {
// Act: Approve the correction. // Act: Approve the correction.
const response = await apiClient.approveCorrection(testCorrectionId, adminToken); const response = await request
expect(response.ok).toBe(true); .post(`/api/admin/corrections/${testCorrectionId}/approve`)
.set('Authorization', `Bearer ${adminToken}`);
expect(response.status).toBe(200);
// Assert: Verify the flyer item's price was updated and the correction status changed. // Assert: Verify the flyer item's price was updated and the correction status changed.
const { rows: itemRows } = await getPool().query( const { rows: itemRows } = await getPool().query(
@@ -189,8 +209,10 @@ describe('Admin API Routes Integration Tests', () => {
it('should allow an admin to reject a correction', async () => { it('should allow an admin to reject a correction', async () => {
// Act: Reject the correction. // Act: Reject the correction.
const response = await apiClient.rejectCorrection(testCorrectionId, adminToken); const response = await request
expect(response.ok).toBe(true); .post(`/api/admin/corrections/${testCorrectionId}/reject`)
.set('Authorization', `Bearer ${adminToken}`);
expect(response.status).toBe(200);
// Assert: Verify the correction status changed. // Assert: Verify the correction status changed.
const { rows: correctionRows } = await getPool().query( const { rows: correctionRows } = await getPool().query(
@@ -202,12 +224,11 @@ describe('Admin API Routes Integration Tests', () => {
it('should allow an admin to update a correction', async () => { it('should allow an admin to update a correction', async () => {
// Act: Update the suggested value of the correction. // Act: Update the suggested value of the correction.
const response = await apiClient.updateSuggestedCorrection( const response = await request
testCorrectionId, .put(`/api/admin/corrections/${testCorrectionId}`)
'300', .set('Authorization', `Bearer ${adminToken}`)
adminToken, .send({ suggested_value: '300' });
); const updatedCorrection = response.body;
const updatedCorrection = await response.json();
// Assert: Verify the API response and the database state. // Assert: Verify the API response and the database state.
expect(updatedCorrection.suggested_value).toBe('300'); expect(updatedCorrection.suggested_value).toBe('300');
@@ -227,8 +248,11 @@ describe('Admin API Routes Integration Tests', () => {
const recipeId = recipeRes.rows[0].recipe_id; const recipeId = recipeRes.rows[0].recipe_id;
// Act: Update the status to 'public'. // Act: Update the status to 'public'.
const response = await apiClient.updateRecipeStatus(recipeId, 'public', adminToken); const response = await request
expect(response.ok).toBe(true); .put(`/api/admin/recipes/${recipeId}/status`)
.set('Authorization', `Bearer ${adminToken}`)
.send({ status: 'public' });
expect(response.status).toBe(200);
// Assert: Verify the status was updated in the database. // Assert: Verify the status was updated in the database.
const { rows: updatedRecipeRows } = await getPool().query( const { rows: updatedRecipeRows } = await getPool().query(

90
src/tests/integration/ai.integration.test.ts
View File

@@ -1,6 +1,7 @@
// src/tests/integration/ai.integration.test.ts // src/tests/integration/ai.integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'vitest'; import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import * as aiApiClient from '../../services/aiApiClient'; import supertest from 'supertest';
import app from '../../../server';
import fs from 'node:fs/promises'; import fs from 'node:fs/promises';
import path from 'path'; import path from 'path';
import { createAndLoginUser } from '../utils/testHelpers'; import { createAndLoginUser } from '../utils/testHelpers';
@@ -9,6 +10,8 @@ import { createAndLoginUser } from '../utils/testHelpers';
* @vitest-environment node * @vitest-environment node
*/ */
const request = supertest(app);
interface TestGeolocationCoordinates { interface TestGeolocationCoordinates {
latitude: number; latitude: number;
longitude: number; longitude: number;
@@ -44,46 +47,63 @@ describe('AI API Routes Integration Tests', () => {
}); });
it('POST /api/ai/check-flyer should return a boolean', async () => { it('POST /api/ai/check-flyer should return a boolean', async () => {
const mockImageFile = new File(['content'], 'test.jpg', { type: 'image/jpeg' }); const response = await request
const response = await aiApiClient.isImageAFlyer(mockImageFile, authToken); .post('/api/ai/check-flyer')
const result = await response.json(); .set('Authorization', `Bearer ${authToken}`)
.attach('image', Buffer.from('content'), 'test.jpg');
const result = response.body;
expect(response.status).toBe(200);
// The backend is stubbed to always return true for this check // The backend is stubbed to always return true for this check
expect(result.is_flyer).toBe(true); expect(result.is_flyer).toBe(true);
}); });
it('POST /api/ai/extract-address should return a stubbed address', async () => { it('POST /api/ai/extract-address should return a stubbed address', async () => {
const mockImageFile = new File(['content'], 'test.jpg', { type: 'image/jpeg' }); const response = await request
const response = await aiApiClient.extractAddressFromImage(mockImageFile, authToken); .post('/api/ai/extract-address')
const result = await response.json(); .set('Authorization', `Bearer ${authToken}`)
.attach('image', Buffer.from('content'), 'test.jpg');
const result = response.body;
expect(response.status).toBe(200);
expect(result.address).toBe('not identified'); expect(result.address).toBe('not identified');
}); });
it('POST /api/ai/extract-logo should return a stubbed response', async () => { it('POST /api/ai/extract-logo should return a stubbed response', async () => {
const mockImageFile = new File(['content'], 'test.jpg', { type: 'image/jpeg' }); const response = await request
const response = await aiApiClient.extractLogoFromImage([mockImageFile], authToken); .post('/api/ai/extract-logo')
const result = await response.json(); .set('Authorization', `Bearer ${authToken}`)
.attach('images', Buffer.from('content'), 'test.jpg');
const result = response.body;
expect(response.status).toBe(200);
expect(result).toEqual({ store_logo_base_64: null }); expect(result).toEqual({ store_logo_base_64: null });
}); });
it('POST /api/ai/quick-insights should return a stubbed insight', async () => { it('POST /api/ai/quick-insights should return a stubbed insight', async () => {
const response = await aiApiClient.getQuickInsights([{ item: 'test' }], undefined, authToken); const response = await request
const result = await response.json(); .post('/api/ai/quick-insights')
.set('Authorization', `Bearer ${authToken}`)
.send({ items: [{ item: 'test' }] });
const result = response.body;
expect(response.status).toBe(200);
expect(result.text).toBe('This is a server-generated quick insight: buy the cheap stuff!'); expect(result.text).toBe('This is a server-generated quick insight: buy the cheap stuff!');
}); });
it('POST /api/ai/deep-dive should return a stubbed analysis', async () => { it('POST /api/ai/deep-dive should return a stubbed analysis', async () => {
const response = await aiApiClient.getDeepDiveAnalysis( const response = await request
[{ item: 'test' }], .post('/api/ai/deep-dive')
undefined, .set('Authorization', `Bearer ${authToken}`)
authToken, .send({ items: [{ item: 'test' }] });
); const result = response.body;
const result = await response.json(); expect(response.status).toBe(200);
expect(result.text).toBe('This is a server-generated deep dive analysis. It is very detailed.'); expect(result.text).toBe('This is a server-generated deep dive analysis. It is very detailed.');
}); });
it('POST /api/ai/search-web should return a stubbed search result', async () => { it('POST /api/ai/search-web should return a stubbed search result', async () => {
const response = await aiApiClient.searchWeb('test query', undefined, authToken); const response = await request
const result = await response.json(); .post('/api/ai/search-web')
.set('Authorization', `Bearer ${authToken}`)
.send({ query: 'test query' });
const result = response.body;
expect(response.status).toBe(200);
expect(result).toEqual({ text: 'The web says this is good.', sources: [] }); expect(result).toEqual({ text: 'The web says this is good.', sources: [] });
}); });
@@ -116,36 +136,32 @@ describe('AI API Routes Integration Tests', () => {
created_at: new Date().toISOString(), created_at: new Date().toISOString(),
updated_at: new Date().toISOString(), updated_at: new Date().toISOString(),
}; };
const response = await aiApiClient.planTripWithMaps( const response = await request
[], .post('/api/ai/plan-trip')
mockStore, .set('Authorization', `Bearer ${authToken}`)
mockLocation, .send({ items: [], store: mockStore, userLocation: mockLocation });
undefined,
authToken,
);
// The service for this endpoint is disabled and throws an error, which results in a 500. // The service for this endpoint is disabled and throws an error, which results in a 500.
expect(response.ok).toBe(false);
expect(response.status).toBe(500); expect(response.status).toBe(500);
const errorResult = await response.json(); const errorResult = response.body;
expect(errorResult.message).toContain('planTripWithMaps'); expect(errorResult.message).toContain('planTripWithMaps');
}); });
it('POST /api/ai/generate-image should reject because it is not implemented', async () => { it('POST /api/ai/generate-image should reject because it is not implemented', async () => {
// The backend for this is not stubbed and will throw an error. // The backend for this is not stubbed and will throw an error.
// This test confirms that the endpoint is protected and responds as expected to a failure. // This test confirms that the endpoint is protected and responds as expected to a failure.
const response = await aiApiClient.generateImageFromText('a test prompt', undefined, authToken); const response = await request
expect(response.ok).toBe(false); .post('/api/ai/generate-image')
.set('Authorization', `Bearer ${authToken}`)
.send({ prompt: 'a test prompt' });
expect(response.status).toBe(501); expect(response.status).toBe(501);
}); });
it('POST /api/ai/generate-speech should reject because it is not implemented', async () => { it('POST /api/ai/generate-speech should reject because it is not implemented', async () => {
// The backend for this is not stubbed and will throw an error. // The backend for this is not stubbed and will throw an error.
const response = await aiApiClient.generateSpeechFromText( const response = await request
'a test prompt', .post('/api/ai/generate-speech')
undefined, .set('Authorization', `Bearer ${authToken}`)
authToken, .send({ text: 'a test prompt' });
);
expect(response.ok).toBe(false);
expect(response.status).toBe(501); expect(response.status).toBe(501);
}); });
}); });

105
src/tests/integration/auth.integration.test.ts
View File

@@ -1,6 +1,7 @@
// src/tests/integration/auth.integration.test.ts // src/tests/integration/auth.integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'vitest'; import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { loginUser } from '../../services/apiClient'; import supertest from 'supertest';
import app from '../../../server';
import { getPool } from '../../services/db/connection.db'; import { getPool } from '../../services/db/connection.db';
import { createAndLoginUser, TEST_PASSWORD } from '../utils/testHelpers'; import { createAndLoginUser, TEST_PASSWORD } from '../utils/testHelpers';
import type { UserProfile } from '../../types'; import type { UserProfile } from '../../types';
@@ -9,6 +10,8 @@ import type { UserProfile } from '../../types';
* @vitest-environment node * @vitest-environment node
*/ */
const request = supertest(app);
/** /**
* These are integration tests that verify the authentication flow against a running backend server. * These are integration tests that verify the authentication flow against a running backend server.
* Make sure your Express server is running before executing these tests. * Make sure your Express server is running before executing these tests.
@@ -16,30 +19,6 @@ import type { UserProfile } from '../../types';
* To run only these tests: `vitest run src/tests/auth.integration.test.ts` * To run only these tests: `vitest run src/tests/auth.integration.test.ts`
*/ */
describe('Authentication API Integration', () => { describe('Authentication API Integration', () => {
// --- START DEBUG LOGGING ---
// Query the DB from within the test file to see its state.
getPool()
.query(
'SELECT u.user_id, u.email, p.role FROM public.users u JOIN public.profiles p ON u.user_id = p.user_id',
)
.then((res) => {
console.log('\n--- [auth.integration.test.ts] Users found in DB from TEST perspective: ---');
console.table(res.rows);
console.log('--------------------------------------------------------------------------\n');
})
.catch((err) => console.error('--- [auth.integration.test.ts] DB QUERY FAILED ---', err));
// --- END DEBUG LOGGING ---
// --- START DEBUG LOGGING ---
// Log the database connection details as seen by an individual TEST FILE.
console.log('\n\n--- [AUTH.INTEGRATION.TEST LOG] DATABASE CONNECTION ---');
console.log(` Host: ${process.env.DB_HOST}`);
console.log(` Port: ${process.env.DB_PORT}`);
console.log(` User: ${process.env.DB_USER}`);
console.log(` Database: ${process.env.DB_NAME}`);
console.log('-----------------------------------------------------\n');
// --- END DEBUG LOGGING ---
let testUserEmail: string; let testUserEmail: string;
let testUser: UserProfile; let testUser: UserProfile;
@@ -57,11 +36,14 @@ describe('Authentication API Integration', () => {
// This test migrates the logic from the old DevTestRunner.tsx component. // This test migrates the logic from the old DevTestRunner.tsx component.
it('should successfully log in a registered user', async () => { it('should successfully log in a registered user', async () => {
// The `rememberMe` parameter is required. For a test, `false` is a safe default. // The `rememberMe` parameter is required. For a test, `false` is a safe default.
const response = await loginUser(testUserEmail, TEST_PASSWORD, false); const response = await request
const data = await response.json(); .post('/api/auth/login')
.send({ email: testUserEmail, password: TEST_PASSWORD, rememberMe: false });
const data = response.body;
// Assert that the API returns the expected structure // Assert that the API returns the expected structure
expect(data).toBeDefined(); expect(data).toBeDefined();
expect(response.status).toBe(200);
expect(data.userprofile).toBeDefined(); expect(data.userprofile).toBeDefined();
expect(data.userprofile.user.email).toBe(testUserEmail); expect(data.userprofile.user.email).toBe(testUserEmail);
expect(data.userprofile.user.user_id).toBeTypeOf('string'); expect(data.userprofile.user.user_id).toBeTypeOf('string');
@@ -74,9 +56,11 @@ describe('Authentication API Integration', () => {
const wrongPassword = 'wrongpassword'; const wrongPassword = 'wrongpassword';
// The loginUser function returns a Response object. We check its status. // The loginUser function returns a Response object. We check its status.
const response = await loginUser(adminEmail, wrongPassword, false); const response = await request
expect(response.ok).toBe(false); .post('/api/auth/login')
const errorData = await response.json(); .send({ email: adminEmail, password: wrongPassword, rememberMe: false });
expect(response.status).toBe(401);
const errorData = response.body;
expect(errorData.message).toBe('Incorrect email or password.'); expect(errorData.message).toBe('Incorrect email or password.');
}); });
@@ -85,9 +69,11 @@ describe('Authentication API Integration', () => {
const anyPassword = 'any-password'; const anyPassword = 'any-password';
// The loginUser function returns a Response object. We check its status. // The loginUser function returns a Response object. We check its status.
const response = await loginUser(nonExistentEmail, anyPassword, false); const response = await request
expect(response.ok).toBe(false); .post('/api/auth/login')
const errorData = await response.json(); .send({ email: nonExistentEmail, password: anyPassword, rememberMe: false });
expect(response.status).toBe(401);
const errorData = response.body;
// Security best practice: the error message should be identical for wrong password and wrong email // Security best practice: the error message should be identical for wrong password and wrong email
// to prevent user enumeration attacks. // to prevent user enumeration attacks.
expect(errorData.message).toBe('Incorrect email or password.'); expect(errorData.message).toBe('Incorrect email or password.');
@@ -96,24 +82,21 @@ describe('Authentication API Integration', () => {
it('should successfully refresh an access token using a refresh token cookie', async () => { it('should successfully refresh an access token using a refresh token cookie', async () => {
// Arrange: Log in to get a fresh, valid refresh token cookie for this specific test. // Arrange: Log in to get a fresh, valid refresh token cookie for this specific test.
// This ensures the test is self-contained and not affected by other tests. // This ensures the test is self-contained and not affected by other tests.
const loginResponse = await loginUser(testUserEmail, TEST_PASSWORD, true); const loginResponse = await request
const setCookieHeader = loginResponse.headers.get('set-cookie'); .post('/api/auth/login')
const refreshTokenCookie = setCookieHeader?.split(';')[0]; .send({ email: testUserEmail, password: TEST_PASSWORD, rememberMe: true });
const refreshTokenCookie = loginResponse.headers['set-cookie'][0].split(';')[0];
expect(refreshTokenCookie).toBeDefined(); expect(refreshTokenCookie).toBeDefined();
// Act: Make a request to the refresh-token endpoint, including the cookie. // Act: Make a request to the refresh-token endpoint, including the cookie.
const apiUrl = process.env.VITE_API_BASE_URL || 'http://localhost:3001/api'; const response = await request
const response = await fetch(`${apiUrl}/auth/refresh-token`, { .post('/api/auth/refresh-token')
method: 'POST', .set('Cookie', refreshTokenCookie!);
headers: {
Cookie: refreshTokenCookie!,
},
});
// Assert: Check for a successful response and a new access token. // Assert: Check for a successful response and a new access token.
expect(response.ok).toBe(true); expect(response.status).toBe(200);
const data = await response.json(); const data = response.body;
expect(data.token).toBeTypeOf('string'); expect(data.token).toBeTypeOf('string');
}); });
@@ -122,40 +105,30 @@ describe('Authentication API Integration', () => {
const invalidRefreshTokenCookie = 'refreshToken=this-is-not-a-valid-token'; const invalidRefreshTokenCookie = 'refreshToken=this-is-not-a-valid-token';
// Act: Make a request to the refresh-token endpoint with the invalid cookie. // Act: Make a request to the refresh-token endpoint with the invalid cookie.
const apiUrl = process.env.VITE_API_BASE_URL || 'http://localhost:3001/api'; const response = await request
const response = await fetch(`${apiUrl}/auth/refresh-token`, { .post('/api/auth/refresh-token')
method: 'POST', .set('Cookie', invalidRefreshTokenCookie);
headers: {
Cookie: invalidRefreshTokenCookie,
},
});
// Assert: Check for a 403 Forbidden response. // Assert: Check for a 403 Forbidden response.
expect(response.ok).toBe(false);
expect(response.status).toBe(403); expect(response.status).toBe(403);
const data = await response.json(); const data = response.body;
expect(data.message).toBe('Invalid or expired refresh token.'); expect(data.message).toBe('Invalid or expired refresh token.');
}); });
it('should successfully log out and clear the refresh token cookie', async () => { it('should successfully log out and clear the refresh token cookie', async () => {
// Arrange: Log in to get a valid refresh token cookie. // Arrange: Log in to get a valid refresh token cookie.
const loginResponse = await loginUser(testUserEmail, TEST_PASSWORD, true); const loginResponse = await request
const setCookieHeader = loginResponse.headers.get('set-cookie'); .post('/api/auth/login')
const refreshTokenCookie = setCookieHeader?.split(';')[0]; .send({ email: testUserEmail, password: TEST_PASSWORD, rememberMe: true });
const refreshTokenCookie = loginResponse.headers['set-cookie'][0].split(';')[0];
expect(refreshTokenCookie).toBeDefined(); expect(refreshTokenCookie).toBeDefined();
// Act: Make a request to the new logout endpoint, including the cookie. // Act: Make a request to the new logout endpoint, including the cookie.
const apiUrl = process.env.VITE_API_BASE_URL || 'http://localhost:3001/api'; const response = await request.post('/api/auth/logout').set('Cookie', refreshTokenCookie!);
const response = await fetch(`${apiUrl}/auth/logout`, {
method: 'POST',
headers: {
Cookie: refreshTokenCookie!,
},
});
// Assert: Check for a successful response and a cookie-clearing header. // Assert: Check for a successful response and a cookie-clearing header.
expect(response.ok).toBe(true); expect(response.status).toBe(200);
const logoutSetCookieHeader = response.headers.get('set-cookie'); const logoutSetCookieHeader = response.headers['set-cookie'][0];
expect(logoutSetCookieHeader).toContain('refreshToken=;'); expect(logoutSetCookieHeader).toContain('refreshToken=;');
expect(logoutSetCookieHeader).toContain('Max-Age=0'); expect(logoutSetCookieHeader).toContain('Max-Age=0');
}); });

24
src/tests/integration/flyer-processing.integration.test.ts
View File

@@ -1,8 +1,9 @@
// src/tests/integration/flyer-processing.integration.test.ts // src/tests/integration/flyer-processing.integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'vitest'; import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import supertest from 'supertest';
import app from '../../../server';
import fs from 'node:fs/promises'; import fs from 'node:fs/promises';
import path from 'path'; import path from 'path';
import * as aiApiClient from '../../services/aiApiClient';
import * as db from '../../services/db/index.db'; import * as db from '../../services/db/index.db';
import { getPool } from '../../services/db/connection.db'; import { getPool } from '../../services/db/connection.db';
import { generateFileChecksum } from '../../utils/checksum'; import { generateFileChecksum } from '../../utils/checksum';
@@ -14,6 +15,8 @@ import { createAndLoginUser } from '../utils/testHelpers';
* @vitest-environment node * @vitest-environment node
*/ */
const request = supertest(app);
describe('Flyer Processing Background Job Integration Test', () => { describe('Flyer Processing Background Job Integration Test', () => {
const createdUserIds: string[] = []; const createdUserIds: string[] = [];
const createdFlyerIds: number[] = []; const createdFlyerIds: number[] = [];
@@ -68,8 +71,15 @@ describe('Flyer Processing Background Job Integration Test', () => {
const checksum = await generateFileChecksum(mockImageFile); const checksum = await generateFileChecksum(mockImageFile);
// Act 1: Upload the file to start the background job. // Act 1: Upload the file to start the background job.
const uploadResponse = await aiApiClient.uploadAndProcessFlyer(mockImageFile, checksum, token); const uploadReq = request
const { jobId } = await uploadResponse.json(); .post('/api/ai/upload-and-process')
.field('checksum', checksum)
.attach('flyerFile', uniqueContent, uniqueFileName);
if (token) {
uploadReq.set('Authorization', `Bearer ${token}`);
}
const uploadResponse = await uploadReq;
const { jobId } = uploadResponse.body;
// Assert 1: Check that a job ID was returned. // Assert 1: Check that a job ID was returned.
expect(jobId).toBeTypeOf('string'); expect(jobId).toBeTypeOf('string');
@@ -79,8 +89,12 @@ describe('Flyer Processing Background Job Integration Test', () => {
const maxRetries = 20; // Poll for up to 60 seconds (20 * 3s) const maxRetries = 20; // Poll for up to 60 seconds (20 * 3s)
for (let i = 0; i < maxRetries; i++) { for (let i = 0; i < maxRetries; i++) {
await new Promise((resolve) => setTimeout(resolve, 3000)); // Wait 3 seconds between polls await new Promise((resolve) => setTimeout(resolve, 3000)); // Wait 3 seconds between polls
const statusResponse = await aiApiClient.getJobStatus(jobId, token); const statusReq = request.get(`/api/ai/jobs/${jobId}/status`);
jobStatus = await statusResponse.json(); if (token) {
statusReq.set('Authorization', `Bearer ${token}`);
}
const statusResponse = await statusReq;
jobStatus = statusResponse.body;
if (jobStatus.state === 'completed' || jobStatus.state === 'failed') { if (jobStatus.state === 'completed' || jobStatus.state === 'failed') {
break; break;
} }

40
src/tests/integration/flyer.integration.test.ts
View File

@@ -1,7 +1,8 @@
// src/tests/integration/flyer.integration.test.ts // src/tests/integration/flyer.integration.test.ts
import { describe, it, expect, beforeAll } from 'vitest'; import { describe, it, expect, beforeAll } from 'vitest';
import * as apiClient from '../../services/apiClient'; import supertest from 'supertest';
import { getPool } from '../../services/db/connection.db'; import { getPool } from '../../services/db/connection.db';
import app from '../../../server';
import type { Flyer, FlyerItem } from '../../types'; import type { Flyer, FlyerItem } from '../../types';
/** /**
@@ -10,6 +11,8 @@ import type { Flyer, FlyerItem } from '../../types';
describe('Public Flyer API Routes Integration Tests', () => { describe('Public Flyer API Routes Integration Tests', () => {
let flyers: Flyer[] = []; let flyers: Flyer[] = [];
// Use a supertest instance for all requests in this file
const request = supertest(app);
let createdFlyerId: number; let createdFlyerId: number;
// Fetch flyers once before all tests in this suite to use in subsequent tests. // Fetch flyers once before all tests in this suite to use in subsequent tests.
@@ -34,18 +37,16 @@ describe('Public Flyer API Routes Integration Tests', () => {
[createdFlyerId], [createdFlyerId],
); );
const response = await apiClient.fetchFlyers(); const response = await request.get('/api/flyers');
flyers = await response.json(); flyers = response.body;
}); });
describe('GET /api/flyers', () => { describe('GET /api/flyers', () => {
it('should return a list of flyers', async () => { it('should return a list of flyers', async () => {
// Act: Call the API endpoint using the client function. // Act: Call the API endpoint using the client function.
const response = await apiClient.fetchFlyers(); const response = await request.get('/api/flyers');
const flyers: Flyer[] = await response.json(); const flyers: Flyer[] = response.body;
expect(response.status).toBe(200);
// Assert: Verify the response is successful and contains the expected data structure.
expect(response.ok).toBe(true);
expect(flyers).toBeInstanceOf(Array); expect(flyers).toBeInstanceOf(Array);
// We created a flyer in beforeAll, so we expect the array not to be empty. // We created a flyer in beforeAll, so we expect the array not to be empty.
@@ -69,11 +70,10 @@ describe('Public Flyer API Routes Integration Tests', () => {
const testFlyer = flyers[0]; const testFlyer = flyers[0];
// Act: Fetch items for the first flyer. // Act: Fetch items for the first flyer.
const response = await apiClient.fetchFlyerItems(testFlyer.flyer_id); const response = await request.get(`/api/flyers/${testFlyer.flyer_id}/items`);
const items: FlyerItem[] = await response.json(); const items: FlyerItem[] = response.body;
// Assert: Verify the response and data structure. expect(response.status).toBe(200);
expect(response.ok).toBe(true);
expect(items).toBeInstanceOf(Array); expect(items).toBeInstanceOf(Array);
// If there are items, check the shape of the first one. // If there are items, check the shape of the first one.
@@ -87,18 +87,16 @@ describe('Public Flyer API Routes Integration Tests', () => {
}); });
}); });
describe('POST /api/flyer-items/batch-fetch', () => { describe('POST /api/flyers/items/batch-fetch', () => {
it('should return items for multiple flyer IDs', async () => { it('should return items for multiple flyer IDs', async () => {
// Arrange: Get IDs from the flyers fetched in beforeAll. // Arrange: Get IDs from the flyers fetched in beforeAll.
const flyerIds = flyers.map((f) => f.flyer_id); const flyerIds = flyers.map((f) => f.flyer_id);
expect(flyerIds.length).toBeGreaterThan(0); expect(flyerIds.length).toBeGreaterThan(0);
// Act: Fetch items for all available flyers. // Act: Fetch items for all available flyers.
const response = await apiClient.fetchFlyerItemsForFlyers(flyerIds); const response = await request.post('/api/flyers/items/batch-fetch').send({ flyerIds });
const items: FlyerItem[] = await response.json(); const items: FlyerItem[] = response.body;
expect(response.status).toBe(200);
// Assert
expect(response.ok).toBe(true);
expect(items).toBeInstanceOf(Array); expect(items).toBeInstanceOf(Array);
// The total number of items should be greater than or equal to the number of flyers (assuming at least one item per flyer). // The total number of items should be greater than or equal to the number of flyers (assuming at least one item per flyer).
if (items.length > 0) { if (items.length > 0) {
@@ -107,15 +105,15 @@ describe('Public Flyer API Routes Integration Tests', () => {
}); });
}); });
describe('POST /api/flyer-items/batch-count', () => { describe('POST /api/flyers/items/batch-count', () => {
it('should return the total count of items for multiple flyer IDs', async () => { it('should return the total count of items for multiple flyer IDs', async () => {
// Arrange // Arrange
const flyerIds = flyers.map((f) => f.flyer_id); const flyerIds = flyers.map((f) => f.flyer_id);
expect(flyerIds.length).toBeGreaterThan(0); expect(flyerIds.length).toBeGreaterThan(0);
// Act // Act
const response = await apiClient.countFlyerItemsForFlyers(flyerIds); const response = await request.post('/api/flyers/items/batch-count').send({ flyerIds });
const result = await response.json(); const result = response.body;
// Assert // Assert
expect(result.count).toBeTypeOf('number'); expect(result.count).toBeTypeOf('number');

108
src/tests/integration/public.integration.test.ts
View File

@@ -1,108 +0,0 @@
// src/tests/integration/public.integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import * as apiClient from '../../services/apiClient';
import { getPool } from '../../services/db/connection.db';
/**
* @vitest-environment node
*/
describe('Public API Routes Integration Tests', () => {
let createdFlyerId: number;
let createdMasterItemId: number;
beforeAll(async () => {
const pool = getPool();
// Create a store for the flyer
const storeRes = await pool.query(
`INSERT INTO public.stores (name) VALUES ('Public Test Store') RETURNING store_id`,
);
const storeId = storeRes.rows[0].store_id;
// Create a flyer
const flyerRes = await pool.query(
`INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum)
VALUES ($1, 'public-test.jpg', 'http://test.com/public.jpg', 0, $2) RETURNING flyer_id`,
[storeId, `checksum-public-${Date.now()}`],
);
createdFlyerId = flyerRes.rows[0].flyer_id;
// Create a master item. Assumes a category with ID 1 exists from static seeds.
const masterItemRes = await pool.query(
`INSERT INTO public.master_grocery_items (name, category_id) VALUES ('Public Test Item', 1) RETURNING master_grocery_item_id`,
);
createdMasterItemId = masterItemRes.rows[0].master_grocery_item_id;
});
afterAll(async () => {
const pool = getPool();
// Cleanup in reverse order of creation
if (createdMasterItemId) {
await pool.query(
'DELETE FROM public.master_grocery_items WHERE master_grocery_item_id = $1',
[createdMasterItemId],
);
}
if (createdFlyerId) {
await pool.query('DELETE FROM public.flyers WHERE flyer_id = $1', [createdFlyerId]);
}
});
describe('Health Check Endpoints', () => {
it('GET /api/health/ping should return "pong"', async () => {
const response = await apiClient.pingBackend();
expect(response.ok).toBe(true);
expect(await response.text()).toBe('pong');
});
it('GET /api/health/db-schema should return success', async () => {
const response = await apiClient.checkDbSchema();
const result = await response.json();
expect(result.success).toBe(true);
expect(result.message).toBe('All required database tables exist.');
});
it('GET /api/health/storage should return success', async () => {
// This assumes the STORAGE_PATH is correctly set up for the test environment
const response = await apiClient.checkStorage();
const result = await response.json();
expect(result.success).toBe(true);
expect(result.message).toContain('is accessible and writable');
});
it('GET /api/health/db-pool should return success', async () => {
const response = await apiClient.checkDbPoolHealth();
// The pingBackend function returns a boolean directly, so no .json() call is needed.
// However, checkDbPoolHealth returns a Response, so we need to parse it.
const result = await response.json();
expect(result.success).toBe(true);
expect(result.message).toContain('Pool Status:');
});
});
describe('Public Data Endpoints', () => {
it('GET /api/flyers should return a list of flyers', async () => {
const response = await apiClient.fetchFlyers();
const flyers = await response.json();
expect(flyers).toBeInstanceOf(Array);
// We created a flyer, so we expect it to be in the list.
expect(flyers.length).toBeGreaterThan(0);
const foundFlyer = flyers.find((f: { flyer_id: number }) => f.flyer_id === createdFlyerId);
expect(foundFlyer).toBeDefined();
expect(foundFlyer).toHaveProperty('store');
});
it('GET /api/master-items should return a list of master items', async () => {
const response = await apiClient.fetchMasterItems();
const masterItems = await response.json();
expect(masterItems).toBeInstanceOf(Array);
// We created a master item, so we expect it to be in the list.
expect(masterItems.length).toBeGreaterThan(0);
const foundItem = masterItems.find(
(i: { master_grocery_item_id: number }) => i.master_grocery_item_id === createdMasterItemId,
);
expect(foundItem).toBeDefined();
expect(foundItem).toHaveProperty('category_name');
});
});
});

24
src/tests/integration/public.routes.integration.test.ts
View File

@@ -101,9 +101,7 @@ describe('Public API Routes Integration Tests', () => {
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body.success).toBe(true); expect(response.body.success).toBe(true);
}); });
});
describe('Public Data Endpoints', () => {
it('GET /api/health/time should return the server time', async () => { it('GET /api/health/time should return the server time', async () => {
const response = await request.get('/api/health/time'); const response = await request.get('/api/health/time');
expect(response.status).toBe(200); expect(response.status).toBe(200);
@@ -111,7 +109,9 @@ describe('Public API Routes Integration Tests', () => {
expect(response.body).toHaveProperty('year'); expect(response.body).toHaveProperty('year');
expect(response.body).toHaveProperty('week'); expect(response.body).toHaveProperty('week');
}); });
});
describe('Public Data Endpoints', () => {
it('GET /api/flyers should return a list of flyers', async () => { it('GET /api/flyers should return a list of flyers', async () => {
const response = await request.get('/api/flyers'); const response = await request.get('/api/flyers');
const flyers: Flyer[] = response.body; const flyers: Flyer[] = response.body;
@@ -130,25 +130,25 @@ describe('Public API Routes Integration Tests', () => {
expect(items[0].flyer_id).toBe(testFlyer.flyer_id); expect(items[0].flyer_id).toBe(testFlyer.flyer_id);
}); });
it('POST /api/flyer-items/batch-fetch should return items for multiple flyers', async () => { it('POST /api/flyers/items/batch-fetch should return items for multiple flyers', async () => {
const flyerIds = [testFlyer.flyer_id]; const flyerIds = [testFlyer.flyer_id];
const response = await request.post('/api/flyer-items/batch-fetch').send({ flyerIds }); const response = await request.post('/api/flyers/items/batch-fetch').send({ flyerIds });
const items: FlyerItem[] = response.body; const items: FlyerItem[] = response.body;
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(items).toBeInstanceOf(Array); expect(items).toBeInstanceOf(Array);
expect(items.length).toBeGreaterThan(0); expect(items.length).toBeGreaterThan(0);
}); });
it('POST /api/flyer-items/batch-count should return a count for multiple flyers', async () => { it('POST /api/flyers/items/batch-count should return a count for multiple flyers', async () => {
const flyerIds = [testFlyer.flyer_id]; const flyerIds = [testFlyer.flyer_id];
const response = await request.post('/api/flyer-items/batch-count').send({ flyerIds }); const response = await request.post('/api/flyers/items/batch-count').send({ flyerIds });
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body.count).toBeTypeOf('number'); expect(response.body.count).toBeTypeOf('number');
expect(response.body.count).toBeGreaterThan(0); expect(response.body.count).toBeGreaterThan(0);
}); });
it('GET /api/master-items should return a list of master grocery items', async () => { it('GET /api/personalization/master-items should return a list of master grocery items', async () => {
const response = await request.get('/api/master-items'); const response = await request.get('/api/personalization/master-items');
const masterItems = response.body; const masterItems = response.body;
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(masterItems).toBeInstanceOf(Array); expect(masterItems).toBeInstanceOf(Array);
@@ -194,9 +194,9 @@ describe('Public API Routes Integration Tests', () => {
expect(items).toBeInstanceOf(Array); expect(items).toBeInstanceOf(Array);
}); });
it('GET /api/dietary-restrictions should return a list of restrictions', async () => { it('GET /api/personalization/dietary-restrictions should return a list of restrictions', async () => {
// This test relies on static seed data for a lookup table, which is acceptable. // This test relies on static seed data for a lookup table, which is acceptable.
const response = await request.get('/api/dietary-restrictions'); const response = await request.get('/api/personalization/dietary-restrictions');
const restrictions: DietaryRestriction[] = response.body; const restrictions: DietaryRestriction[] = response.body;
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(restrictions).toBeInstanceOf(Array); expect(restrictions).toBeInstanceOf(Array);
@@ -204,8 +204,8 @@ describe('Public API Routes Integration Tests', () => {
expect(restrictions[0]).toHaveProperty('dietary_restriction_id'); expect(restrictions[0]).toHaveProperty('dietary_restriction_id');
}); });
it('GET /api/appliances should return a list of appliances', async () => { it('GET /api/personalization/appliances should return a list of appliances', async () => {
const response = await request.get('/api/appliances'); const response = await request.get('/api/personalization/appliances');
const appliances: Appliance[] = response.body; const appliances: Appliance[] = response.body;
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(appliances).toBeInstanceOf(Array); expect(appliances).toBeInstanceOf(Array);

10
src/tests/integration/system.integration.test.ts
View File

@@ -1,6 +1,7 @@
// src/tests/integration/system.integration.test.ts // src/tests/integration/system.integration.test.ts
import { describe, it, expect } from 'vitest'; import { describe, it, expect } from 'vitest';
import * as apiClient from '../../services/apiClient'; import supertest from 'supertest';
import app from '../../../server';
/** /**
* @vitest-environment node * @vitest-environment node
@@ -9,15 +10,16 @@ import * as apiClient from '../../services/apiClient';
describe('System API Routes Integration Tests', () => { describe('System API Routes Integration Tests', () => {
describe('GET /api/system/pm2-status', () => { describe('GET /api/system/pm2-status', () => {
it('should return a status for PM2', async () => { it('should return a status for PM2', async () => {
const request = supertest(app);
// In a typical CI environment without PM2, this will fail gracefully. // In a typical CI environment without PM2, this will fail gracefully.
// The test verifies that the endpoint responds correctly, even if PM2 isn't running. // The test verifies that the endpoint responds correctly, even if PM2 isn't running.
const response = await apiClient.checkPm2Status(); const response = await request.get('/api/system/pm2-status');
const result = await response.json(); const result = response.body;
expect(result).toBeDefined(); expect(result).toBeDefined();
expect(result).toHaveProperty('message'); expect(result).toHaveProperty('message');
// If the response is successful (200 OK), it must have a 'success' property. // If the response is successful (200 OK), it must have a 'success' property.
// If it's an error (e.g., 500 because pm2 command not found), it will only have 'message'. // If it's an error (e.g., 500 because pm2 command not found), it will only have 'message'.
if (response.ok) { if (response.status === 200) {
expect(result).toHaveProperty('success'); expect(result).toHaveProperty('success');
} }
}); });

176
src/tests/integration/user.integration.test.ts
View File

@@ -1,6 +1,7 @@
// src/tests/integration/user.integration.test.ts // src/tests/integration/user.integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'vitest'; import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import * as apiClient from '../../services/apiClient'; import supertest from 'supertest';
import app from '../../../server';
import { logger } from '../../services/logger.server'; import { logger } from '../../services/logger.server';
import { getPool } from '../../services/db/connection.db'; import { getPool } from '../../services/db/connection.db';
import type { UserProfile, MasterGroceryItem, ShoppingList } from '../../types'; import type { UserProfile, MasterGroceryItem, ShoppingList } from '../../types';
@@ -10,25 +11,12 @@ import { createAndLoginUser, TEST_PASSWORD } from '../utils/testHelpers';
* @vitest-environment node * @vitest-environment node
*/ */
const request = supertest(app);
describe('User API Routes Integration Tests', () => { describe('User API Routes Integration Tests', () => {
let testUser: UserProfile; let testUser: UserProfile;
let authToken: string; let authToken: string;
// --- START DEBUG LOGGING ---
// Query the DB from within the test file to see its state.
beforeAll(async () => {
const res = await getPool().query(
'SELECT u.user_id, u.email, p.role FROM public.users u JOIN public.profiles p ON u.user_id = p.user_id',
);
console.log(
'\n--- [user.integration.test.ts] Users found in DB from TEST perspective (beforeAll): ---',
);
console.table(res.rows);
console.log(
'-------------------------------------------------------------------------------------\n',
);
});
// --- END DEBUG LOGGING ---
// Before any tests run, create a new user and log them in. // Before any tests run, create a new user and log them in.
// The token will be used for all subsequent API calls in this test suite. // The token will be used for all subsequent API calls in this test suite.
beforeAll(async () => { beforeAll(async () => {
@@ -62,11 +50,13 @@ describe('User API Routes Integration Tests', () => {
it('should fetch the authenticated user profile via GET /api/users/profile', async () => { it('should fetch the authenticated user profile via GET /api/users/profile', async () => {
// Act: Call the API endpoint using the authenticated token. // Act: Call the API endpoint using the authenticated token.
const response = await apiClient.getAuthenticatedUserProfile({ tokenOverride: authToken }); const response = await request
const profile = await response.json(); .get('/api/users/profile')
.set('Authorization', `Bearer ${authToken}`);
const profile = response.body;
// Assert: Verify the profile data matches the created user. // Assert: Verify the profile data matches the created user.
expect(profile).toBeDefined(); expect(response.status).toBe(200);
expect(profile.user.user_id).toBe(testUser.user.user_id); expect(profile.user.user_id).toBe(testUser.user.user_id);
expect(profile.user.email).toBe(testUser.user.email); // This was already correct expect(profile.user.email).toBe(testUser.user.email); // This was already correct
expect(profile.full_name).toBe('Test User'); expect(profile.full_name).toBe('Test User');
@@ -80,20 +70,21 @@ describe('User API Routes Integration Tests', () => {
}; };
// Act: Call the update endpoint with the new data and the auth token. // Act: Call the update endpoint with the new data and the auth token.
const response = await apiClient.updateUserProfile(profileUpdates, { const response = await request
tokenOverride: authToken, .put('/api/users/profile')
}); .set('Authorization', `Bearer ${authToken}`)
const updatedProfile = await response.json(); .send(profileUpdates);
const updatedProfile = response.body;
// Assert: Check that the returned profile reflects the changes. // Assert: Check that the returned profile reflects the changes.
expect(updatedProfile).toBeDefined(); expect(response.status).toBe(200);
expect(updatedProfile.full_name).toBe('Updated Test User'); expect(updatedProfile.full_name).toBe('Updated Test User');
// Also, fetch the profile again to ensure the change was persisted. // Also, fetch the profile again to ensure the change was persisted.
const refetchResponse = await apiClient.getAuthenticatedUserProfile({ const refetchResponse = await request
tokenOverride: authToken, .get('/api/users/profile')
}); .set('Authorization', `Bearer ${authToken}`);
const refetchedProfile = await refetchResponse.json(); const refetchedProfile = refetchResponse.body;
expect(refetchedProfile.full_name).toBe('Updated Test User'); expect(refetchedProfile.full_name).toBe('Updated Test User');
}); });
@@ -104,14 +95,14 @@ describe('User API Routes Integration Tests', () => {
}; };
// Act: Call the update endpoint. // Act: Call the update endpoint.
const response = await apiClient.updateUserPreferences(preferenceUpdates, { const response = await request
tokenOverride: authToken, .put('/api/users/profile/preferences')
}); .set('Authorization', `Bearer ${authToken}`)
const updatedProfile = await response.json(); .send(preferenceUpdates);
const updatedProfile = response.body;
// Assert: Check that the preferences object in the returned profile is updated. // Assert: Check that the preferences object in the returned profile is updated.
expect(updatedProfile).toBeDefined(); expect(response.status).toBe(200);
expect(updatedProfile.preferences).toBeDefined();
expect(updatedProfile.preferences?.darkMode).toBe(true); expect(updatedProfile.preferences?.darkMode).toBe(true);
}); });
@@ -122,9 +113,14 @@ describe('User API Routes Integration Tests', () => {
// Act & Assert: Attempt to register and expect the promise to reject // Act & Assert: Attempt to register and expect the promise to reject
// with an error message indicating the password is too weak. // with an error message indicating the password is too weak.
const response = await apiClient.registerUser(email, weakPassword, 'Weak Password User'); const response = await request.post('/api/auth/register').send({
expect(response.ok).toBe(false); email,
const errorData = (await response.json()) as { message: string; errors: { message: string }[] }; password: weakPassword,
full_name: 'Weak Password User',
});
expect(response.status).toBe(400);
const errorData = response.body as { message: string; errors: { message: string }[] };
// For validation errors, the detailed messages are in the `errors` array. // For validation errors, the detailed messages are in the `errors` array.
// We join them to check for the specific feedback from the password strength checker. // We join them to check for the specific feedback from the password strength checker.
const detailedErrorMessage = errorData.errors?.map((e) => e.message).join(' '); const detailedErrorMessage = errorData.errors?.map((e) => e.message).join(' ');
@@ -137,18 +133,22 @@ describe('User API Routes Integration Tests', () => {
const { token: deletionToken } = await createAndLoginUser({ email: deletionEmail }); const { token: deletionToken } = await createAndLoginUser({ email: deletionEmail });
// Act: Call the delete endpoint with the correct password and token. // Act: Call the delete endpoint with the correct password and token.
const response = await apiClient.deleteUserAccount(TEST_PASSWORD, { const response = await request
tokenOverride: deletionToken, .delete('/api/users/account')
}); .set('Authorization', `Bearer ${deletionToken}`)
const deleteResponse = await response.json(); .send({ password: TEST_PASSWORD });
const deleteResponse = response.body;
// Assert: Check for a successful deletion message. // Assert: Check for a successful deletion message.
expect(response.status).toBe(200);
expect(deleteResponse.message).toBe('Account deleted successfully.'); expect(deleteResponse.message).toBe('Account deleted successfully.');
// Assert (Verification): Attempting to log in again with the same credentials should now fail. // Assert (Verification): Attempting to log in again with the same credentials should now fail.
const loginResponse = await apiClient.loginUser(deletionEmail, TEST_PASSWORD, false); const loginResponse = await request
expect(loginResponse.ok).toBe(false); .post('/api/auth/login')
const errorData = await loginResponse.json(); .send({ email: deletionEmail, password: TEST_PASSWORD });
expect(loginResponse.status).toBe(401);
const errorData = loginResponse.body;
expect(errorData.message).toBe('Incorrect email or password.'); expect(errorData.message).toBe('Incorrect email or password.');
}); });
@@ -158,12 +158,14 @@ describe('User API Routes Integration Tests', () => {
const { user: resetUser } = await createAndLoginUser({ email: resetEmail }); const { user: resetUser } = await createAndLoginUser({ email: resetEmail });
// Act 1: Request a password reset. In our test environment, the token is returned in the response. // Act 1: Request a password reset. In our test environment, the token is returned in the response.
const resetRequestRawResponse = await apiClient.requestPasswordReset(resetEmail); const resetRequestRawResponse = await request
if (!resetRequestRawResponse.ok) { .post('/api/auth/forgot-password')
const errorData = await resetRequestRawResponse.json(); .send({ email: resetEmail });
if (resetRequestRawResponse.status !== 200) {
const errorData = resetRequestRawResponse.body;
throw new Error(errorData.message || 'Password reset request failed'); throw new Error(errorData.message || 'Password reset request failed');
} }
const resetRequestResponse = await resetRequestRawResponse.json(); const resetRequestResponse = resetRequestRawResponse.body;
const resetToken = resetRequestResponse.token; const resetToken = resetRequestResponse.token;
// Assert 1: Check that we received a token. // Assert 1: Check that we received a token.
@@ -172,19 +174,23 @@ describe('User API Routes Integration Tests', () => {
// Act 2: Use the token to set a new password. // Act 2: Use the token to set a new password.
const newPassword = 'my-new-secure-password-!@#$'; const newPassword = 'my-new-secure-password-!@#$';
const resetRawResponse = await apiClient.resetPassword(resetToken!, newPassword); const resetRawResponse = await request
if (!resetRawResponse.ok) { .post('/api/auth/reset-password')
const errorData = await resetRawResponse.json(); .send({ token: resetToken!, newPassword });
if (resetRawResponse.status !== 200) {
const errorData = resetRawResponse.body;
throw new Error(errorData.message || 'Password reset failed'); throw new Error(errorData.message || 'Password reset failed');
} }
const resetResponse = await resetRawResponse.json(); const resetResponse = resetRawResponse.body;
// Assert 2: Check for a successful password reset message. // Assert 2: Check for a successful password reset message.
expect(resetResponse.message).toBe('Password has been reset successfully.'); expect(resetResponse.message).toBe('Password has been reset successfully.');
// Act 3 & Assert 3 (Verification): Log in with the NEW password to confirm the change. // Act 3 & Assert 3 (Verification): Log in with the NEW password to confirm the change.
const loginResponse = await apiClient.loginUser(resetEmail, newPassword, false); const loginResponse = await request
const loginData = await loginResponse.json(); .post('/api/auth/login')
.send({ email: resetEmail, password: newPassword });
const loginData = loginResponse.body;
expect(loginData.userprofile).toBeDefined(); expect(loginData.userprofile).toBeDefined();
expect(loginData.userprofile.user.user_id).toBe(resetUser.user.user_id); expect(loginData.userprofile.user.user_id).toBe(resetUser.user.user_id);
}); });
@@ -192,20 +198,21 @@ describe('User API Routes Integration Tests', () => {
describe('User Data Routes (Watched Items & Shopping Lists)', () => { describe('User Data Routes (Watched Items & Shopping Lists)', () => {
it('should allow a user to add and remove a watched item', async () => { it('should allow a user to add and remove a watched item', async () => {
// Act 1: Add a new watched item. The API returns the created master item. // Act 1: Add a new watched item. The API returns the created master item.
const addResponse = await apiClient.addWatchedItem( const addResponse = await request
'Integration Test Item', .post('/api/users/watched-items')
'Other/Miscellaneous', .set('Authorization', `Bearer ${authToken}`)
authToken, .send({ itemName: 'Integration Test Item', category: 'Other/Miscellaneous' });
); const newItem = addResponse.body;
const newItem = await addResponse.json();
// Assert 1: Check that the item was created correctly. // Assert 1: Check that the item was created correctly.
expect(newItem).toBeDefined(); expect(addResponse.status).toBe(201);
expect(newItem.name).toBe('Integration Test Item'); expect(newItem.name).toBe('Integration Test Item');
// Act 2: Fetch all watched items for the user. // Act 2: Fetch all watched items for the user.
const watchedItemsResponse = await apiClient.fetchWatchedItems(authToken); const watchedItemsResponse = await request
const watchedItems = await watchedItemsResponse.json(); .get('/api/users/watched-items')
.set('Authorization', `Bearer ${authToken}`);
const watchedItems = watchedItemsResponse.body;
// Assert 2: Verify the new item is in the user's watched list. // Assert 2: Verify the new item is in the user's watched list.
expect( expect(
@@ -216,11 +223,16 @@ describe('User API Routes Integration Tests', () => {
).toBe(true); ).toBe(true);
// Act 3: Remove the watched item. // Act 3: Remove the watched item.
await apiClient.removeWatchedItem(newItem.master_grocery_item_id, authToken); const removeResponse = await request
.delete(`/api/users/watched-items/${newItem.master_grocery_item_id}`)
.set('Authorization', `Bearer ${authToken}`);
expect(removeResponse.status).toBe(204);
// Assert 3: Fetch again and verify the item is gone. // Assert 3: Fetch again and verify the item is gone.
const finalWatchedItemsResponse = await apiClient.fetchWatchedItems(authToken); const finalWatchedItemsResponse = await request
const finalWatchedItems = await finalWatchedItemsResponse.json(); .get('/api/users/watched-items')
.set('Authorization', `Bearer ${authToken}`);
const finalWatchedItems = finalWatchedItemsResponse.body;
expect( expect(
finalWatchedItems.some( finalWatchedItems.some(
(item: MasterGroceryItem) => (item: MasterGroceryItem) =>
@@ -231,31 +243,33 @@ describe('User API Routes Integration Tests', () => {
it('should allow a user to manage a shopping list', async () => { it('should allow a user to manage a shopping list', async () => {
// Act 1: Create a new shopping list. // Act 1: Create a new shopping list.
const createListResponse = await apiClient.createShoppingList( const createListResponse = await request
'My Integration Test List', .post('/api/users/shopping-lists')
authToken, .set('Authorization', `Bearer ${authToken}`)
); .send({ name: 'My Integration Test List' });
const newList = await createListResponse.json(); const newList = createListResponse.body;
// Assert 1: Check that the list was created. // Assert 1: Check that the list was created.
expect(newList).toBeDefined(); expect(createListResponse.status).toBe(201);
expect(newList.name).toBe('My Integration Test List'); expect(newList.name).toBe('My Integration Test List');
// Act 2: Add an item to the new list. // Act 2: Add an item to the new list.
const addItemResponse = await apiClient.addShoppingListItem( const addItemResponse = await request
newList.shopping_list_id, .post(`/api/users/shopping-lists/${newList.shopping_list_id}/items`)
{ customItemName: 'Custom Test Item' }, .set('Authorization', `Bearer ${authToken}`)
authToken, .send({ customItemName: 'Custom Test Item' });
); const addedItem = addItemResponse.body;
const addedItem = await addItemResponse.json();
// Assert 2: Check that the item was added. // Assert 2: Check that the item was added.
expect(addedItem).toBeDefined(); expect(addItemResponse.status).toBe(201);
expect(addedItem.custom_item_name).toBe('Custom Test Item'); expect(addedItem.custom_item_name).toBe('Custom Test Item');
// Assert 3: Fetch all lists and verify the new item is present in the correct list. // Assert 3: Fetch all lists and verify the new item is present in the correct list.
const fetchResponse = await apiClient.fetchShoppingLists(authToken); const fetchResponse = await request
const lists = await fetchResponse.json(); .get('/api/users/shopping-lists')
.set('Authorization', `Bearer ${authToken}`);
const lists = fetchResponse.body;
expect(fetchResponse.status).toBe(200);
const updatedList = lists.find( const updatedList = lists.find(
(l: ShoppingList) => l.shopping_list_id === newList.shopping_list_id, (l: ShoppingList) => l.shopping_list_id === newList.shopping_list_id,
); );

38
src/tests/integration/user.routes.integration.test.ts
View File

@@ -1,42 +1,30 @@
// src/tests/integration/user.routes.integration.test.ts // src/tests/integration/user.routes.integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'vitest'; import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import supertest from 'supertest'; import supertest from 'supertest';
import app from '../../../server';
import { getPool } from '../../services/db/connection.db'; import { getPool } from '../../services/db/connection.db';
import type { UserProfile } from '../../types'; import type { UserProfile } from '../../types';
import { createAndLoginUser } from '../utils/testHelpers';
const API_URL = process.env.VITE_API_BASE_URL || 'http://localhost:3001/api'; /**
const request = supertest(API_URL.replace('/api', '')); // supertest needs the server's base URL * @vitest-environment node
*/
const request = supertest(app);
let authToken = ''; let authToken = '';
let createdListId: number; let createdListId: number;
let testUser: UserProfile; let testUser: UserProfile;
const testPassword = 'password-for-user-routes-test';
describe('User Routes Integration Tests (/api/users)', () => { describe('User Routes Integration Tests (/api/users)', () => {
// Authenticate once before all tests in this suite to get a JWT. // Authenticate once before all tests in this suite to get a JWT.
beforeAll(async () => { beforeAll(async () => {
// Create a new user for this test suite to avoid dependency on seeded data // Use the helper to create and log in a user in one step.
const testEmail = `user-routes-test-${Date.now()}@example.com`; const { user, token } = await createAndLoginUser({
fullName: 'User Routes Test User',
// 1. Register the user });
const registerResponse = await request testUser = user;
.post('/api/auth/register') authToken = token;
.send({ email: testEmail, password: testPassword, full_name: 'User Routes Test User' });
expect(registerResponse.status).toBe(201);
// 2. Log in as the new user
const loginResponse = await request
.post('/api/auth/login')
.send({ email: testEmail, password: testPassword });
if (loginResponse.status !== 200) {
console.error('Login failed in beforeAll hook:', loginResponse.body);
}
expect(loginResponse.status).toBe(200);
expect(loginResponse.body.token).toBeDefined();
authToken = loginResponse.body.token;
testUser = loginResponse.body.userprofile;
}); });
afterAll(async () => { afterAll(async () => {