negyedik gyakorlat + megoldasok

Backend/negyedik gyakorlat/tests/unit/services/JwtService.test.js

@@ -0,0 +1,218 @@
+const JwtService = require('../../../src/application/services/JwtService');
+const jwt = require('jsonwebtoken');
+
+// Mock jsonwebtoken
+jest.mock('jsonwebtoken');
+
+describe('JwtService', () => {
+  let jwtService;
+  const mockSecret = 'test-secret';
+  const mockExpiresIn = '1h';
+
+  beforeEach(() => {
+    // Setup environment variables
+    process.env.JWT_SECRET = mockSecret;
+    process.env.JWT_EXPIRES_IN = mockExpiresIn;
+    
+    jwtService = new JwtService();
+    
+    // Reset all mocks
+    jest.clearAllMocks();
+  });
+
+  describe('generateToken', () => {
+    it('should generate a JWT token with payload', () => {
+      // Arrange
+      const payload = { userId: 1, email: 'john@example.com' };
+      const mockToken = 'mock_jwt_token_abc123';
+      
+      jwt.sign.mockReturnValue(mockToken);
+
+      // Act
+      const result = jwtService.generateToken(payload);
+
+      // Assert
+      expect(jwt.sign).toHaveBeenCalledWith(payload, mockSecret, { expiresIn: mockExpiresIn });
+      expect(result).toBe(mockToken);
+    });
+
+    it('should use default secret if JWT_SECRET not set', () => {
+      // Arrange
+      delete process.env.JWT_SECRET;
+      jwtService = new JwtService();
+      const payload = { userId: 1, email: 'john@example.com' };
+      
+      jwt.sign.mockReturnValue('token');
+
+      // Act
+      jwtService.generateToken(payload);
+
+      // Assert
+      expect(jwt.sign).toHaveBeenCalledWith(payload, 'default-secret-change-me', expect.any(Object));
+    });
+  });
+
+  describe('verifyToken', () => {
+    it('should verify and return decoded token', () => {
+      // Arrange
+      const token = 'valid_token';
+      const mockDecoded = { userId: 1, email: 'john@example.com' };
+      
+      jwt.verify.mockReturnValue(mockDecoded);
+
+      // Act
+      const result = jwtService.verifyToken(token);
+
+      // Assert
+      expect(jwt.verify).toHaveBeenCalledWith(token, mockSecret);
+      expect(result).toEqual(mockDecoded);
+    });
+
+    it('should throw error for invalid token', () => {
+      // Arrange
+      const token = 'invalid_token';
+      
+      jwt.verify.mockImplementation(() => {
+        throw new Error('jwt malformed');
+      });
+
+      // Act & Assert
+      expect(() => jwtService.verifyToken(token)).toThrow('Invalid or expired token');
+    });
+
+    it('should throw error for expired token', () => {
+      // Arrange
+      const token = 'expired_token';
+      
+      jwt.verify.mockImplementation(() => {
+        throw new Error('jwt expired');
+      });
+
+      // Act & Assert
+      expect(() => jwtService.verifyToken(token)).toThrow('Invalid or expired token');
+    });
+  });
+
+  describe('extractTokenFromCookies', () => {
+    it('should extract token from cookies object', () => {
+      // Arrange
+      const cookies = { auth_token: 'abc123xyz' };
+
+      // Act
+      const result = jwtService.extractTokenFromCookies(cookies);
+
+      // Assert
+      expect(result).toBe('abc123xyz');
+    });
+
+    it('should return null if cookies object is empty', () => {
+      // Arrange
+      const cookies = {};
+
+      // Act
+      const result = jwtService.extractTokenFromCookies(cookies);
+
+      // Assert
+      expect(result).toBeNull();
+    });
+
+    it('should return null if cookies is null', () => {
+      // Arrange
+      const cookies = null;
+
+      // Act
+      const result = jwtService.extractTokenFromCookies(cookies);
+
+      // Assert
+      expect(result).toBeNull();
+    });
+
+    it('should return null if cookies is undefined', () => {
+      // Arrange
+      const cookies = undefined;
+
+      // Act
+      const result = jwtService.extractTokenFromCookies(cookies);
+
+      // Assert
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getCookieOptions', () => {
+    it('should return secure cookie options in production', () => {
+      // Arrange
+      process.env.NODE_ENV = 'production';
+      jwtService = new JwtService();
+
+      // Act
+      const options = jwtService.getCookieOptions();
+
+      // Assert
+      expect(options.httpOnly).toBe(true);
+      expect(options.secure).toBe(true);
+      expect(options.sameSite).toBe('strict');
+      expect(options.path).toBe('/');
+      expect(options.maxAge).toBeGreaterThan(0);
+    });
+
+    it('should return non-secure cookie options in development', () => {
+      // Arrange
+      process.env.NODE_ENV = 'development';
+      jwtService = new JwtService();
+
+      // Act
+      const options = jwtService.getCookieOptions();
+
+      // Assert
+      expect(options.httpOnly).toBe(true);
+      expect(options.secure).toBe(false);
+      expect(options.sameSite).toBe('strict');
+    });
+  });
+
+  describe('getCookieName', () => {
+    it('should return the cookie name', () => {
+      // Act
+      const name = jwtService.getCookieName();
+
+      // Assert
+      expect(name).toBe('auth_token');
+    });
+  });
+
+  describe('extractTokenFromHeader (legacy)', () => {
+    it('should extract token from valid Authorization header', () => {
+      // Arrange
+      const authHeader = 'Bearer abc123xyz';
+
+      // Act
+      const result = jwtService.extractTokenFromHeader(authHeader);
+
+      // Assert
+      expect(result).toBe('abc123xyz');
+    });
+
+    it('should return null if Authorization header is missing', () => {
+      // Arrange
+      const authHeader = null;
+
+      // Act
+      const result = jwtService.extractTokenFromHeader(authHeader);
+
+      // Assert
+      expect(result).toBeNull();
+    });
+
+    it('should return null if Authorization header does not start with Bearer', () => {
+      // Arrange
+      const authHeader = 'Basic abc123xyz';
+
+      // Act
+      const result = jwtService.extractTokenFromHeader(authHeader);
+
+      // Assert
+      expect(result).toBeNull();
+    });
+  });
+});