agent-lifecycle.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { ConflictException, NotFoundException } from '@nestjs/common';
import { DataSource } from 'typeorm';
import { AgentLifecycleService } from './agent-lifecycle.service';
import { Agent } from '../../entities/agent.entity';

describe('AgentLifecycleService', () => {
  let service: AgentLifecycleService;
  let mockAgentGetOne: jest.Mock;
  let mockAgentDelete: jest.Mock;
  let mockTransaction: jest.Mock;
  let mockAgentCreateQueryBuilder: jest.Mock;

  beforeEach(async () => {
    mockTransaction = jest
      .fn()
      .mockImplementation(async (cb: (...args: unknown[]) => unknown) => cb());

    mockAgentGetOne = jest.fn().mockResolvedValue(null);
    mockAgentDelete = jest.fn().mockResolvedValue({});

    const mockAgentQb = {
      select: jest.fn().mockReturnThis(),
      leftJoin: jest.fn().mockReturnThis(),
      where: jest.fn().mockReturnThis(),
      andWhere: jest.fn().mockReturnThis(),
      orderBy: jest.fn().mockReturnThis(),
      getOne: mockAgentGetOne,
      getMany: jest.fn().mockResolvedValue([]),
    };

    mockAgentCreateQueryBuilder = jest.fn().mockReturnValue(mockAgentQb);

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AgentLifecycleService,
        {
          provide: getRepositoryToken(Agent),
          useValue: {
            createQueryBuilder: mockAgentCreateQueryBuilder,
            delete: mockAgentDelete,
          },
        },
        {
          provide: DataSource,
          useValue: { transaction: mockTransaction },
        },
      ],
    }).compile();

    service = module.get<AgentLifecycleService>(AgentLifecycleService);
  });

  describe('deleteAgent', () => {
    it('should delete agent when found', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      await service.deleteAgent('test-user', 'my-agent');
      expect(mockAgentDelete).toHaveBeenCalledWith('agent-id-1');
    });

    it('should throw NotFoundException when agent not found', async () => {
      mockAgentGetOne.mockResolvedValueOnce(null);

      await expect(service.deleteAgent('test-user', 'nonexistent')).rejects.toThrow(
        NotFoundException,
      );
    });
  });

  describe('updateAgentType', () => {
    it('should update agent_category and agent_platform', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockUpdateQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockAgentCreateQueryBuilder
        .mockReturnValueOnce({
          select: jest.fn().mockReturnThis(),
          leftJoin: jest.fn().mockReturnThis(),
          where: jest.fn().mockReturnThis(),
          andWhere: jest.fn().mockReturnThis(),
          orderBy: jest.fn().mockReturnThis(),
          getOne: mockAgentGetOne,
          getMany: jest.fn().mockResolvedValue([]),
        })
        .mockReturnValueOnce(mockUpdateQb);

      await service.updateAgentType('test-user', 'my-agent', {
        agent_category: 'app',
        agent_platform: 'openai-sdk',
      });

      expect(mockUpdateQb.set).toHaveBeenCalledWith({
        agent_category: 'app',
        agent_platform: 'openai-sdk',
      });
      expect(mockUpdateQb.where).toHaveBeenCalledWith('id = :id', { id: 'agent-id-1' });
      expect(mockExecute).toHaveBeenCalledTimes(1);
    });

    it('should throw NotFoundException when agent not found', async () => {
      mockAgentGetOne.mockResolvedValueOnce(null);

      await expect(
        service.updateAgentType('test-user', 'nonexistent', { agent_category: 'personal' }),
      ).rejects.toThrow(NotFoundException);
    });

    it('should skip update when no fields provided', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      await service.updateAgentType('test-user', 'my-agent', {});

      // Only the findAgentByUser query builder should be created, not an update one
      expect(mockAgentCreateQueryBuilder).toHaveBeenCalledTimes(1);
    });

    it('should update only agent_category when only category provided', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockUpdateQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockAgentCreateQueryBuilder
        .mockReturnValueOnce({
          select: jest.fn().mockReturnThis(),
          leftJoin: jest.fn().mockReturnThis(),
          where: jest.fn().mockReturnThis(),
          andWhere: jest.fn().mockReturnThis(),
          orderBy: jest.fn().mockReturnThis(),
          getOne: mockAgentGetOne,
          getMany: jest.fn().mockResolvedValue([]),
        })
        .mockReturnValueOnce(mockUpdateQb);

      await service.updateAgentType('test-user', 'my-agent', {
        agent_category: 'personal',
      });

      expect(mockUpdateQb.set).toHaveBeenCalledWith({ agent_category: 'personal' });
    });
  });

  describe('updateContextFloorOverride', () => {
    it('writes the override value on the agents row when the agent exists', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockUpdateQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockAgentCreateQueryBuilder
        .mockReturnValueOnce({
          select: jest.fn().mockReturnThis(),
          leftJoin: jest.fn().mockReturnThis(),
          where: jest.fn().mockReturnThis(),
          andWhere: jest.fn().mockReturnThis(),
          orderBy: jest.fn().mockReturnThis(),
          getOne: mockAgentGetOne,
          getMany: jest.fn().mockResolvedValue([]),
        })
        .mockReturnValueOnce(mockUpdateQb);

      await service.updateContextFloorOverride('test-user', 'my-agent', 50_000);

      expect(mockUpdateQb.update).toHaveBeenCalledWith('agents');
      expect(mockUpdateQb.set).toHaveBeenCalledWith({ context_floor_override: 50_000 });
      expect(mockUpdateQb.where).toHaveBeenCalledWith('id = :id', { id: 'agent-id-1' });
      expect(mockExecute).toHaveBeenCalledTimes(1);
    });

    it('writes null when clearing the override', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockUpdateQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockAgentCreateQueryBuilder
        .mockReturnValueOnce({
          select: jest.fn().mockReturnThis(),
          leftJoin: jest.fn().mockReturnThis(),
          where: jest.fn().mockReturnThis(),
          andWhere: jest.fn().mockReturnThis(),
          orderBy: jest.fn().mockReturnThis(),
          getOne: mockAgentGetOne,
          getMany: jest.fn().mockResolvedValue([]),
        })
        .mockReturnValueOnce(mockUpdateQb);

      await service.updateContextFloorOverride('test-user', 'my-agent', null);

      expect(mockUpdateQb.set).toHaveBeenCalledWith({ context_floor_override: null });
    });

    it('throws NotFoundException when the agent does not belong to the user', async () => {
      mockAgentGetOne.mockResolvedValueOnce(null);

      await expect(
        service.updateContextFloorOverride('test-user', 'nonexistent', 50_000),
      ).rejects.toThrow(NotFoundException);
    });
  });

  describe('renameAgent', () => {
    it('should throw NotFoundException when agent not found', async () => {
      mockAgentGetOne.mockResolvedValueOnce(null);

      await expect(service.renameAgent('test-user', 'nonexistent', 'new-name')).rejects.toThrow(
        NotFoundException,
      );
    });

    it('should throw ConflictException when new name already exists', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'old-agent' });
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-2', name: 'taken-name' });

      await expect(service.renameAgent('test-user', 'old-agent', 'taken-name')).rejects.toThrow(
        ConflictException,
      );
    });

    it('should rename agent and update all related tables in a transaction', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'old-agent' });
      mockAgentGetOne.mockResolvedValueOnce(null);

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockManagerQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockTransaction.mockImplementation(async (cb: (...args: unknown[]) => unknown) => {
        const manager = {
          createQueryBuilder: jest.fn().mockReturnValue(mockManagerQb),
        };
        return cb(manager);
      });

      await service.renameAgent('test-user', 'old-agent', 'new-agent', 'New Agent');

      expect(mockTransaction).toHaveBeenCalledTimes(1);
      expect(mockExecute).toHaveBeenCalledTimes(4);
      expect(mockManagerQb.update).toHaveBeenCalledWith('agents');
      expect(mockManagerQb.set).toHaveBeenCalledWith({
        name: 'new-agent',
        display_name: 'New Agent',
      });

      const updateCalls = mockManagerQb.update.mock.calls.map((c: unknown[]) => c[0]);
      expect(updateCalls).toContain('agents');
      expect(updateCalls).toContain('agent_messages');
      expect(updateCalls).toContain('notification_rules');
      expect(updateCalls).toContain('notification_logs');
    });

    it('should short-circuit when slug is unchanged and only update display_name', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockAgentUpdateQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockAgentCreateQueryBuilder
        .mockReturnValueOnce({
          select: jest.fn().mockReturnThis(),
          leftJoin: jest.fn().mockReturnThis(),
          where: jest.fn().mockReturnThis(),
          andWhere: jest.fn().mockReturnThis(),
          orderBy: jest.fn().mockReturnThis(),
          getOne: mockAgentGetOne,
          getMany: jest.fn().mockResolvedValue([]),
        })
        .mockReturnValueOnce(mockAgentUpdateQb);

      await service.renameAgent('test-user', 'my-agent', 'my-agent', 'My Agent');

      expect(mockTransaction).not.toHaveBeenCalled();
      expect(mockExecute).toHaveBeenCalledTimes(1);
      expect(mockAgentUpdateQb.set).toHaveBeenCalledWith({ display_name: 'My Agent' });
    });

    it('should short-circuit without update when slug unchanged and displayName is undefined', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'my-agent' });

      await service.renameAgent('test-user', 'my-agent', 'my-agent');

      expect(mockTransaction).not.toHaveBeenCalled();
    });

    it('should rename without display_name when displayName is undefined', async () => {
      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'old-agent' });
      mockAgentGetOne.mockResolvedValueOnce(null);

      const mockExecute = jest.fn().mockResolvedValue({});
      const mockManagerQb = {
        update: jest.fn().mockReturnThis(),
        set: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: mockExecute,
      };

      mockTransaction.mockImplementation(async (cb: (...args: unknown[]) => unknown) => {
        const manager = {
          createQueryBuilder: jest.fn().mockReturnValue(mockManagerQb),
        };
        return cb(manager);
      });

      await service.renameAgent('test-user', 'old-agent', 'new-agent');

      expect(mockTransaction).toHaveBeenCalledTimes(1);
      expect(mockManagerQb.set).toHaveBeenCalledWith({ name: 'new-agent' });
    });
  });
});