Skip to content

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

15.1 KB
Raw Blame
import { Request, Response } from 'express';
import { StorageController } from '../../src/controllers/StorageController';
import { StorageService } from '../../src/services/StorageService';

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

describe('StorageController', () => {
	let storageController: StorageController;
	let mockStorageService: jest.Mocked<StorageService>;
	let mockRequest: Partial<Request>;
	let mockResponse: Partial<Response>;
	let mockJson: jest.Mock;
	let mockStatus: jest.Mock;

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

		mockStorageService = new StorageService(
			null as any,
			null as any,
			null as any,
			null as any,
			null as any
		) as jest.Mocked<StorageService>;

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

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

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

		storageController = new StorageController(mockStorageService);
	});

	describe('listStorages', () => {
		it('should successfully get all storages', async () => {
			const mockStorages = [
				{ id: 'storage-1', name: 'Storage 1', type: 's3' },
				{ id: 'storage-2', name: 'Storage 2', type: 'local' },
			];
			mockStorageService.getStorages.mockResolvedValue(mockStorages as any);

			await storageController.listStorages(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.getStorages).toHaveBeenCalled();
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockStorages,
			});
		});

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

			await storageController.listStorages(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to fetch storages',
			});
		});
	});

	describe('listAvailableStorageTypes', () => {
		it('should successfully get available storage types', async () => {
			const mockTypes = ['s3', 'gcs', 'azure', 'local'];
			mockStorageService.getAvailableStorageTypes.mockResolvedValue(mockTypes as any);

			await storageController.listAvailableStorageTypes(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockStorageService.getAvailableStorageTypes).toHaveBeenCalled();
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockTypes,
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockStorageService.getAvailableStorageTypes.mockRejectedValue(new Error('Fetch failed'));

			await storageController.listAvailableStorageTypes(
				mockRequest as Request,
				mockResponse as Response
			);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to fetch available storages',
			});
		});
	});

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

			await storageController.getStorage(mockRequest as Request, mockResponse as Response);

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

		it('should successfully get a storage', async () => {
			const mockStorage = { id: 'storage-1', name: 'Storage 1', type: 's3' };
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.getStorage.mockResolvedValue(mockStorage as any);

			await storageController.getStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.getStorage).toHaveBeenCalledWith('storage-1');
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: mockStorage,
			});
		});

		it('should return 404 if storage not found', async () => {
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.getStorage.mockRejectedValue(new Error('Storage not found'));

			await storageController.getStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(404);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Storage not found',
			});
		});

		it('should return 500 for other errors', async () => {
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.getStorage.mockRejectedValue(new Error('Database error'));

			await storageController.getStorage(mockRequest as Request, mockResponse as Response);

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

	describe('createStorage', () => {
		it('should return 400 if required fields are missing', async () => {
			mockRequest.body = { name: 'Test Storage' };

			await storageController.createStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(400);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Name, type, credentials and settings are required',
			});
		});

		it('should successfully create storage', async () => {
			const storageData = {
				name: 'Test Storage',
				type: 's3',
				settings: { bucket: 'test-bucket' },
				credentials: { accessKey: 'key', secretKey: 'secret' },
			};
			const createdStorage = { id: 'storage-1', ...storageData };
			mockRequest.body = storageData;
			mockStorageService.createStorage.mockResolvedValue(createdStorage as any);

			await storageController.createStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.createStorage).toHaveBeenCalledWith(storageData);
			expect(mockStatus).toHaveBeenCalledWith(201);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: createdStorage,
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.body = {
				name: 'Test Storage',
				type: 's3',
				settings: {},
				credentials: {},
			};
			mockStorageService.createStorage.mockRejectedValue(new Error('Creation failed'));

			await storageController.createStorage(mockRequest as Request, mockResponse as Response);

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

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

			await storageController.updateStorage(mockRequest as Request, mockResponse as Response);

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

		it('should successfully update storage', async () => {
			const updateData = { name: 'Updated Storage' };
			const updatedStorage = { id: 'storage-1', ...updateData };
			mockRequest.params = { id: 'storage-1' };
			mockRequest.body = updateData;
			mockStorageService.updateStorage.mockResolvedValue(updatedStorage as any);

			await storageController.updateStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.updateStorage).toHaveBeenCalledWith('storage-1', updateData);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: updatedStorage,
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'storage-1' };
			mockRequest.body = { name: 'Updated Storage' };
			mockStorageService.updateStorage.mockRejectedValue(new Error('Update failed'));

			await storageController.updateStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to update storage',
			});
		});
	});

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

			await storageController.deleteStorage(mockRequest as Request, mockResponse as Response);

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

		it('should successfully delete storage', async () => {
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.deleteStorage.mockResolvedValue(true);

			await storageController.deleteStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.deleteStorage).toHaveBeenCalledWith('storage-1');
			expect(mockJson).toHaveBeenCalledWith({ success: true });
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.deleteStorage.mockRejectedValue(new Error('Delete failed'));

			await storageController.deleteStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to delete storage. Reason : Delete failed',
			});
		});
	});

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

			await storageController.verifyStorage(mockRequest as Request, mockResponse as Response);

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

		it('should successfully verify storage', async () => {
			const verifyResult = { success: true, message: 'Storage is accessible' };
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.verifyStorage.mockResolvedValue(verifyResult as any);

			await storageController.verifyStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.verifyStorage).toHaveBeenCalledWith('storage-1');
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: verifyResult,
			});
		});

		it('should return 500 if service throws an error', async () => {
			mockRequest.params = { id: 'storage-1' };
			mockStorageService.verifyStorage.mockRejectedValue(new Error('Verification failed'));

			await storageController.verifyStorage(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(500);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Failed to verify storage',
			});
		});
	});

	describe('startAuthorize', () => {
		it('should return 400 if storage type is missing', async () => {
			mockRequest.body = {};

			await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);

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

		it('should return 400 if storage type is not a string', async () => {
			mockRequest.body = { type: 123 };

			await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);

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

		it('should successfully start authorization', async () => {
			mockRequest.body = { type: 'drive' };
			mockStorageService.startAuthorize.mockReturnValue('session-abc');

			await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.startAuthorize).toHaveBeenCalledWith('drive');
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: { sessionId: 'session-abc' },
			});
		});

		it('should forward service errors with statusCode', async () => {
			mockRequest.body = { type: 'drive' };
			const error = { statusCode: 409, message: 'Already in progress' };
			mockStorageService.startAuthorize.mockImplementation(() => {
				throw error;
			});

			await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(409);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Already in progress',
			});
		});
	});

	describe('getAuthorizeStatus', () => {
		it('should return 400 if sessionId is missing', async () => {
			mockRequest.query = {};

			await storageController.getAuthorizeStatus(mockRequest as Request, mockResponse as Response);

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

		it('should successfully return authorize status', async () => {
			mockRequest.query = { sessionId: 'session-abc' };
			const statusResult = {
				status: 'success',
				token: '{"access_token":"xyz"}',
			};
			mockStorageService.getAuthorizeStatus.mockReturnValue(statusResult as any);

			await storageController.getAuthorizeStatus(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.getAuthorizeStatus).toHaveBeenCalledWith('session-abc');
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({
				success: true,
				result: statusResult,
			});
		});

		it('should forward 404 for unknown session', async () => {
			mockRequest.query = { sessionId: 'nonexistent' };
			const error = { statusCode: 404, message: 'Authorization session not found' };
			mockStorageService.getAuthorizeStatus.mockImplementation(() => {
				throw error;
			});

			await storageController.getAuthorizeStatus(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(404);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Authorization session not found',
			});
		});
	});

	describe('cancelAuthorize', () => {
		it('should return 400 if sessionId is missing', async () => {
			mockRequest.body = {};

			await storageController.cancelAuthorize(mockRequest as Request, mockResponse as Response);

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

		it('should successfully cancel authorization', async () => {
			mockRequest.body = { sessionId: 'session-abc' };
			mockStorageService.cancelAuthorize.mockReturnValue(undefined);

			await storageController.cancelAuthorize(mockRequest as Request, mockResponse as Response);

			expect(mockStorageService.cancelAuthorize).toHaveBeenCalledWith('session-abc');
			expect(mockStatus).toHaveBeenCalledWith(200);
			expect(mockJson).toHaveBeenCalledWith({ success: true });
		});

		it('should forward 404 for unknown session', async () => {
			mockRequest.body = { sessionId: 'nonexistent' };
			const error = { statusCode: 404, message: 'Authorization session not found' };
			mockStorageService.cancelAuthorize.mockImplementation(() => {
				throw error;
			});

			await storageController.cancelAuthorize(mockRequest as Request, mockResponse as Response);

			expect(mockStatus).toHaveBeenCalledWith(404);
			expect(mockJson).toHaveBeenCalledWith({
				success: false,
				error: 'Authorization session not found',
			});
		});
	});
});