Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

12.6 KB
Raw Blame
import { Request, Response } from 'express';
import { BackupController } from '../../src/controllers/BackupController';
import { BackupService } from '../../src/services/BackupServices';

jest.mock('../../src/services/BackupServices');

describe('BackupController', () => {
	let backupController: BackupController;
	let mockBackupService: jest.Mocked<BackupService>;
	let mockRequest: Partial<Request>;
	let mockResponse: Partial<Response>;
	let mockJson: jest.Mock;
	let mockStatus: jest.Mock;
	let mockSetHeader: jest.Mock;
	let mockDownload: jest.Mock;

	beforeEach(() => {
		jest.clearAllMocks();

		mockBackupService = new BackupService(
			null as any,
			null as any,
			null as any,
			null as any,
			null as any,
			null as any
		) as jest.Mocked<BackupService>;

		mockJson = jest.fn().mockReturnThis();
		mockStatus = jest.fn().mockReturnValue({ json: mockJson });
		mockSetHeader = jest.fn();
		mockDownload = jest.fn();

		mockResponse = {
			json: mockJson,
			status: mockStatus,
			setHeader: mockSetHeader,
			download: mockDownload,
		};

		mockRequest = {
			params: {},
			query: {},
		};

		backupController = new BackupController(mockBackupService);
	});

	describe('getBackupDownload', () => {
		it('should return 400 if backup ID is missing', async () => {
			mockRequest.params = {};

			await backupController.getBackupDownload(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID is required',
			});
		});

		it('should send the backup file with res.download', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.getBackupDownload.mockResolvedValue({
				fileName: 'backup.tar',
				filePath: '/downloads/backup.tar',
			});

			await backupController.getBackupDownload(mockRequest as Request, mockResponse as Response);

			expect(mockBackupService.getBackupDownload).toHaveBeenCalledWith('backup-123');
			expect(mockDownload).toHaveBeenCalledWith(
				'/downloads/backup.tar',
				'backup.tar',
				{ dotfiles: 'allow' },
				expect.any(Function)
			);
			expect(mockStatus).not.toHaveBeenCalled();
		});

		it('should return an error if res.download fails before headers are sent', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.getBackupDownload.mockResolvedValue({
				fileName: 'backup.tar',
				filePath: '/downloads/backup.tar',
			});

			await backupController.getBackupDownload(mockRequest as Request, mockResponse as Response);

			const callback = mockDownload.mock.calls[0][3];
			const error: any = new Error('File not found');
			error.statusCode = 404;
			callback(error);

			expect(mockStatus).toHaveBeenCalledWith(404);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to get Downloaded file. File not found',
			});
		});

		it('should not send an error if res.download fails after headers are sent', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.getBackupDownload.mockResolvedValue({
				fileName: 'backup.tar',
				filePath: '/downloads/backup.tar',
			});
			(mockResponse as any).headersSent = true;

			await backupController.getBackupDownload(mockRequest as Request, mockResponse as Response);

			const callback = mockDownload.mock.calls[0][3];
			callback(new Error('Connection reset'));

			expect(mockStatus).not.toHaveBeenCalled();
			expect(mockJson).not.toHaveBeenCalled();
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.getBackupDownload.mockRejectedValue(new Error('Download failed'));

			await backupController.getBackupDownload(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to get Downloaded file. Download failed',
			});
		});
	});

	describe('generateBackupDownload', () => {
		it('should return 400 if backup ID is missing', async () => {
			mockRequest.params = {};

			await backupController.generateBackupDownload(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID is required',
			});
		});

		it('should successfully generate backup download', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.generateBackupDownload.mockResolvedValue('Download link generated');

			await backupController.generateBackupDownload(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockBackupService.generateBackupDownload).toHaveBeenCalledWith(
				'backup-123',
				undefined
			);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: 'Download link generated',
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.generateBackupDownload.mockRejectedValue(new Error('Generation failed'));

			await backupController.generateBackupDownload(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to generate Download Link. Generation failed',
			});
		});
	});

	describe('getSnapshotFiles', () => {
		it('should return 400 if backup ID is missing', async () => {
			mockRequest.params = {};

			await backupController.getSnapshotFiles(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID is required',
			});
		});

		it('should successfully get snapshot files', async () => {
			const mockFiles = [{ name: 'file1.txt', path: '/path/file1.txt' }];
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.getSnapshotFiles.mockResolvedValue(mockFiles as any);

			await backupController.getSnapshotFiles(mockRequest as Request, mockResponse as Response);

			expect(mockBackupService.getSnapshotFiles).toHaveBeenCalledWith('backup-123', undefined);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockFiles,
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.getSnapshotFiles.mockRejectedValue(new Error('Failed to get files'));

			await backupController.getSnapshotFiles(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to get Snapshot Files. Failed to get files',
			});
		});
	});

	describe('cancelBackupDownload', () => {
		it('should return 400 if backup ID is missing', async () => {
			mockRequest.params = {};

			await backupController.cancelBackupDownload(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID is required',
			});
		});

		it('should successfully cancel backup download', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = { planId: 'plan-456' };
			mockBackupService.cancelBackupDownload.mockResolvedValue('Download cancelled');

			await backupController.cancelBackupDownload(mockRequest as Request, mockResponse as Response);

			expect(mockBackupService.cancelBackupDownload).toHaveBeenCalledWith('plan-456', 'backup-123');
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: 'Download cancelled',
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = { planId: 'plan-456' };
			mockBackupService.cancelBackupDownload.mockRejectedValue(new Error('Cancel failed'));

			await backupController.cancelBackupDownload(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to cancel Download Generation. Cancel failed',
			});
		});
	});

	describe('deleteBackup', () => {
		it('should return 400 if backup ID is missing', async () => {
			mockRequest.params = {};

			await backupController.deleteBackup(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID is required',
			});
		});

		it('should successfully delete backup', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.deleteBackup.mockResolvedValue({} as any);

			await backupController.deleteBackup(mockRequest as Request, mockResponse as Response);

			expect(mockBackupService.deleteBackup).toHaveBeenCalledWith('backup-123', true);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: 'Removed',
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockBackupService.deleteBackup.mockRejectedValue(new Error('Delete failed'));

			await backupController.deleteBackup(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Delete failed',
			});
		});
	});

	describe('getBackupProgress', () => {
		it('should return 400 if required parameters are missing', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = {};

			await backupController.getBackupProgress(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID or Device ID is required',
			});
		});

		it('should successfully get backup progress', async () => {
			const mockProgress = { percent_done: 50, bytes_done: 1024 };
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = { sourceId: 'device-456', sourceType: 'local' };
			mockBackupService.getBackupProgress.mockResolvedValue(mockProgress);

			await backupController.getBackupProgress(mockRequest as Request, mockResponse as Response);

			expect(mockBackupService.getBackupProgress).toHaveBeenCalledWith('backup-123');
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith(mockProgress);
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = { sourceId: 'device-456', sourceType: 'local' };
			mockBackupService.getBackupProgress.mockRejectedValue(new Error('Progress failed'));

			await backupController.getBackupProgress(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Progress failed',
			});
		});
	});

	describe('cancelBackup', () => {
		it('should return 400 if backup ID or planId is missing', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = {};

			await backupController.cancelBackup(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Backup ID is required',
			});
		});

		it('should successfully cancel backup', async () => {
			const mockResult = { success: true, result: 'Cancelled' };
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = { planId: 'plan-456' };
			mockBackupService.cancelBackup.mockResolvedValue(mockResult);

			await backupController.cancelBackup(mockRequest as Request, mockResponse as Response);

			expect(mockBackupService.cancelBackup).toHaveBeenCalledWith('plan-456', 'backup-123');
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith(mockResult);
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'backup-123' };
			mockRequest.query = { planId: 'plan-456' };
			mockBackupService.cancelBackup.mockRejectedValue(new Error('Cancel failed'));

			await backupController.cancelBackup(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Cancel failed',
			});
		});
	});
});