A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.
import { Request, Response } from 'express';
import { PlanController } from '../../src/controllers/PlanController';
import { PlanService } from '../../src/services/PlanService';
import { AppError } from '../../src/utils/AppError';
jest.mock('../../src/services/PlanService');
describe('PlanController', () => {
let planController: PlanController;
let mockPlanService: jest.Mocked<PlanService>;
let mockRequest: Partial<Request>;
let mockResponse: Partial<Response>;
let mockJson: jest.Mock;
let mockStatus: jest.Mock;
let mockPipe: jest.Mock;
let mockSetHeader: jest.Mock;
beforeEach(() => {
jest.clearAllMocks();
mockPlanService = new PlanService(
null as any,
null as any,
null as any,
null as any,
null as any,
null as any
) as jest.Mocked<PlanService>;
mockJson = jest.fn().mockReturnThis();
mockStatus = jest.fn().mockReturnValue({ json: mockJson });
mockPipe = jest.fn();
mockSetHeader = jest.fn();
mockResponse = {
json: mockJson,
status: mockStatus,
setHeader: mockSetHeader,
};
mockRequest = {
params: {},
query: {},
body: {},
};
planController = new PlanController(mockPlanService);
});
describe('getPlans', () => {
it('should successfully get all plans', async () => {
const mockPlans = [
{ id: 'plan-1', name: 'Plan 1' },
{ id: 'plan-2', name: 'Plan 2' },
];
mockPlanService.getAllPlans.mockResolvedValue(mockPlans as any);
await planController.getPlans(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.getAllPlans).toHaveBeenCalled();
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: mockPlans,
});
});
it('should return empty array if no plans exist', async () => {
mockPlanService.getAllPlans.mockResolvedValue(null);
await planController.getPlans(mockRequest as Request, mockResponse as Response);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: [],
});
});
it('should return 500 if service throws an error', async () => {
const error = new AppError(500, 'Database error');
mockPlanService.getAllPlans.mockRejectedValue(error);
await planController.getPlans(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(500);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Internal Server Error. Details: Database error',
});
});
});
describe('getPlan', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.getPlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Plan ID is required',
});
});
it('should successfully get a plan', async () => {
const mockPlan = { id: 'plan-1', name: 'Plan 1' };
mockRequest.params = { id: 'plan-1' };
mockPlanService.getPlan.mockResolvedValue(mockPlan as any);
await planController.getPlan(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.getPlan).toHaveBeenCalledWith('plan-1', true);
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: mockPlan,
});
});
it('should return 404 if plan not found', async () => {
mockRequest.params = { id: 'plan-1' };
const error = new AppError(404, 'Plan not found');
mockPlanService.getPlan.mockRejectedValue(error);
await planController.getPlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(404);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Plan not found',
});
});
});
describe('checkActiveBackupsOrRestore', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.checkActiveBackupsOrRestore(
mockRequest as Request,
mockResponse as Response
);
expect(mockStatus).toHaveBeenCalledWith(400);
});
it('should successfully check for active backups', async () => {
mockRequest.params = { id: 'plan-1' };
mockRequest.query = { type: 'backup' };
mockPlanService.checkActiveBackupsOrRestore.mockResolvedValue(true);
await planController.checkActiveBackupsOrRestore(
mockRequest as Request,
mockResponse as Response
);
expect(mockPlanService.checkActiveBackupsOrRestore).toHaveBeenCalledWith('plan-1', 'backup');
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: true,
});
});
});
describe('createPlan', () => {
it('should return 400 if required fields are missing', async () => {
mockRequest.body = {};
await planController.createPlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Required fields missing: interval, storage Id, sourceId, sourceType, sourceConfig',
});
});
it('should successfully create a plan', async () => {
const planPayload = {
settings: { interval: 'daily' },
storage: { id: 'storage-1' },
sourceType: 'local',
sourceConfig: {},
};
const createdPlan = { id: 'plan-1', ...planPayload };
mockRequest.body = { plan: planPayload };
mockPlanService.createPlan.mockResolvedValue(createdPlan as any);
await planController.createPlan(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.createPlan).toHaveBeenCalledWith(planPayload, undefined);
expect(mockStatus).toHaveBeenCalledWith(201);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: createdPlan,
});
});
it('should return 500 if service throws an error', async () => {
const planPayload = {
settings: { interval: 'daily' },
storage: { id: 'storage-1' },
sourceType: 'local',
sourceConfig: {},
};
mockRequest.body = { plan: planPayload };
const error = new AppError(500, 'Creation failed');
mockPlanService.createPlan.mockRejectedValue(error);
await planController.createPlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(500);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Creation failed',
});
});
});
describe('updatePlan', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
mockRequest.body = { plan: {} };
await planController.updatePlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Plan ID is required.',
});
});
it('should return 400 if payload is missing', async () => {
mockRequest.params = { id: 'plan-1' };
mockRequest.body = {};
await planController.updatePlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Payload Missing.',
});
});
it('should successfully update a plan', async () => {
const planPayload = { name: 'Updated Plan' };
const updatedPlan = { id: 'plan-1', ...planPayload };
mockRequest.params = { id: 'plan-1' };
mockRequest.body = { plan: planPayload };
mockPlanService.updatePlan.mockResolvedValue(updatedPlan as any);
await planController.updatePlan(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.updatePlan).toHaveBeenCalledWith('plan-1', planPayload);
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: updatedPlan,
});
});
});
describe('deletePlan', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.deletePlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
});
it('should successfully delete a plan', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.deletePlan.mockResolvedValue({
deleted: true,
unremovedPaths: [],
unremovedReason: '',
});
await planController.deletePlan(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.deletePlan).toHaveBeenCalledWith('plan-1', false);
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
message: 'Plan deleted successfully',
unremovedPaths: [],
unremovedReason: '',
});
});
it('should report storage paths that could not be removed, and why', async () => {
mockRequest.params = { id: 'plan-1' };
const unremovedPaths = [{ storageName: 'wasabi', storagePath: 'pluton/laptop-01' }];
mockPlanService.deletePlan.mockResolvedValue({
deleted: true,
unremovedPaths,
unremovedReason: 'The device could not be reached.',
});
await planController.deletePlan(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
message: 'Plan deleted successfully',
unremovedPaths,
unremovedReason: 'The device could not be reached.',
});
});
});
describe('performBackup', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.performBackup(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
});
it('should successfully initiate backup', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.performBackup.mockResolvedValue('');
await planController.performBackup(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.performBackup).toHaveBeenCalledWith('plan-1', undefined);
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
message: 'Backup initiated successfully',
});
});
});
describe('pauseBackup', () => {
it('should successfully pause backup', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.pauseBackup.mockResolvedValue(undefined);
await planController.pauseBackup(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.pauseBackup).toHaveBeenCalledWith('plan-1');
expect(mockStatus).toHaveBeenCalledWith(200);
});
});
describe('resumeBackup', () => {
it('should successfully resume backup', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.resumeBackup.mockResolvedValue(undefined);
await planController.resumeBackup(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.resumeBackup).toHaveBeenCalledWith('plan-1');
expect(mockStatus).toHaveBeenCalledWith(200);
});
});
describe('pruneBackup', () => {
it('should successfully prune backups', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.pruneBackups.mockResolvedValue('Pruned successfully');
await planController.pruneBackup(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.pruneBackups).toHaveBeenCalledWith('plan-1');
expect(mockStatus).toHaveBeenCalledWith(200);
});
});
describe('unlockRepo', () => {
it('should successfully unlock repository', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.unlockRepo.mockResolvedValue({ success: true, result: 'Unlocked' });
await planController.unlockRepo(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.unlockRepo).toHaveBeenCalledWith('plan-1');
expect(mockStatus).toHaveBeenCalledWith(200);
});
it('should return 500 if unlock fails', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.unlockRepo.mockResolvedValue({ success: false, result: 'Failed' });
await planController.unlockRepo(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(500);
});
});
describe('getLogs', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.getLogs(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
});
it('should successfully get logs', async () => {
const mockLogs = [
{ timestamp: new Date(), level: 'info', message: 'log line 1' },
{ timestamp: new Date(), level: 'info', message: 'log line 2' },
];
mockRequest.params = { id: 'plan-1' };
mockPlanService.getPlanLogs.mockResolvedValue(mockLogs as any);
await planController.getLogs(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.getPlanLogs).toHaveBeenCalledWith('plan-1');
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
logs: mockLogs,
});
});
});
describe('downloadLogs', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.downloadLogs(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
});
it('should successfully stream log file', async () => {
const mockFileStream = { pipe: mockPipe };
mockRequest.params = { id: 'plan-1' };
mockPlanService.downloadPlanLogs.mockResolvedValue(mockFileStream as any);
await planController.downloadLogs(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.downloadPlanLogs).toHaveBeenCalledWith('plan-1');
expect(mockSetHeader).toHaveBeenCalledWith('Content-Type', 'text/plain');
expect(mockSetHeader).toHaveBeenCalledWith(
'Content-Disposition',
'attachment; filename="plan.log"'
);
expect(mockPipe).toHaveBeenCalledWith(mockResponse);
});
});
describe('checkIntegrity', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
await planController.checkIntegrity(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Plan ID is required',
});
});
it('should return 200 when integrity check succeeds', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.checkIntegrity.mockResolvedValue({
success: true,
result: { primary: 'no errors found' },
});
await planController.checkIntegrity(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.checkIntegrity).toHaveBeenCalledWith('plan-1');
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: { primary: 'no errors found' },
});
});
it('should return 500 when integrity check result is not successful', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.checkIntegrity.mockResolvedValue({
success: false,
result: { primary: 'No Backup schedule found' },
});
await planController.checkIntegrity(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(500);
expect(mockJson).toHaveBeenCalledWith({
success: false,
result: { primary: 'No Backup schedule found' },
});
});
it('should return 500 if service throws an error', async () => {
mockRequest.params = { id: 'plan-1' };
mockPlanService.checkIntegrity.mockRejectedValue(new Error('Internal error'));
await planController.checkIntegrity(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(500);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Internal Server Error',
});
});
});
describe('repairRepo', () => {
it('should return 400 if plan ID is missing', async () => {
mockRequest.params = {};
mockRequest.query = { type: 'index' };
await planController.repairRepo(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Plan ID is required',
});
});
it('should return 400 if repair type is missing', async () => {
mockRequest.params = { id: 'plan-1' };
mockRequest.query = {};
await planController.repairRepo(mockRequest as Request, mockResponse as Response);
expect(mockStatus).toHaveBeenCalledWith(400);
expect(mockJson).toHaveBeenCalledWith({
success: false,
error: 'Type is required',
});
});
it('should return 200 when repair succeeds', async () => {
mockRequest.params = { id: 'plan-1' };
mockRequest.query = { type: 'index', replicationId: 'replica-1' };
mockPlanService.repairRepo.mockResolvedValue({
success: true,
result: { primary: 'repair completed' },
});
await planController.repairRepo(mockRequest as Request, mockResponse as Response);
expect(mockPlanService.repairRepo).toHaveBeenCalledWith('plan-1', 'index', 'replica-1');
expect(mockStatus).toHaveBeenCalledWith(200);
expect(mockJson).toHaveBeenCalledWith({
success: true,
result: { primary: 'repair completed' },
});
});
});
});