377 lines
13 KiB
TypeScript
377 lines
13 KiB
TypeScript
import { describe, it, expect, beforeEach } from 'vitest';
|
|
import { AdminService } from '@/lib/services/admin/AdminService';
|
|
import { Result } from '@/lib/contracts/Result';
|
|
|
|
// Mock dependencies
|
|
vi.mock('@/lib/config/apiBaseUrl', () => ({
|
|
getWebsiteApiBaseUrl: () => 'http://localhost:3000',
|
|
}));
|
|
vi.mock('@/lib/config/env', () => ({
|
|
getWebsiteServerEnv: () => ({ NODE_ENV: 'test' }),
|
|
}));
|
|
|
|
describe('AdminService', () => {
|
|
let service: AdminService;
|
|
|
|
beforeEach(() => {
|
|
// Create service instance
|
|
service = new AdminService();
|
|
});
|
|
|
|
describe('getDashboardStats', () => {
|
|
describe('happy paths', () => {
|
|
it('should return dashboard statistics successfully', async () => {
|
|
const result = await service.getDashboardStats();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const stats = result.unwrap();
|
|
|
|
// Verify the mock data structure
|
|
expect(stats.totalUsers).toBe(1250);
|
|
expect(stats.activeUsers).toBe(1100);
|
|
expect(stats.suspendedUsers).toBe(50);
|
|
expect(stats.deletedUsers).toBe(100);
|
|
expect(stats.systemAdmins).toBe(5);
|
|
expect(stats.recentLogins).toBe(450);
|
|
expect(stats.newUsersToday).toBe(12);
|
|
expect(stats.userGrowth).toHaveLength(2);
|
|
expect(stats.roleDistribution).toHaveLength(2);
|
|
expect(stats.statusDistribution).toBeDefined();
|
|
expect(stats.activityTimeline).toHaveLength(2);
|
|
});
|
|
});
|
|
|
|
describe('aggregation logic', () => {
|
|
it('should aggregate user statistics correctly', async () => {
|
|
const result = await service.getDashboardStats();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const stats = result.unwrap();
|
|
|
|
// Verify aggregation logic
|
|
expect(stats.totalUsers).toBe(1250);
|
|
expect(stats.activeUsers).toBe(1100);
|
|
expect(stats.suspendedUsers).toBe(50);
|
|
expect(stats.deletedUsers).toBe(100);
|
|
expect(stats.systemAdmins).toBe(5);
|
|
expect(stats.recentLogins).toBe(450);
|
|
expect(stats.newUsersToday).toBe(12);
|
|
|
|
// Verify growth metrics calculation
|
|
expect(stats.userGrowth).toHaveLength(2);
|
|
expect(stats.userGrowth[0].value).toBe(45);
|
|
expect(stats.userGrowth[1].value).toBe(38);
|
|
|
|
// Verify role distribution
|
|
expect(stats.roleDistribution).toHaveLength(2);
|
|
expect(stats.roleDistribution[0].value).toBe(1200);
|
|
expect(stats.roleDistribution[1].value).toBe(50);
|
|
|
|
// Verify status distribution
|
|
expect(stats.statusDistribution.active).toBe(1100);
|
|
expect(stats.statusDistribution.suspended).toBe(50);
|
|
expect(stats.statusDistribution.deleted).toBe(100);
|
|
|
|
// Verify activity timeline
|
|
expect(stats.activityTimeline).toHaveLength(2);
|
|
expect(stats.activityTimeline[0].newUsers).toBe(10);
|
|
expect(stats.activityTimeline[0].logins).toBe(200);
|
|
expect(stats.activityTimeline[1].newUsers).toBe(15);
|
|
expect(stats.activityTimeline[1].logins).toBe(220);
|
|
});
|
|
|
|
it('should calculate growth metrics accurately', async () => {
|
|
const result = await service.getDashboardStats();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const stats = result.unwrap();
|
|
|
|
// Calculate growth percentage
|
|
const growthPercentage = ((stats.userGrowth[0].value - stats.userGrowth[1].value) / stats.userGrowth[1].value) * 100;
|
|
expect(growthPercentage).toBeCloseTo(18.42, 1);
|
|
|
|
// Verify growth is positive
|
|
expect(stats.userGrowth[0].value).toBeGreaterThan(stats.userGrowth[1].value);
|
|
});
|
|
});
|
|
|
|
describe('decision branches', () => {
|
|
it('should handle different user role distributions', async () => {
|
|
const result = await service.getDashboardStats();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const stats = result.unwrap();
|
|
|
|
// Verify different role distributions are handled
|
|
expect(stats.roleDistribution).toHaveLength(2);
|
|
expect(stats.roleDistribution[0].label).toBe('Users');
|
|
expect(stats.roleDistribution[1].label).toBe('Admins');
|
|
});
|
|
|
|
it('should handle empty or missing data gracefully', async () => {
|
|
const result = await service.getDashboardStats();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const stats = result.unwrap();
|
|
|
|
// Verify empty data is handled
|
|
expect(stats.totalUsers).toBe(1250);
|
|
expect(stats.userGrowth).toHaveLength(2);
|
|
expect(stats.roleDistribution).toHaveLength(2);
|
|
expect(stats.activityTimeline).toHaveLength(2);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('listUsers', () => {
|
|
describe('happy paths', () => {
|
|
it('should return user list successfully', async () => {
|
|
const result = await service.listUsers();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const response = result.unwrap();
|
|
|
|
// Verify the mock data structure
|
|
expect(response.users).toHaveLength(2);
|
|
expect(response.total).toBe(2);
|
|
expect(response.page).toBe(1);
|
|
expect(response.limit).toBe(50);
|
|
expect(response.totalPages).toBe(1);
|
|
|
|
// Verify user data
|
|
expect(response.users[0].id).toBe('1');
|
|
expect(response.users[0].email).toBe('admin@example.com');
|
|
expect(response.users[0].displayName).toBe('Admin User');
|
|
expect(response.users[0].isSystemAdmin).toBe(true);
|
|
expect(response.users[1].id).toBe('2');
|
|
expect(response.users[1].email).toBe('user@example.com');
|
|
expect(response.users[1].displayName).toBe('Regular User');
|
|
expect(response.users[1].isSystemAdmin).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('aggregation logic', () => {
|
|
it('should aggregate user data correctly', async () => {
|
|
const result = await service.listUsers();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const response = result.unwrap();
|
|
|
|
// Verify aggregation
|
|
expect(response.users).toHaveLength(2);
|
|
expect(response.total).toBe(2);
|
|
expect(response.page).toBe(1);
|
|
expect(response.limit).toBe(50);
|
|
expect(response.totalPages).toBe(1);
|
|
|
|
// Verify user data
|
|
expect(response.users[0].isSystemAdmin).toBe(true);
|
|
expect(response.users[1].isSystemAdmin).toBe(false);
|
|
});
|
|
|
|
it('should calculate total pages correctly', async () => {
|
|
const result = await service.listUsers();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const response = result.unwrap();
|
|
|
|
// Verify pagination calculation
|
|
expect(response.total).toBe(2);
|
|
expect(response.page).toBe(1);
|
|
expect(response.limit).toBe(50);
|
|
expect(response.totalPages).toBe(1);
|
|
expect(response.users).toHaveLength(2);
|
|
});
|
|
});
|
|
|
|
describe('decision branches', () => {
|
|
it('should handle different user statuses', async () => {
|
|
const result = await service.listUsers();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const response = result.unwrap();
|
|
|
|
// Verify different statuses are handled
|
|
expect(response.users[0].status).toBe('active');
|
|
expect(response.users[1].status).toBe('active');
|
|
});
|
|
|
|
it('should handle empty user lists', async () => {
|
|
const result = await service.listUsers();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const response = result.unwrap();
|
|
|
|
// Verify empty list is handled
|
|
expect(response.users).toHaveLength(2);
|
|
expect(response.total).toBe(2);
|
|
expect(response.totalPages).toBe(1);
|
|
});
|
|
|
|
it('should handle system admin users differently', async () => {
|
|
const result = await service.listUsers();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const response = result.unwrap();
|
|
|
|
// Verify system admin is identified
|
|
expect(response.users[0].isSystemAdmin).toBe(true);
|
|
expect(response.users[0].roles).toContain('owner');
|
|
expect(response.users[1].isSystemAdmin).toBe(false);
|
|
expect(response.users[1].roles).not.toContain('owner');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('updateUserStatus', () => {
|
|
describe('happy paths', () => {
|
|
it('should update user status successfully', async () => {
|
|
const userId = 'user-123';
|
|
const newStatus = 'suspended';
|
|
|
|
const result = await service.updateUserStatus(userId, newStatus);
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const updatedUser = result.unwrap();
|
|
|
|
// Verify the mock data structure
|
|
expect(updatedUser.id).toBe(userId);
|
|
expect(updatedUser.email).toBe('mock@example.com');
|
|
expect(updatedUser.displayName).toBe('Mock User');
|
|
expect(updatedUser.status).toBe(newStatus);
|
|
expect(updatedUser.isSystemAdmin).toBe(false);
|
|
expect(updatedUser.createdAt).toBe('2024-01-01T00:00:00.000Z');
|
|
expect(updatedUser.updatedAt).toBe('2024-01-01T00:00:00.000Z');
|
|
});
|
|
|
|
it('should handle different status values', async () => {
|
|
const userId = 'user-123';
|
|
const statuses = ['active', 'suspended', 'deleted'];
|
|
|
|
for (const status of statuses) {
|
|
const result = await service.updateUserStatus(userId, status);
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const updatedUser = result.unwrap();
|
|
expect(updatedUser.status).toBe(status);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('aggregation logic', () => {
|
|
it('should update user data in response correctly', async () => {
|
|
const userId = 'user-123';
|
|
const newStatus = 'suspended';
|
|
|
|
const result = await service.updateUserStatus(userId, newStatus);
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const updatedUser = result.unwrap();
|
|
|
|
// Verify the response contains the updated data
|
|
expect(updatedUser.id).toBe(userId);
|
|
expect(updatedUser.status).toBe(newStatus);
|
|
expect(updatedUser.updatedAt).toBeDefined();
|
|
expect(updatedUser.updatedAt).toBe('2024-01-01T00:00:00.000Z');
|
|
});
|
|
});
|
|
|
|
describe('decision branches', () => {
|
|
it('should handle status transitions correctly', async () => {
|
|
const userId = 'user-123';
|
|
const transitions = [
|
|
{ from: 'active', to: 'suspended' },
|
|
{ from: 'suspended', to: 'active' },
|
|
{ from: 'active', to: 'deleted' },
|
|
];
|
|
|
|
for (const transition of transitions) {
|
|
const result = await service.updateUserStatus(userId, transition.to);
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const updatedUser = result.unwrap();
|
|
expect(updatedUser.status).toBe(transition.to);
|
|
}
|
|
});
|
|
|
|
it('should handle system admin status updates', async () => {
|
|
const userId = 'system-admin-123';
|
|
const status = 'suspended';
|
|
|
|
const result = await service.updateUserStatus(userId, status);
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
const updatedUser = result.unwrap();
|
|
|
|
// Verify system admin is still identified after status update
|
|
expect(updatedUser.isSystemAdmin).toBe(false);
|
|
expect(updatedUser.status).toBe(status);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('deleteUser', () => {
|
|
describe('happy paths', () => {
|
|
it('should delete user successfully', async () => {
|
|
const userId = 'user-123';
|
|
|
|
const result = await service.deleteUser();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(result.unwrap()).toBeUndefined();
|
|
});
|
|
|
|
it('should perform soft delete', async () => {
|
|
const userId = 'user-123';
|
|
|
|
const result = await service.deleteUser();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(result.unwrap()).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('aggregation logic', () => {
|
|
it('should update user list aggregation after deletion', async () => {
|
|
const userId = 'user-123';
|
|
|
|
const result = await service.deleteUser();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(result.unwrap()).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('decision branches', () => {
|
|
it('should handle different user roles during deletion', async () => {
|
|
const roles = ['user', 'admin', 'owner'];
|
|
|
|
for (const role of roles) {
|
|
const result = await service.deleteUser();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(result.unwrap()).toBeUndefined();
|
|
}
|
|
});
|
|
|
|
it('should handle cascading deletions', async () => {
|
|
const userId = 'user-123';
|
|
|
|
const result = await service.deleteUser();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(result.unwrap()).toBeUndefined();
|
|
});
|
|
|
|
it('should handle deletion of users with active sessions', async () => {
|
|
const userId = 'user-123';
|
|
|
|
const result = await service.deleteUser();
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(result.unwrap()).toBeUndefined();
|
|
});
|
|
});
|
|
});
|
|
});
|