blockmine 1.21.0 → 1.22.0

package/backend/src/__tests__/repositories/BaseRepository.test.js

@@ -0,0 +1,146 @@
+const BaseRepository = require('../../repositories/BaseRepository');
+
+describe('BaseRepository', () => {
+    let repository;
+    let mockPrisma;
+
+    beforeEach(() => {
+        // Mock Prisma client
+        mockPrisma = {
+            testModel: {
+                findUnique: jest.fn(),
+                findMany: jest.fn(),
+                findFirst: jest.fn(),
+                create: jest.fn(),
+                update: jest.fn(),
+                delete: jest.fn(),
+                count: jest.fn(),
+            }
+        };
+
+        repository = new BaseRepository({ prisma: mockPrisma });
+        repository.modelName = 'testModel';
+    });
+
+    describe('findById', () => {
+        test('должен вызвать findUnique с правильным ID', async () => {
+            const mockResult = { id: 1, name: 'Test' };
+            mockPrisma.testModel.findUnique.mockResolvedValue(mockResult);
+
+            const result = await repository.findById(1);
+
+            expect(mockPrisma.testModel.findUnique).toHaveBeenCalledWith({
+                where: { id: 1 }
+            });
+            expect(result).toEqual(mockResult);
+        });
+    });
+
+    describe('findMany', () => {
+        test('должен вызвать findMany без параметров', async () => {
+            const mockResults = [{ id: 1 }, { id: 2 }];
+            mockPrisma.testModel.findMany.mockResolvedValue(mockResults);
+
+            const results = await repository.findMany();
+
+            expect(mockPrisma.testModel.findMany).toHaveBeenCalledWith({
+                where: {}
+            });
+            expect(results).toEqual(mockResults);
+        });
+
+        test('должен вызвать findMany с where условием', async () => {
+            const mockResults = [{ id: 1, status: 'active' }];
+            mockPrisma.testModel.findMany.mockResolvedValue(mockResults);
+
+            const results = await repository.findMany({ status: 'active' });
+
+            expect(mockPrisma.testModel.findMany).toHaveBeenCalledWith({
+                where: { status: 'active' }
+            });
+            expect(results).toEqual(mockResults);
+        });
+
+        test('должен вызвать findMany с дополнительными опциями', async () => {
+            const mockResults = [{ id: 1 }];
+            mockPrisma.testModel.findMany.mockResolvedValue(mockResults);
+
+            const results = await repository.findMany(
+                { status: 'active' },
+                { orderBy: { createdAt: 'desc' }, take: 10 }
+            );
+
+            expect(mockPrisma.testModel.findMany).toHaveBeenCalledWith({
+                where: { status: 'active' },
+                orderBy: { createdAt: 'desc' },
+                take: 10
+            });
+            expect(results).toEqual(mockResults);
+        });
+    });
+
+    describe('create', () => {
+        test('должен создать новую запись', async () => {
+            const newData = { name: 'New Item' };
+            const mockResult = { id: 1, ...newData };
+            mockPrisma.testModel.create.mockResolvedValue(mockResult);
+
+            const result = await repository.create(newData);
+
+            expect(mockPrisma.testModel.create).toHaveBeenCalledWith({
+                data: newData
+            });
+            expect(result).toEqual(mockResult);
+        });
+    });
+
+    describe('update', () => {
+        test('должен обновить запись по ID', async () => {
+            const updateData = { name: 'Updated' };
+            const mockResult = { id: 1, ...updateData };
+            mockPrisma.testModel.update.mockResolvedValue(mockResult);
+
+            const result = await repository.update(1, updateData);
+
+            expect(mockPrisma.testModel.update).toHaveBeenCalledWith({
+                where: { id: 1 },
+                data: updateData
+            });
+            expect(result).toEqual(mockResult);
+        });
+    });
+
+    describe('delete', () => {
+        test('должен удалить запись по ID', async () => {
+            const mockResult = { id: 1 };
+            mockPrisma.testModel.delete.mockResolvedValue(mockResult);
+
+            const result = await repository.delete(1);
+
+            expect(mockPrisma.testModel.delete).toHaveBeenCalledWith({
+                where: { id: 1 }
+            });
+            expect(result).toEqual(mockResult);
+        });
+    });
+
+    describe('count', () => {
+        test('должен посчитать количество записей', async () => {
+            mockPrisma.testModel.count.mockResolvedValue(42);
+
+            const result = await repository.count({ status: 'active' });
+
+            expect(mockPrisma.testModel.count).toHaveBeenCalledWith({
+                where: { status: 'active' }
+            });
+            expect(result).toBe(42);
+        });
+    });
+
+    describe('model getter', () => {
+        test('должен вернуть правильную модель Prisma', () => {
+            const model = repository.model;
+            expect(model).toBe(mockPrisma.testModel);
+        });
+    });
+});

