FastGPT/test/cases/global/core/chat/utils.test.ts

import { describe, expect, it } from 'vitest';
import { ChatRoleEnum } from '@fastgpt/global/core/chat/constants';
import { FlowNodeTypeEnum } from '@fastgpt/global/core/workflow/node/constant';
import type { ChatItemType } from '@fastgpt/global/core/chat/type';
import {
  transformPreviewHistories,
  addStatisticalDataToHistoryItem
} from '@/global/core/chat/utils';

const mockResponseData = {
  id: '1',
  nodeId: '1',
  moduleName: 'test',
  moduleType: FlowNodeTypeEnum.chatNode
};

describe('transformPreviewHistories', () => {
  it('should transform histories correctly with responseDetail=true', () => {
    const histories: ChatItemType[] = [
      {
        obj: ChatRoleEnum.AI,
        value: [{ text: { content: 'test response' } }],
        responseData: [
          {
            ...mockResponseData,
            runningTime: 1.5
          }
        ]
      }
    ];

    const result = transformPreviewHistories(histories, true);

    expect(result[0]).toEqual({
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: 'test response' } }],
      responseData: undefined,
      useAgentSandbox: false,
      llmModuleAccount: 1,
      totalQuoteList: [],
      historyPreviewLength: undefined
    });
  });

  it('should transform histories correctly with responseDetail=false', () => {
    const histories: ChatItemType[] = [
      {
        obj: ChatRoleEnum.AI,
        value: [{ text: { content: 'test response' } }],
        responseData: [
          {
            ...mockResponseData,
            runningTime: 1.5
          }
        ]
      }
    ];

    const result = transformPreviewHistories(histories, false);

    expect(result[0]).toEqual({
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: 'test response' } }],
      responseData: undefined,
      useAgentSandbox: false,
      llmModuleAccount: 1,
      totalQuoteList: undefined,
      historyPreviewLength: undefined
    });
  });
});

describe('addStatisticalDataToHistoryItem', () => {
  it('should return original item if obj is not AI', () => {
    const item: ChatItemType = {
      obj: ChatRoleEnum.Human,
      value: [{ text: { content: 'test response' } }]
    };

    expect(addStatisticalDataToHistoryItem(item)).toBe(item);
  });

  it('should return original item if totalQuoteList is already defined', () => {
    const item: ChatItemType = {
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: 'test response' } }],
      totalQuoteList: []
    };

    expect(addStatisticalDataToHistoryItem(item)).toBe(item);
  });

  it('should return original item if responseData is undefined', () => {
    const item: ChatItemType = {
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: 'test response' } }]
    };

    expect(addStatisticalDataToHistoryItem(item)).toBe(item);
  });

  it('should calculate statistics correctly', () => {
    const quoteId = '507f1f77bcf86cd799439011'; // Valid 24-bit hex ID
    const item: ChatItemType = {
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: `test response with citation [${quoteId}](CITE)` } }],
      responseData: [
        {
          ...mockResponseData,
          moduleType: FlowNodeTypeEnum.chatNode,
          runningTime: 1.5,
          historyPreview: [{ obj: ChatRoleEnum.AI, value: 'preview1' }]
        },
        {
          ...mockResponseData,
          moduleType: FlowNodeTypeEnum.datasetSearchNode,
          quoteList: [
            {
              id: quoteId,
              q: 'test',
              a: 'answer',
              datasetId: 'ds1',
              collectionId: 'col1',
              sourceName: 'source1',
              chunkIndex: 0,
              updateTime: new Date(),
              score: []
            }
          ],
          runningTime: 0.5
        },
        {
          ...mockResponseData,
          moduleType: FlowNodeTypeEnum.toolCall,
          runningTime: 1,
          toolDetail: [
            {
              id: 'detail1',
              nodeId: 'detailNode1',
              moduleName: 'Detail Chat',
              moduleType: FlowNodeTypeEnum.chatNode,
              runningTime: 0.5
            }
          ]
        }
      ]
    };

    const result = addStatisticalDataToHistoryItem(item);

    expect(result).toEqual({
      ...item,
      llmModuleAccount: 3,
      useAgentSandbox: false,
      totalQuoteList: [
        {
          id: quoteId,
          q: 'test',
          a: 'answer',
          datasetId: 'ds1',
          collectionId: 'col1',
          sourceName: 'source1',
          chunkIndex: 0,
          updateTime: expect.any(Date),
          score: []
        }
      ],
      historyPreviewLength: 1
    });
  });

  it('should handle empty arrays and undefined values', () => {
    const item: ChatItemType = {
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: 'test response' } }],
      responseData: [
        {
          ...mockResponseData,
          runningTime: 0
        }
      ]
    };

    const result = addStatisticalDataToHistoryItem(item);

    expect(result).toEqual({
      ...item,
      useAgentSandbox: false,
      llmModuleAccount: 1,
      totalQuoteList: [],
      historyPreviewLength: undefined
    });
  });

  it('should handle nested plugin and loop details', () => {
    const item: ChatItemType = {
      obj: ChatRoleEnum.AI,
      value: [{ text: { content: 'test response' } }],
      responseData: [
        {
          ...mockResponseData,
          runningTime: 1,
          pluginDetail: [
            {
              id: 'plugin1',
              nodeId: 'pluginNode1',
              moduleName: 'Plugin Chat',
              moduleType: FlowNodeTypeEnum.chatNode,
              runningTime: 0.5
            }
          ],
          loopDetail: [
            {
              id: 'loop1',
              nodeId: 'loopNode1',
              moduleName: 'Loop Tool',
              moduleType: FlowNodeTypeEnum.toolCall,
              runningTime: 0.3
            }
          ]
        }
      ]
    };

    const result = addStatisticalDataToHistoryItem(item);

    expect(result).toEqual({
      ...item,
      useAgentSandbox: false,
      llmModuleAccount: 3,
      totalQuoteList: [],
      historyPreviewLength: undefined
    });
  });
});