will/rxminder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add comprehensive test coverage and fix lint issues

Browse Source 
- Add comprehensive tests for MailgunService (439 lines)
  * Email sending functionality with template generation
  * Configuration status validation
  * Error handling and edge cases
  * Mock setup for fetch API and FormData

- Add DatabaseService tests (451 lines)
  * Strategy pattern testing (Mock vs Production)
  * All CRUD operations for users, medications, settings
  * Legacy compatibility method testing
  * Proper TypeScript typing

- Add MockDatabaseStrategy tests (434 lines)
  * Complete coverage of mock database implementation
  * User operations, medication management
  * Settings and custom reminders functionality
  * Data persistence and error handling

- Add React hooks tests
  * useLocalStorage hook with comprehensive edge cases (340 lines)
  * useSettings hook with fetch operations and error handling (78 lines)

- Fix auth integration tests
  * Update mocking to use new database service instead of legacy couchdb.factory
  * Fix service variable references and expectations

- Simplify mailgun config tests
  * Remove redundant edge case testing
  * Focus on core functionality validation

- Fix all TypeScript and ESLint issues
  * Proper FormData mock typing
  * Correct database entity type usage
  * Remove non-existent property references

Test Results:
- 184 total tests passing
- Comprehensive coverage of core services
- Zero TypeScript compilation errors
- Full ESLint compliance
This commit is contained in:
William Valentin
2025-09-08 10:13:50 -07:00
parent 9a3bf2084e
commit 2556250f2c
7 changed files with 1901 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
services/auth/__tests__/auth.integration.test.ts
View File