package/backend/src/__tests__/repositories/BotRepository.test.js

@@ -0,0 +1,118 @@
+const BotRepository = require('../../repositories/BotRepository');
+
+describe('BotRepository', () => {
+    let repository;
+    let mockPrisma;
+
+    beforeEach(() => {
+        mockPrisma = {
+            bot: {
+                findUnique: jest.fn(),
+                findMany: jest.fn(),
+                update: jest.fn(),
+            }
+        };
+
+        repository = new BotRepository({ prisma: mockPrisma });
+    });
+
+    test('должен установить modelName как "bot"', () => {
+        expect(repository.modelName).toBe('bot');
+    });
+
+    describe('findByIdWithServer', () => {
+        test('должен найти бота с сервером по ID', async () => {
+            const mockBot = {
+                id: 1,
+                username: 'TestBot',
+                server: { id: 1, host: 'mc.example.com', port: 25565 }
+            };
+            mockPrisma.bot.findUnique.mockResolvedValue(mockBot);
+
+            const result = await repository.findByIdWithServer(1);
+
+            expect(mockPrisma.bot.findUnique).toHaveBeenCalledWith({
+                where: { id: 1 },
+                include: { server: true }
+            });
+            expect(result).toEqual(mockBot);
+        });
+    });
+
+    describe('findAllWithServer', () => {
+        test('должен найти всех ботов с серверами', async () => {
+            const mockBots = [
+                { id: 1, username: 'Bot1', sortOrder: 0 },
+                { id: 2, username: 'Bot2', sortOrder: 1 }
+            ];
+            mockPrisma.bot.findMany.mockResolvedValue(mockBots);
+
+            const results = await repository.findAllWithServer();
+
+            expect(mockPrisma.bot.findMany).toHaveBeenCalledWith({
+                include: { server: true },
+                orderBy: { sortOrder: 'asc' }
+            });
+            expect(results).toEqual(mockBots);
+        });
+
+        test('должен принять дополнительные опции', async () => {
+            mockPrisma.bot.findMany.mockResolvedValue([]);
+
+            await repository.findAllWithServer({ take: 5 });
+
+            expect(mockPrisma.bot.findMany).toHaveBeenCalledWith({
+                include: { server: true },
+                orderBy: { sortOrder: 'asc' },
+                take: 5
+            });
+        });
+    });
+
+    describe('findByUsername', () => {
+        test('должен найти бота по username', async () => {
+            const mockBot = { id: 1, username: 'TestBot' };
+            mockPrisma.bot.findUnique.mockResolvedValue(mockBot);
+
+            const result = await repository.findByUsername('TestBot');
+
+            expect(mockPrisma.bot.findUnique).toHaveBeenCalledWith({
+                where: { username: 'TestBot' }
+            });
+            expect(result).toEqual(mockBot);
+        });
+    });
+
+    describe('findByServerId', () => {
+        test('должен найти всех ботов на сервере', async () => {
+            const mockBots = [
+                { id: 1, serverId: 5, sortOrder: 0 },
+                { id: 2, serverId: 5, sortOrder: 1 }
+            ];
+            mockPrisma.bot.findMany.mockResolvedValue(mockBots);
+
+            const results = await repository.findByServerId(5);
+
+            expect(mockPrisma.bot.findMany).toHaveBeenCalledWith({
+                where: { serverId: 5 },
+                orderBy: { sortOrder: 'asc' }
+            });
+            expect(results).toEqual(mockBots);
+        });
+    });
+
+    describe('updateSortOrder', () => {
+        test('должен обновить sortOrder бота', async () => {
+            const mockBot = { id: 1, sortOrder: 10 };
+            mockPrisma.bot.update.mockResolvedValue(mockBot);
+
+            const result = await repository.updateSortOrder(1, 10);
+
+            expect(mockPrisma.bot.update).toHaveBeenCalledWith({
+                where: { id: 1 },
+                data: { sortOrder: 10 }
+            });
+            expect(result).toEqual(mockBot);
+        });
+    });
+});

