negyedik gyakorlat + megoldasok

2026-03-04 20:02:39 +01:00
parent afc3777ac9
commit 388aa908de
217 changed files with 19791 additions and 0 deletions
@@ -0,0 +1,86 @@
+const GetAllUsersQueryHandler = require('../../../src/application/user/queries/GetAllUsersQueryHandler');
+const GetAllUsersQuery = require('../../../src/application/user/queries/GetAllUsersQuery');
+
+describe('GetAllUsersQueryHandler', () => {
+  let handler;
+  let mockPrisma;
+
+  beforeEach(() => {
+    // Mock Prisma
+    mockPrisma = {
+      user: {
+        findMany: jest.fn()
+      }
+    };
+
+    handler = new GetAllUsersQueryHandler(mockPrisma);
+
+    // Reset all mocks
+    jest.clearAllMocks();
+  });
+
+  describe('handle - success cases', () => {
+    it('should return all users successfully', async () => {
+      // Arrange
+      const query = new GetAllUsersQuery();
+      
+      mockPrisma.user.findMany.mockResolvedValue([
+        {
+          id: 1,
+          name: 'John Doe',
+          email: 'john@example.com',
+          password: 'hashed_password_1',
+          createdAt: new Date(),
+          updatedAt: new Date()
+        },
+        {
+          id: 2,
+          name: 'Jane Doe',
+          email: 'jane@example.com',
+          password: 'hashed_password_2',
+          createdAt: new Date(),
+          updatedAt: new Date()
+        }
+      ]);
+
+      // Act
+      const result = await handler.handle(query);
+
+      // Assert
+      expect(mockPrisma.user.findMany).toHaveBeenCalledWith({
+        orderBy: { createdAt: 'desc' }
+      });
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({
+        id: 1,
+        name: 'John Doe',
+        email: 'john@example.com',
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date)
+      });
+      expect(result[1]).toEqual({
+        id: 2,
+        name: 'Jane Doe',
+        email: 'jane@example.com',
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date)
+      });
+      // Passwords should not be returned
+      expect(result[0].password).toBeUndefined();
+      expect(result[1].password).toBeUndefined();
+    });
+
+    it('should return empty array if no users exist', async () => {
+      // Arrange
+      const query = new GetAllUsersQuery();
+      
+      mockPrisma.user.findMany.mockResolvedValue([]);
+
+      // Act
+      const result = await handler.handle(query);
+
+      // Assert
+      expect(result).toEqual([]);
+    });
+  });
+});
@@ -0,0 +1,65 @@
+const GetMeQueryHandler = require('../../../src/application/user/queries/GetMeQueryHandler');
+const GetMeQuery = require('../../../src/application/user/queries/GetMeQuery');
+
+describe('GetMeQueryHandler', () => {
+  let handler;
+  let mockPrisma;
+
+  beforeEach(() => {
+    // Mock Prisma
+    mockPrisma = {
+      user: {
+        findUnique: jest.fn()
+      }
+    };
+
+    handler = new GetMeQueryHandler(mockPrisma);
+
+    // Reset all mocks
+    jest.clearAllMocks();
+  });
+
+  describe('handle - success cases', () => {
+    it('should return current user successfully', async () => {
+      // Arrange
+      const query = new GetMeQuery(1);
+      
+      mockPrisma.user.findUnique.mockResolvedValue({
+        id: 1,
+        name: 'John Doe',
+        email: 'john@example.com',
+        password: 'hashed_password',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      });
+
+      // Act
+      const result = await handler.handle(query);
+
+      // Assert
+      expect(mockPrisma.user.findUnique).toHaveBeenCalledWith({
+        where: { id: 1 }
+      });
+      expect(result).toEqual({
+        id: 1,
+        name: 'John Doe',
+        email: 'john@example.com',
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date)
+      });
+      expect(result.password).toBeUndefined(); // Password should not be returned
+    });
+  });
+
+  describe('handle - error cases', () => {
+    it('should throw error if user not found', async () => {
+      // Arrange
+      const query = new GetMeQuery(999);
+      
+      mockPrisma.user.findUnique.mockResolvedValue(null);
+
+      // Act & Assert
+      await expect(handler.handle(query)).rejects.toThrow('User not found');
+    });
+  });
+});
@@ -0,0 +1,91 @@
+const GetUserByIdQueryHandler = require('../../../src/application/user/queries/GetUserByIdQueryHandler');
+const GetUserByIdQuery = require('../../../src/application/user/queries/GetUserByIdQuery');
+
+describe('GetUserByIdQueryHandler', () => {
+  let handler;
+  let mockPrisma;
+
+  beforeEach(() => {
+    // Mock Prisma
+    mockPrisma = {
+      user: {
+        findUnique: jest.fn()
+      }
+    };
+
+    handler = new GetUserByIdQueryHandler(mockPrisma);
+
+    // Reset all mocks
+    jest.clearAllMocks();
+  });
+
+  describe('handle - success cases', () => {
+    it('should return user by ID successfully', async () => {
+      // Arrange
+      const query = new GetUserByIdQuery(1);
+      
+      mockPrisma.user.findUnique.mockResolvedValue({
+        id: 1,
+        name: 'John Doe',
+        email: 'john@example.com',
+        password: 'hashed_password',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      });
+
+      // Act
+      const result = await handler.handle(query);
+
+      // Assert
+      expect(mockPrisma.user.findUnique).toHaveBeenCalledWith({
+        where: { id: 1 }
+      });
+      expect(result).toEqual({
+        id: 1,
+        name: 'John Doe',
+        email: 'john@example.com',
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date)
+      });
+      expect(result.password).toBeUndefined(); // Password should not be returned
+    });
+  });
+
+  describe('handle - validation errors', () => {
+    it('should throw error if userId is invalid (NaN)', async () => {
+      // Arrange
+      const query = new GetUserByIdQuery('invalid');
+
+      // Act & Assert
+      await expect(handler.handle(query)).rejects.toThrow('Valid user ID is required');
+    });
+
+    it('should throw error if userId is null', async () => {
+      // Arrange
+      const query = new GetUserByIdQuery(null);
+
+      // Act & Assert
+      await expect(handler.handle(query)).rejects.toThrow('Valid user ID is required');
+    });
+
+    it('should throw error if userId is undefined', async () => {
+      // Arrange
+      const query = new GetUserByIdQuery(undefined);
+
+      // Act & Assert
+      await expect(handler.handle(query)).rejects.toThrow('Valid user ID is required');
+    });
+  });
+
+  describe('handle - error cases', () => {
+    it('should throw error if user not found', async () => {
+      // Arrange
+      const query = new GetUserByIdQuery(999);
+      
+      mockPrisma.user.findUnique.mockResolvedValue(null);
+
+      // Act & Assert
+      await expect(handler.handle(query)).rejects.toThrow('User not found');
+    });
+  });
+});