@@ -2,19 +2,9 @@ import { authService } from '../auth.service';
import { AccountStatus } from '../auth.constants';
import { AuthenticatedUser } from '../auth.types';
// Create typed mock interfaces for better type safety
interface MockDbService {
findUserByEmail: jest.MockedFunction<any>;
createUserWithPassword: jest.MockedFunction<any>;
createUserFromOAuth: jest.MockedFunction<any>;
updateUser: jest.MockedFunction<any>;
getUserById: jest.MockedFunction<any>;
changeUserPassword: jest.MockedFunction<any>;
}
// Mock the entire couchdb.factory module
jest.mock('../../couchdb.factory', () => ({
dbService: {
// Mock the new database service
jest.mock('../../database', () => ({
databaseService: {
findUserByEmail: jest.fn(),
createUserWithPassword: jest.fn(),
createUserFromOAuth: jest.fn(),
@@ -24,14 +14,6 @@ jest.mock('../../couchdb.factory', () => ({
},
}));
// Mock the mailgun service
jest.mock('../../mailgun.service', () => ({
mailgunService: {
sendVerificationEmail: jest.fn().mockResolvedValue(true),
sendPasswordResetEmail: jest.fn().mockResolvedValue(true),
},
}));
// Mock the emailVerification service
jest.mock('../emailVerification.service', () => ({
EmailVerificationService: jest.fn().mockImplementation(() => ({
@@ -39,7 +21,7 @@ jest.mock('../emailVerification.service', () => ({
token: 'mock-verification-token',
userId: 'user1',
email: 'testuser@example.com',
expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
}),
validateVerificationToken: jest.fn(),
markEmailVerified: jest.fn(),
@@ -55,18 +37,15 @@ describe('Authentication Integration Tests', () => {
};
let mockUser: AuthenticatedUser;
let mockDbService: MockDbService;
let mockDatabaseService: any;
beforeEach(async () => {
// Clear all localStorage keys
localStorage.clear();
// Reset all mocks
jest.clearAllMocks();
// Get the mocked services
const { dbService } = await import('../../couchdb.factory');
mockDbService = dbService as MockDbService;
// Get the mocked database service
const { databaseService } = await import('../../database');
mockDatabaseService = databaseService;
// Setup default mock user
mockUser = {
@@ -82,18 +61,15 @@ describe('Authentication Integration Tests', () => {
describe('User Registration', () => {
test('should create a pending account for new user', async () => {
// Arrange
mockDbService.findUserByEmail.mockResolvedValue(null); // User doesn't exist
mockDbService.createUserWithPassword.mockResolvedValue(mockUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(null);
mockDatabaseService.createUserWithPassword.mockResolvedValue(mockUser);
// Act
const result = await authService.register(
testCredentials.email,
testCredentials.password,
testCredentials.username
);
// Assert
expect(result).toBeDefined();
expect(result.user.username).toBe(testCredentials.username);
expect(result.user.email).toBe(testCredentials.email);
@@ -102,11 +78,10 @@ describe('Authentication Integration Tests', () => {
expect(result.verificationToken).toBeDefined();
expect(result.verificationToken.token).toBe('mock-verification-token');
// Verify database interactions
expect(mockDbService.findUserByEmail).toHaveBeenCalledWith(
expect(mockDatabaseService.findUserByEmail).toHaveBeenCalledWith(
testCredentials.email
);
expect(mockDbService.createUserWithPassword).toHaveBeenCalledWith(
expect(mockDatabaseService.createUserWithPassword).toHaveBeenCalledWith(
testCredentials.email,
testCredentials.password,
testCredentials.username
@@ -114,10 +89,8 @@ describe('Authentication Integration Tests', () => {
});
test('should fail when user already exists', async () => {
// Arrange
mockDbService.findUserByEmail.mockResolvedValue(mockUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(mockUser);
// Act & Assert
await expect(
authService.register(
testCredentials.email,
@@ -126,16 +99,14 @@ describe('Authentication Integration Tests', () => {
)
).rejects.toThrow('User already exists');
expect(mockDbService.createUserWithPassword).not.toHaveBeenCalled();
expect(mockDatabaseService.createUserWithPassword).not.toHaveBeenCalled();
});
});
describe('User Login', () => {
test('should fail for unverified (pending) account', async () => {
// Arrange
mockDbService.findUserByEmail.mockResolvedValue(mockUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(mockUser);
// Act & Assert
await expect(
authService.login({
email: testCredentials.email,
@@ -145,21 +116,18 @@ describe('Authentication Integration Tests', () => {
});
test('should succeed after email verification', async () => {
// Arrange
const verifiedUser = {
...mockUser,
emailVerified: true,
status: AccountStatus.ACTIVE,
};
mockDbService.findUserByEmail.mockResolvedValue(verifiedUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(verifiedUser);
// Act
const tokens = await authService.login({
email: testCredentials.email,
password: testCredentials.password,
});
// Assert
expect(tokens).toBeDefined();
expect(tokens.accessToken).toBeTruthy();
expect(tokens.refreshToken).toBeTruthy();
@@ -168,15 +136,13 @@ describe('Authentication Integration Tests', () => {
});
test('should fail with wrong password', async () => {
// Arrange
const verifiedUser = {
...mockUser,
emailVerified: true,
status: AccountStatus.ACTIVE,
};
mockDbService.findUserByEmail.mockResolvedValue(verifiedUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(verifiedUser);
// Act & Assert
await expect(
authService.login({
email: testCredentials.email,
@@ -186,10 +152,8 @@ describe('Authentication Integration Tests', () => {
});
test('should fail for non-existent user', async () => {
// Arrange
mockDbService.findUserByEmail.mockResolvedValue(null);
mockDatabaseService.findUserByEmail.mockResolvedValue(null);
// Act & Assert
await expect(
authService.login({
email: 'nonexistent@example.com',
@@ -199,20 +163,6 @@ describe('Authentication Integration Tests', () => {
});
});
describe('Email Verification', () => {
test('should activate account with valid token', async () => {
// This test is covered by the EmailVerificationService unit tests
// and the integration is tested through the registration flow
expect(true).toBe(true);
});
test('should fail with invalid token', async () => {
// This test is covered by the EmailVerificationService unit tests
// and the integration is tested through the registration flow
expect(true).toBe(true);
});
});
describe('OAuth Authentication', () => {
const oauthUserData = {
email: 'oauthuser@example.com',
@@ -220,7 +170,6 @@ describe('Authentication Integration Tests', () => {
};
test('should register new OAuth user', async () => {
// Arrange
const oauthUser: AuthenticatedUser = {
_id: 'oauth-user1',
_rev: 'mock-rev-oauth-1',
@@ -231,13 +180,11 @@ describe('Authentication Integration Tests', () => {
status: AccountStatus.ACTIVE,
};
mockDbService.findUserByEmail.mockResolvedValue(null);
mockDbService.createUserFromOAuth.mockResolvedValue(oauthUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(null);
mockDatabaseService.createUserFromOAuth.mockResolvedValue(oauthUser);
// Act
const result = await authService.loginWithOAuth('google', oauthUserData);
// Assert
expect(result).toBeDefined();
expect(result.user.email).toBe(oauthUserData.email);
expect(result.user.username).toBe(oauthUserData.username);
@@ -246,13 +193,14 @@ describe('Authentication Integration Tests', () => {
expect(result.accessToken).toBeTruthy();
expect(result.refreshToken).toBeTruthy();
expect(mockDbService.createUserFromOAuth).toHaveBeenCalledWith(
oauthUserData
expect(mockDatabaseService.createUserFromOAuth).toHaveBeenCalledWith(
oauthUserData.email,
oauthUserData.username,
'google'
);
});
test('should login existing OAuth user', async () => {
// Arrange
const existingUser: AuthenticatedUser = {
_id: 'existing-user1',
_rev: 'mock-rev-existing-1',
@@ -263,29 +211,24 @@ describe('Authentication Integration Tests', () => {
status: AccountStatus.ACTIVE,
};
mockDbService.findUserByEmail.mockResolvedValue(existingUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(existingUser);
// Act
const result = await authService.loginWithOAuth('google', oauthUserData);
// Assert
expect(result).toBeDefined();
expect(result.user.email).toBe(oauthUserData.email);
expect(result.user._id).toBe('existing-user1');
expect(result.accessToken).toBeTruthy();
expect(result.refreshToken).toBeTruthy();
// Should not create a new user
expect(mockDbService.createUserFromOAuth).not.toHaveBeenCalled();
expect(mockDatabaseService.createUserFromOAuth).not.toHaveBeenCalled();
});
test('should handle OAuth login errors gracefully', async () => {
// Arrange
mockDbService.findUserByEmail.mockRejectedValue(
mockDatabaseService.findUserByEmail.mockRejectedValue(
new Error('Database error')
);
// Act & Assert
await expect(
authService.loginWithOAuth('google', oauthUserData)
).rejects.toThrow('OAuth login failed: Database error');
@@ -294,7 +237,6 @@ describe('Authentication Integration Tests', () => {
describe('Password Management', () => {
test('should change password with valid current password', async () => {
// Arrange
const userId = 'user1';
const currentPassword = 'currentPassword';
const newPassword = 'newPassword123';
@@ -307,28 +249,25 @@ describe('Authentication Integration Tests', () => {
password: newPassword,
};
mockDbService.getUserById.mockResolvedValue(userWithPassword);
mockDbService.changeUserPassword.mockResolvedValue(updatedUser);
mockDatabaseService.getUserById.mockResolvedValue(userWithPassword);
mockDatabaseService.updateUser.mockResolvedValue(updatedUser);
// Act
const result = await authService.changePassword(
userId,
currentPassword,
newPassword
);
// Assert
expect(result).toBeDefined();
expect(result.user.password).toBe(newPassword);
expect(result.message).toBe('Password changed successfully');
expect(mockDbService.changeUserPassword).toHaveBeenCalledWith(
userId,
newPassword
);
expect(mockDatabaseService.updateUser).toHaveBeenCalledWith({
...userWithPassword,
password: newPassword,
});
});
test('should fail password change with incorrect current password', async () => {
// Arrange
const userId = 'user1';
const currentPassword = 'wrongPassword';
const newPassword = 'newPassword123';
@@ -337,25 +276,22 @@ describe('Authentication Integration Tests', () => {
password: 'correctPassword',
};
mockDbService.getUserById.mockResolvedValue(userWithPassword);
mockDatabaseService.getUserById.mockResolvedValue(userWithPassword);
// Act & Assert
await expect(
authService.changePassword(userId, currentPassword, newPassword)
).rejects.toThrow('Current password is incorrect');
});
test('should fail password change for OAuth users', async () => {
// Arrange
const userId = 'user1';
const oauthUser = {
...mockUser,
password: '', // OAuth users don't have passwords
password: '',
};
mockDbService.getUserById.mockResolvedValue(oauthUser);
mockDatabaseService.getUserById.mockResolvedValue(oauthUser);
// Act & Assert
await expect(
authService.changePassword(userId, 'any', 'newPassword')
).rejects.toThrow('Cannot change password for OAuth accounts');
@@ -364,48 +300,38 @@ describe('Authentication Integration Tests', () => {
describe('Password Reset', () => {
test('should request password reset for existing user', async () => {
// Arrange
const userWithPassword = {
...mockUser,
password: 'hasPassword',
};
mockDbService.findUserByEmail.mockResolvedValue(userWithPassword);
mockDatabaseService.findUserByEmail.mockResolvedValue(userWithPassword);
// Act
const result = await authService.requestPasswordReset(
testCredentials.email
);
// Assert
expect(result).toBeDefined();
expect(result.message).toContain('password reset link has been sent');
expect(result.emailSent).toBe(true);
});
test('should handle password reset for non-existent user gracefully', async () => {
// Arrange
mockDbService.findUserByEmail.mockResolvedValue(null);
mockDatabaseService.findUserByEmail.mockResolvedValue(null);
// Act
const result = await authService.requestPasswordReset(
'nonexistent@example.com'
);
// Assert
expect(result).toBeDefined();
expect(result.message).toContain('password reset link has been sent');
// Should not reveal whether user exists or not
});
test('should fail password reset for OAuth users', async () => {
// Arrange
const oauthUser = {
...mockUser,
password: '', // OAuth users don't have passwords
password: '',
};
mockDbService.findUserByEmail.mockResolvedValue(oauthUser);
mockDatabaseService.findUserByEmail.mockResolvedValue(oauthUser);
// Act & Assert
await expect(
authService.requestPasswordReset(testCredentials.email)
).rejects.toThrow('Cannot reset password for OAuth accounts');