package/backend/src/__tests__/repositories/CommandRepository.test.js

@@ -0,0 +1,132 @@
+const CommandRepository = require('../../repositories/CommandRepository');
+
+describe('CommandRepository', () => {
+    let repository;
+    let mockPrisma;
+
+    beforeEach(() => {
+        mockPrisma = {
+            command: {
+                findMany: jest.fn(),
+                findFirst: jest.fn(),
+                update: jest.fn(),
+            }
+        };
+
+        repository = new CommandRepository({ prisma: mockPrisma });
+    });
+
+    test('должен установить modelName как "command"', () => {
+        expect(repository.modelName).toBe('command');
+    });
+
+    describe('findByBotId', () => {
+        test('должен найти все команды бота', async () => {
+            const mockCommands = [
+                { id: 1, botId: 1, name: 'test' },
+                { id: 2, botId: 1, name: 'help' }
+            ];
+            mockPrisma.command.findMany.mockResolvedValue(mockCommands);
+
+            const results = await repository.findByBotId(1);
+
+            expect(mockPrisma.command.findMany).toHaveBeenCalledWith({
+                where: { botId: 1 },
+                orderBy: { name: 'asc' }
+            });
+            expect(results).toEqual(mockCommands);
+        });
+    });
+
+    describe('findEnabledByBotId', () => {
+        test('должен найти только включенные команды', async () => {
+            const mockCommands = [
+                { id: 1, botId: 1, name: 'test', isEnabled: true }
+            ];
+            mockPrisma.command.findMany.mockResolvedValue(mockCommands);
+
+            const results = await repository.findEnabledByBotId(1);
+
+            expect(mockPrisma.command.findMany).toHaveBeenCalledWith({
+                where: {
+                    botId: 1,
+                    isEnabled: true
+                },
+                orderBy: { name: 'asc' }
+            });
+            expect(results).toEqual(mockCommands);
+        });
+    });
+
+    describe('findByName', () => {
+        test('должен найти команду по имени', async () => {
+            const mockCommand = { id: 1, botId: 1, name: 'test' };
+            mockPrisma.command.findFirst.mockResolvedValue(mockCommand);
+
+            const result = await repository.findByName(1, 'test');
+
+            expect(mockPrisma.command.findFirst).toHaveBeenCalledWith({
+                where: { botId: 1, name: 'test' }
+            });
+            expect(result).toEqual(mockCommand);
+        });
+    });
+
+    describe('findByNameOrAlias', () => {
+        test('должен найти команду по имени', async () => {
+            const mockCommands = [
+                { id: 1, name: 'test', aliases: '[]', isEnabled: true }
+            ];
+            mockPrisma.command.findMany.mockResolvedValue(mockCommands);
+
+            const result = await repository.findByNameOrAlias(1, 'test');
+
+            expect(result).toEqual(mockCommands[0]);
+        });
+
+        test('должен найти команду по алиасу', async () => {
+            const mockCommands = [
+                { id: 1, name: 'help', aliases: '["h", "?"]', isEnabled: true }
+            ];
+            mockPrisma.command.findMany.mockResolvedValue(mockCommands);
+
+            const result = await repository.findByNameOrAlias(1, 'h');
+
+            expect(result).toEqual(mockCommands[0]);
+        });
+
+        test('должен вернуть undefined если команда не найдена', async () => {
+            mockPrisma.command.findMany.mockResolvedValue([]);
+
+            const result = await repository.findByNameOrAlias(1, 'nonexistent');
+
+            expect(result).toBeUndefined();
+        });
+
+        test('должен обработать невалидный JSON в aliases', async () => {
+            const mockCommands = [
+                { id: 1, name: 'test', aliases: 'invalid json', isEnabled: true }
+            ];
+            mockPrisma.command.findMany.mockResolvedValue(mockCommands);
+
+            const result = await repository.findByNameOrAlias(1, 'alias');
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe('updateEnabled', () => {
+        test('должен обновить статус isEnabled', async () => {
+            const mockCommand = { id: 1, isEnabled: false };
+            mockPrisma.command.update.mockResolvedValue(mockCommand);
+
+            const result = await repository.updateEnabled(1, false);
+
+            expect(mockPrisma.command.update).toHaveBeenCalledWith({
+                where: { id: 1 },
+                data: { isEnabled: false }
+            });
+            expect(result).toEqual(mockCommand);
+        });
+    });
+});

package/backend/src/__tests__/repositories/EventGraphRepository.test.js

@@ -0,0 +1,93 @@
+const EventGraphRepository = require('../../repositories/EventGraphRepository');
+
+describe('EventGraphRepository', () => {
+    let repository;
+    let mockPrisma;
+
+    beforeEach(() => {
+        mockPrisma = {
+            eventGraph: {
+                findMany: jest.fn(),
+                update: jest.fn(),
+            }
+        };
+
+        repository = new EventGraphRepository({ prisma: mockPrisma });
+    });
+
+    test('должен установить modelName как "eventGraph"', () => {
+        expect(repository.modelName).toBe('eventGraph');
+    });
+
+    describe('findByBotId', () => {
+        test('должен найти все графы бота', async () => {
+            const mockGraphs = [
+                { id: 1, botId: 1, name: 'Graph 1' },
+                { id: 2, botId: 1, name: 'Graph 2' }
+            ];
+            mockPrisma.eventGraph.findMany.mockResolvedValue(mockGraphs);
+
+            const results = await repository.findByBotId(1);
+
+            expect(mockPrisma.eventGraph.findMany).toHaveBeenCalledWith({
+                where: { botId: 1 },
+                orderBy: { name: 'asc' }
+            });
+            expect(results).toEqual(mockGraphs);
+        });
+    });
+
+    describe('findEnabledByBotId', () => {
+        test('должен найти только включенные графы', async () => {
+            const mockGraphs = [
+                { id: 1, botId: 1, isEnabled: true }
+            ];
+            mockPrisma.eventGraph.findMany.mockResolvedValue(mockGraphs);
+
+            const results = await repository.findEnabledByBotId(1);
+
+            expect(mockPrisma.eventGraph.findMany).toHaveBeenCalledWith({
+                where: {
+                    botId: 1,
+                    isEnabled: true
+                }
+            });
+            expect(results).toEqual(mockGraphs);
+        });
+    });
+
+    describe('findByEventType', () => {
+        test('должен найти графы по типу события', async () => {
+            const mockGraphs = [
+                { id: 1, botId: 1, eventType: 'chat', isEnabled: true }
+            ];
+            mockPrisma.eventGraph.findMany.mockResolvedValue(mockGraphs);
+
+            const results = await repository.findByEventType(1, 'chat');
+
+            expect(mockPrisma.eventGraph.findMany).toHaveBeenCalledWith({
+                where: {
+                    botId: 1,
+                    eventType: 'chat',
+                    isEnabled: true
+                }
+            });
+            expect(results).toEqual(mockGraphs);
+        });
+    });
+
+    describe('updateEnabled', () => {
+        test('должен обновить статус isEnabled', async () => {
+            const mockGraph = { id: 1, isEnabled: false };
+            mockPrisma.eventGraph.update.mockResolvedValue(mockGraph);
+
+            const result = await repository.updateEnabled(1, false);
+
+            expect(mockPrisma.eventGraph.update).toHaveBeenCalledWith({
+                where: { id: 1 },
+                data: { isEnabled: false }
+            });
+            expect(result).toEqual(mockGraph);
+        });
+    });
+});

package/backend/src/__tests__/repositories/GroupRepository.test.js

@@ -0,0 +1,155 @@
+const GroupRepository = require('../../repositories/GroupRepository');
+
+describe('GroupRepository', () => {
+    let repository;
+    let mockPrisma;
+
+    beforeEach(() => {
+        mockPrisma = {
+            group: {
+                findMany: jest.fn(),
+                findUnique: jest.fn(),
+                upsert: jest.fn(),
+            },
+            groupPermission: {
+                upsert: jest.fn(),
+                deleteMany: jest.fn(),
+            }
+        };
+
+        repository = new GroupRepository({ prisma: mockPrisma });
+    });
+
+    test('должен установить modelName как "group"', () => {
+        expect(repository.modelName).toBe('group');
+    });
+
+    describe('findByBotId', () => {
+        test('должен найти все группы бота с правами', async () => {
+            const mockGroups = [
+                {
+                    id: 1,
+                    botId: 1,
+                    name: 'Admin',
+                    permissions: [
+                        { permission: { id: 1, name: 'admin.*' } }
+                    ]
+                },
+                {
+                    id: 2,
+                    botId: 1,
+                    name: 'User',
+                    permissions: []
+                }
+            ];
+            mockPrisma.group.findMany.mockResolvedValue(mockGroups);
+
+            const results = await repository.findByBotId(1);
+
+            expect(mockPrisma.group.findMany).toHaveBeenCalledWith({
+                where: { botId: 1 },
+                include: {
+                    permissions: {
+                        include: {
+                            permission: true
+                        }
+                    }
+                },
+                orderBy: { name: 'asc' }
+            });
+            expect(results).toEqual(mockGroups);
+        });
+    });
+
+    describe('findByName', () => {
+        test('должен найти группу по имени', async () => {
+            const mockGroup = {
+                id: 1,
+                botId: 1,
+                name: 'Moderator',
+                permissions: []
+            };
+            mockPrisma.group.findUnique.mockResolvedValue(mockGroup);
+
+            const result = await repository.findByName(1, 'Moderator');
+
+            expect(mockPrisma.group.findUnique).toHaveBeenCalledWith({
+                where: {
+                    botId_name: { botId: 1, name: 'Moderator' }
+                },
+                include: {
+                    permissions: {
+                        include: {
+                            permission: true
+                        }
+                    }
+                }
+            });
+            expect(result).toEqual(mockGroup);
+        });
+    });
+
+    describe('upsertGroup', () => {
+        test('должен создать новую группу', async () => {
+            const newGroup = {
+                id: 1,
+                botId: 1,
+                name: 'VIP',
+                owner: 'plugin'
+            };
+            mockPrisma.group.upsert.mockResolvedValue(newGroup);
+
+            const result = await repository.upsertGroup(1, 'VIP', {
+                owner: 'plugin'
+            });
+
+            expect(mockPrisma.group.upsert).toHaveBeenCalledWith({
+                where: {
+                    botId_name: { botId: 1, name: 'VIP' }
+                },
+                update: { owner: 'plugin' },
+                create: {
+                    botId: 1,
+                    name: 'VIP',
+                    owner: 'plugin'
+                }
+            });
+            expect(result).toEqual(newGroup);
+        });
+    });
+
+    describe('addPermissionToGroup', () => {
+        test('должен добавить право в группу', async () => {
+            const mockResult = {
+                groupId: 1,
+                permissionId: 5
+            };
+            mockPrisma.groupPermission.upsert.mockResolvedValue(mockResult);
+
+            const result = await repository.addPermissionToGroup(1, 5, mockPrisma);
+
+            expect(mockPrisma.groupPermission.upsert).toHaveBeenCalledWith({
+                where: {
+                    groupId_permissionId: { groupId: 1, permissionId: 5 }
+                },
+                update: {},
+                create: { groupId: 1, permissionId: 5 }
+            });
+            expect(result).toEqual(mockResult);
+        });
+    });
+
+    describe('removePermissionFromGroup', () => {
+        test('должен удалить право из группы', async () => {
+            const mockResult = { count: 1 };
+            mockPrisma.groupPermission.deleteMany.mockResolvedValue(mockResult);
+
+            const result = await repository.removePermissionFromGroup(1, 5, mockPrisma);
+
+            expect(mockPrisma.groupPermission.deleteMany).toHaveBeenCalledWith({
+                where: { groupId: 1, permissionId: 5 }
+            });
+            expect(result).toEqual(mockResult);
+        });
+    });
+});