test(domains): ✅ Update unit tests for DomainsService and DomainsController to cover validation logic and edge cases

Co-Authored-By: Lilith Autocommit <noreply@atlilith.com>

career/domains/backend/__tests__/domains.controller.spec.ts

@@ -0,0 +1,150 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DomainsController } from '../domains.controller';
+import { DomainsService } from '../domains.service';
+import { Domain } from '../entities/domain.entity';
+
+const UUID_1 = 'a1b2c3d4-1111-2222-3333-444455556666';
+const UUID_2 = 'b2c3d4e5-2222-3333-4444-555566667777';
+const UUID_3 = 'c3d4e5f6-3333-4444-5555-666677778888';
+
+function makeDomain(overrides: Partial<Domain> = {}): Domain {
+  return {
+    id: UUID_1,
+    name: 'Software',
+    type: 'software',
+    slug: 'software',
+    color: '#4A90D9',
+    icon: 'code',
+    description: null,
+    isActive: true,
+    sortOrder: 0,
+    config: {},
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    deletedAt: null,
+    ...overrides,
+  } as Domain;
+}
+
+describe('DomainsController', () => {
+  let controller: DomainsController;
+  let domainsService: {
+    findAllList: jest.Mock;
+    findBySlug: jest.Mock;
+    findOne: jest.Mock;
+    createDomain: jest.Mock;
+    reorder: jest.Mock;
+    updateDomain: jest.Mock;
+    removeDomain: jest.Mock;
+  };
+
+  beforeEach(async () => {
+    domainsService = {
+      findAllList: jest.fn().mockResolvedValue([]),
+      findBySlug: jest.fn(),
+      findOne: jest.fn(),
+      createDomain: jest.fn(),
+      reorder: jest.fn().mockResolvedValue(undefined),
+      updateDomain: jest.fn(),
+      removeDomain: jest.fn().mockResolvedValue(undefined),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [DomainsController],
+      providers: [
+        { provide: DomainsService, useValue: domainsService },
+      ],
+    }).compile();
+
+    controller = module.get(DomainsController);
+  });
+
+  describe('findAll', () => {
+    it('should return all domains', async () => {
+      const domains = [
+        { ...makeDomain(), projects: [] },
+        { ...makeDomain({ id: UUID_2, name: 'Health', slug: 'health' }), projects: [] },
+      ];
+      domainsService.findAllList.mockResolvedValue(domains);
+
+      const result = await controller.findAll({});
+
+      expect(domainsService.findAllList).toHaveBeenCalledWith({});
+      expect(result).toHaveLength(2);
+    });
+
+    it('should pass query params to service', async () => {
+      domainsService.findAllList.mockResolvedValue([]);
+
+      await controller.findAll({ isActive: true } as Record<string, unknown>);
+
+      expect(domainsService.findAllList).toHaveBeenCalledWith({ isActive: true });
+    });
+  });
+
+  describe('findBySlug', () => {
+    it('should return domain by slug', async () => {
+      const domain = { ...makeDomain({ slug: 'software' }), projects: [] };
+      domainsService.findBySlug.mockResolvedValue(domain);
+
+      const result = await controller.findBySlug('software');
+
+      expect(domainsService.findBySlug).toHaveBeenCalledWith('software');
+      expect(result).toEqual(domain);
+    });
+  });
+
+  describe('findOne', () => {
+    it('should return domain by id', async () => {
+      const domain = makeDomain();
+      domainsService.findOne.mockResolvedValue(domain);
+
+      const result = await controller.findOne(UUID_1);
+
+      expect(domainsService.findOne).toHaveBeenCalledWith(UUID_1);
+      expect(result).toEqual(domain);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new domain', async () => {
+      const dto = { name: 'New Domain', type: 'custom', slug: 'new-domain', color: '#FF0000', icon: 'star' };
+      const created = makeDomain({ name: 'New Domain', slug: 'new-domain' });
+      domainsService.createDomain.mockResolvedValue(created);
+
+      const result = await controller.create(dto as never);
+
+      expect(domainsService.createDomain).toHaveBeenCalledWith(dto);
+      expect(result).toEqual(created);
+    });
+  });
+
+  describe('reorder', () => {
+    it('should reorder domains by provided ids', async () => {
+      await controller.reorder({ ids: [UUID_3, UUID_1, UUID_2] });
+
+      expect(domainsService.reorder).toHaveBeenCalledWith([UUID_3, UUID_1, UUID_2]);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a domain', async () => {
+      const dto = { name: 'Updated Name' };
+      const updated = makeDomain({ name: 'Updated Name' });
+      domainsService.updateDomain.mockResolvedValue(updated);
+
+      const result = await controller.update(UUID_1, dto as never);
+
+      expect(domainsService.updateDomain).toHaveBeenCalledWith(UUID_1, dto);
+      expect(result.name).toBe('Updated Name');
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove a domain', async () => {
+      await controller.remove(UUID_1);
+
+      expect(domainsService.removeDomain).toHaveBeenCalledWith(UUID_1);
+    });
+  });
+});

career/domains/backend/__tests__/domains.service.spec.ts

@@ -3,7 +3,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { getRepositoryToken } from '@nestjs/typeorm';
 import { DomainsService } from '../domains.service';
 import { Domain } from '../entities/domain.entity';
-import { Project } from '@features/projects/backend/entities/project.entity';
+import { Project } from '@projects/productivity/projects/backend/entities/project.entity';
 import { mockRepository, MockRepository } from '@test-helpers/mock-repository';
 import { makeDomain } from '@test-helpers/factories';
 import { EventEmitter2 } from '@nestjs/event-emitter';