unit tests

2025-12-12 16:27:56 -05:00
parent 25bbf5d20b
commit 3f319bfdd0
24 changed files with 4282 additions and 1806 deletions
--- a/backend/tests/unit/services/email/TemplateManager.test.js
+++ b/backend/tests/unit/services/email/TemplateManager.test.js
@@ -0,0 +1,281 @@
+// Mock fs before requiring modules
+jest.mock('fs', () => ({
+  promises: {
+    readFile: jest.fn(),
+  },
+}));
+
+// Clear singleton between tests
+beforeEach(() => {
+  jest.clearAllMocks();
+  const TemplateManager = require('../../../../services/email/core/TemplateManager');
+  TemplateManager.instance = null;
+});
+
+describe('TemplateManager', () => {
+  const fs = require('fs').promises;
+
+  describe('constructor', () => {
+    it('should create a new instance', () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+      expect(manager).toBeDefined();
+      expect(manager.templates).toBeInstanceOf(Map);
+      expect(manager.initialized).toBe(false);
+    });
+
+    it('should return existing instance (singleton pattern)', () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager1 = new TemplateManager();
+      const manager2 = new TemplateManager();
+      expect(manager1).toBe(manager2);
+    });
+  });
+
+  describe('initialize', () => {
+    it('should load all templates on initialization', async () => {
+      // Mock fs.readFile to return template content
+      fs.readFile.mockResolvedValue('<html>{{content}}</html>');
+
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      expect(manager.initialized).toBe(true);
+      expect(fs.readFile).toHaveBeenCalled();
+    });
+
+    it('should not re-initialize if already initialized', async () => {
+      fs.readFile.mockResolvedValue('<html>{{content}}</html>');
+
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+      const callCount = fs.readFile.mock.calls.length;
+
+      await manager.initialize();
+
+      expect(fs.readFile.mock.calls.length).toBe(callCount);
+    });
+
+    it('should wait for existing initialization if in progress', async () => {
+      fs.readFile.mockResolvedValue('<html>{{content}}</html>');
+
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      // Start two initializations concurrently
+      await Promise.all([manager.initialize(), manager.initialize()]);
+
+      // Should only load templates once
+      const uniquePaths = new Set(fs.readFile.mock.calls.map((call) => call[0]));
+      expect(uniquePaths.size).toBeLessThanOrEqual(fs.readFile.mock.calls.length);
+    });
+
+    it('should throw error if critical templates fail to load', async () => {
+      // All template files fail to load
+      fs.readFile.mockRejectedValue(new Error('File not found'));
+
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await expect(manager.initialize()).rejects.toThrow('Critical email templates failed to load');
+    });
+
+    it('should succeed if critical templates load but non-critical fail', async () => {
+      const criticalTemplates = [
+        'emailVerificationToUser',
+        'passwordResetToUser',
+        'passwordChangedToUser',
+        'personalInfoChangedToUser',
+      ];
+
+      fs.readFile.mockImplementation((path) => {
+        const isCritical = criticalTemplates.some((t) => path.includes(t));
+        if (isCritical) {
+          return Promise.resolve('<html>Template content</html>');
+        }
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      // Should not throw since critical templates loaded
+      await expect(manager.initialize()).resolves.not.toThrow();
+      expect(manager.initialized).toBe(true);
+    });
+  });
+
+  describe('renderTemplate', () => {
+    beforeEach(() => {
+      fs.readFile.mockResolvedValue('<html>Hello {{name}}, your email is {{email}}</html>');
+    });
+
+    it('should render template with variables', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      // Manually set a template for testing
+      manager.templates.set('testTemplate', '<html>Hello {{name}}, your email is {{email}}</html>');
+
+      const result = await manager.renderTemplate('testTemplate', {
+        name: 'John',
+        email: 'john@example.com',
+      });
+
+      expect(result).toBe('<html>Hello John, your email is john@example.com</html>');
+    });
+
+    it('should replace all occurrences of a variable', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      manager.templates.set('testTemplate', '<html>{{name}} {{name}} {{name}}</html>');
+
+      const result = await manager.renderTemplate('testTemplate', {
+        name: 'John',
+      });
+
+      expect(result).toBe('<html>John John John</html>');
+    });
+
+    it('should replace missing variables with empty string', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      manager.templates.set('testTemplate', '<html>Hello {{name}}, {{missing}}</html>');
+
+      const result = await manager.renderTemplate('testTemplate', {
+        name: 'John',
+      });
+
+      expect(result).toBe('<html>Hello John, {{missing}}</html>');
+    });
+
+    it('should use fallback template when template not found', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      const result = await manager.renderTemplate('nonExistentTemplate', {
+        title: 'Test Title',
+        message: 'Test Message',
+      });
+
+      // Should return fallback template content
+      expect(result).toContain('Test Title');
+      expect(result).toContain('Test Message');
+      expect(result).toContain('RentAll');
+    });
+
+    it('should auto-initialize if not initialized', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      expect(manager.initialized).toBe(false);
+
+      await manager.renderTemplate('someTemplate', {});
+
+      expect(manager.initialized).toBe(true);
+    });
+
+    it('should handle empty variables object', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      manager.templates.set('testTemplate', '<html>No variables</html>');
+
+      const result = await manager.renderTemplate('testTemplate', {});
+
+      expect(result).toBe('<html>No variables</html>');
+    });
+
+    it('should handle null or undefined variable values', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      await manager.initialize();
+
+      manager.templates.set('testTemplate', '<html>Hello {{name}}</html>');
+
+      const result = await manager.renderTemplate('testTemplate', {
+        name: null,
+      });
+
+      expect(result).toBe('<html>Hello </html>');
+    });
+  });
+
+  describe('getFallbackTemplate', () => {
+    it('should return specific fallback for known templates', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      const fallback = manager.getFallbackTemplate('emailVerificationToUser');
+
+      expect(fallback).toContain('Verify Your Email');
+      expect(fallback).toContain('{{verificationUrl}}');
+    });
+
+    it('should return specific fallback for password reset', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      const fallback = manager.getFallbackTemplate('passwordResetToUser');
+
+      expect(fallback).toContain('Reset Your Password');
+      expect(fallback).toContain('{{resetUrl}}');
+    });
+
+    it('should return specific fallback for rental request', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      const fallback = manager.getFallbackTemplate('rentalRequestToOwner');
+
+      expect(fallback).toContain('New Rental Request');
+      expect(fallback).toContain('{{itemName}}');
+    });
+
+    it('should return generic fallback for unknown templates', async () => {
+      const TemplateManager = require('../../../../services/email/core/TemplateManager');
+      TemplateManager.instance = null;
+      const manager = new TemplateManager();
+
+      const fallback = manager.getFallbackTemplate('unknownTemplate');
+
+      expect(fallback).toContain('{{title}}');
+      expect(fallback).toContain('{{message}}');
+      expect(fallback).toContain('RentAll');
+    });
+  });
+});