Skip to content

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

13.6 KB
Raw Blame
import { Request, Response } from 'express';
import { SettingsController } from '../../src/controllers/SettingsController';
import { SettingsService } from '../../src/services/SettingsService';
import { AppSettings } from '../../src/types/settings';

jest.mock('../../src/services/ConfigService', () => ({
	configService: {
		get: jest.fn().mockReturnValue(undefined),
		getAll: jest.fn().mockReturnValue({}),
	},
	ConfigService: {
		getInstance: jest.fn().mockReturnValue({
			get: jest.fn().mockReturnValue(undefined),
			getAll: jest.fn().mockReturnValue({}),
		}),
	},
}));

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

describe('SettingsController', () => {
	let settingsController: SettingsController;
	let mockSettingsService: jest.Mocked<SettingsService>;
	let mockRequest: Partial<Request>;
	let mockResponse: Partial<Response>;
	let mockJson: jest.Mock;
	let mockStatus: jest.Mock;
	let mockSetHeader: jest.Mock;
	let mockPipe: jest.Mock;

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

		mockSettingsService = new SettingsService(null as any) as jest.Mocked<SettingsService>;

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

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

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

		settingsController = new SettingsController(mockSettingsService);
	});

	describe('getMainSettings', () => {
		it('should successfully get main settings', async () => {
			const mockSettings = {
				id: 1,
				settings: { notifications: { enabled: true } } as any,
				updatedAt: null,
				updatedBy: null,
				version: 1,
			};
			mockSettingsService.getMainSettings.mockResolvedValue(mockSettings as any);

			await settingsController.getMainSettings(mockRequest as Request, mockResponse as Response);

			expect(mockSettingsService.getMainSettings).toHaveBeenCalled();
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockSettings,
			});
		});

		it('should return 404 if settings not found', async () => {
			mockSettingsService.getMainSettings.mockResolvedValue(null);

			await settingsController.getMainSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(404);
		});

		it('should return 500 if service throws an error', async () => {
			mockSettingsService.getMainSettings.mockRejectedValue(new Error('Database error'));

			await settingsController.getMainSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: "couldn't Retrieve App settings.",
			});
		});
	});

	describe('2FA data in responses', () => {
		const rowWithTotp = () => ({
			id: 1,
			settings: {
				title: 'Pluton',
				totp: { enabled: true, secret: 'encrypted-secret', recoveryCodes: ['hash1', 'hash2'] },
			} as any,
		});
		const publicTotp = { enabled: true, configured: true };

		it('should not send the TOTP secret or recovery codes from getMainSettings', async () => {
			mockSettingsService.getMainSettings.mockResolvedValue(rowWithTotp() as any);

			await settingsController.getMainSettings(mockRequest as Request, mockResponse as Response);

			const result = mockJson.mock.calls[0][0].result;
			expect(result.settings.totp).toEqual(publicTotp);
			expect(result.settings.title).toBe('Pluton');
		});

		it('should not send the TOTP secret or recovery codes from getSettings', async () => {
			mockRequest.params = { id: '1' };
			mockSettingsService.getSettings.mockResolvedValue(rowWithTotp() as any);

			await settingsController.getSettings(mockRequest as Request, mockResponse as Response);

			expect(mockJson.mock.calls[0][0].result.settings.totp).toEqual(publicTotp);
		});

		it('should not send the TOTP secret or recovery codes from updateSettings', async () => {
			mockRequest.params = { id: '1' };
			mockRequest.body = { settings: { title: 'Pluton' } };
			mockSettingsService.updateSettings.mockResolvedValue(rowWithTotp() as any);

			await settingsController.updateSettings(mockRequest as Request, mockResponse as Response);

			expect(mockJson.mock.calls[0][0].result.settings.totp).toEqual(publicTotp);
		});

		it('should report configured false when no secret is saved', async () => {
			const row = rowWithTotp();
			row.settings.totp = { enabled: false, secret: '', recoveryCodes: [] };
			mockSettingsService.getMainSettings.mockResolvedValue(row as any);

			await settingsController.getMainSettings(mockRequest as Request, mockResponse as Response);

			expect(mockJson.mock.calls[0][0].result.settings.totp).toEqual({
				enabled: false,
				configured: false,
			});
		});
	});

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

			await settingsController.getSettings(mockRequest as Request, mockResponse as Response);

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

		it('should successfully get settings by ID', async () => {
			const mockSettings = {
				id: 1,
				settings: { notifications: { enabled: true } } as any,
				updatedAt: null,
				updatedBy: null,
				version: 1,
			};
			mockRequest.params = { id: '1' };
			mockSettingsService.getSettings.mockResolvedValue(mockSettings as any);

			await settingsController.getSettings(mockRequest as Request, mockResponse as Response);

			expect(mockSettingsService.getSettings).toHaveBeenCalledWith(1);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockSettings,
			});
		});

		it('should return 404 if settings not found', async () => {
			mockRequest.params = { id: '1' };
			mockSettingsService.getSettings.mockResolvedValue(null);

			await settingsController.getSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(404);
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: '1' };
			mockSettingsService.getSettings.mockRejectedValue(new Error('Database error'));

			await settingsController.getSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: "couldn't Retrieve settings for the given ID.",
			});
		});
	});

	describe('updateSettings', () => {
		it('should return 400 if settings ID is missing', async () => {
			mockRequest.params = {};
			mockRequest.body = { settings: {} };

			await settingsController.updateSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Settings ID or Settings Data Missing',
			});
		});

		it('should return 400 if settings data is missing', async () => {
			mockRequest.params = { id: '1' };
			mockRequest.body = {};

			await settingsController.updateSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
		});

		it('should successfully update settings', async () => {
			const settingsData = { notifications: { enabled: true } } as any;
			const updatedSettings = {
				id: 1,
				settings: settingsData,
				updatedAt: new Date(),
				updatedBy: null,
				version: 1,
			};
			mockRequest.params = { id: '1' };
			mockRequest.body = { settings: settingsData };
			mockSettingsService.updateSettings.mockResolvedValue(updatedSettings as any);

			await settingsController.updateSettings(mockRequest as Request, mockResponse as Response);

			expect(mockSettingsService.updateSettings).toHaveBeenCalledWith(1, settingsData);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: updatedSettings,
			});
		});

		it('should return 404 if settings not found', async () => {
			const settingsData = { notifications: { enabled: true } } as any;
			mockRequest.params = { id: '1' };
			mockRequest.body = { settings: settingsData };
			mockSettingsService.updateSettings.mockResolvedValue(null);

			await settingsController.updateSettings(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(404);
		});

		it('should return 500 if service throws an error', async () => {
			const settingsData = { notifications: { enabled: true } } as any;
			mockRequest.params = { id: '1' };
			mockRequest.body = { settings: settingsData };
			mockSettingsService.updateSettings.mockRejectedValue(new Error('Update failed'));

			await settingsController.updateSettings(mockRequest as Request, mockResponse as Response);

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

	describe('validateIntegration', () => {
		it('should return 400 if required fields are missing', async () => {
			mockRequest.body = {};

			await settingsController.validateIntegration(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Integration Payload Missing.',
			});
		});

		it('should successfully validate integration', async () => {
			mockRequest.body = {
				settingsID: '1',
				type: 'smtp',
				settings: { smtp: { host: 'smtp.example.com' } },
				test: true,
			};
			mockSettingsService.validateIntegration.mockResolvedValue(true);

			await settingsController.validateIntegration(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockSettingsService.validateIntegration).toHaveBeenCalledWith(
				1,
				'smtp',
				true,
				mockRequest.body.settings
			);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: 'Notification Sent Successfully. Integration Validated.',
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.body = {
				settingsID: '1',
				type: 'smtp',
				settings: { smtp: { host: 'smtp.example.com' } },
				test: true,
			};
			mockSettingsService.validateIntegration.mockRejectedValue(
				new Error('SMTP connection failed')
			);

			await settingsController.validateIntegration(
				mockRequest as Request,
				mockResponse as Response
			);

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

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

			await settingsController.getAppLogs(mockRequest as Request, mockResponse as Response);

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

		it('should successfully get app 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: '1' };
			mockSettingsService.getAppLogs.mockResolvedValue(mockLogs as any);

			await settingsController.getAppLogs(mockRequest as Request, mockResponse as Response);

			expect(mockSettingsService.getAppLogs).toHaveBeenCalledWith(1);
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockLogs,
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: '1' };
			mockSettingsService.getAppLogs.mockRejectedValue(new Error('Log read failed'));

			await settingsController.getAppLogs(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to get logs: Log read failed',
			});
		});
	});

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

			await settingsController.downloadAppLogs(mockRequest as Request, mockResponse as Response);

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

		it('should successfully stream log file', async () => {
			const mockFileStream = { pipe: mockPipe };
			mockRequest.params = { id: '1' };
			mockSettingsService.getAppLogsFile.mockResolvedValue(mockFileStream as any);

			await settingsController.downloadAppLogs(mockRequest as Request, mockResponse as Response);

			expect(mockSettingsService.getAppLogsFile).toHaveBeenCalled();
			expect(mockSetHeader).toHaveBeenCalledWith('Content-Type', 'text/plain');
			expect(mockSetHeader).toHaveBeenCalledWith(
				'Content-Disposition',
				'attachment; filename="app.log"'
			);
			expect(mockPipe).toHaveBeenCalledWith(mockResponse);
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: '1' };
			mockSettingsService.getAppLogsFile.mockRejectedValue(new Error('File not found'));

			await settingsController.downloadAppLogs(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to download logs: File not found',
			});
		});
	});
});