knowai/test/mocks/data-factory.ts

/**
 * Mock数据工厂
 * 用于生成测试中使用的各种模拟数据
 */

import type {
  User,
  UserProfile,
  LoginRequest,
  LoginResponse,
  RegisterRequest,
  RegisterResponse,
  RefreshTokenRequest,
  RefreshTokenResponse,
  UserProfileUpdateRequest,
  UserProfileUpdateResponse,
  UserFollowRequest,
  UserFollowResponse
} from '@/types/user';
import type {
  Post,
  PostComment,
  CreatePostRequest,
  CreatePostResponse,
  GetPostsRequest,
  GetPostsResponse,
  GetPostRequest,
  GetPostResponse,
  LikePostRequest,
  LikePostResponse,
  BookmarkPostRequest,
  BookmarkPostResponse,
  CreateCommentRequest,
  CreateCommentResponse,
  GetCommentsRequest,
  GetCommentsResponse,
  LikeCommentRequest,
  LikeCommentResponse
} from '@/types/post';
import type {
  AIModel,
  ModelComment,
  GetAIPlazaRequest,
  GetAIPlazaResponse,
  GetModelDetailRequest,
  GetModelDetailResponse,
  GetModelCommentsRequest,
  GetModelCommentsResponse,
  CreateModelCommentRequest,
  CreateModelCommentResponse,
  LikeModelCommentRequest,
  LikeModelCommentResponse
} from '@/types/model';
import type {
  ChatSession,
  ChatMessage,
  CreateChatSessionRequest,
  UpdateChatSessionRequest,
  SendMessageRequest,
  GetChatSessionsRequest,
  GetChatSessionsResponse,
  GetChatMessagesRequest,
  GetChatMessagesResponse,
  MarkMessagesAsReadRequest,
  MarkMessagesAsReadResponse
} from '@/types/chat';
import type { ApiResponse, ApiRequestConfig } from '@/types';

// 生成模拟用户数据
export function createMockUser(overrides: Partial<User> = {}): User {
  return {
    id: 'user-123',
    username: 'testuser',
    ...overrides
  };
}

// 生成模拟用户档案数据
export function createMockUserProfile(overrides: Partial<UserProfile> = {}): UserProfile {
  return {
    user: createMockUser(),
    avatar: 'https://example.com/avatar.jpg',
    introduction: 'Test user introduction',
    level: 'advanced',
    ...overrides
  };
}

// 生成模拟登录请求数据
export function createMockLoginRequest(overrides: Partial<LoginRequest> = {}): LoginRequest {
  return {
    username: 'testuser',
    password: 'password123',
    ...overrides
  };
}

// 生成模拟登录响应数据
export function createMockLoginResponse(overrides: Partial<LoginResponse> = {}): LoginResponse {
  return {
    user: createMockUser(),
    avatar: 'https://example.com/avatar.jpg',
    token: 'mock-jwt-token',
    expiresIn: 3600,
    refreshToken: 'mock-refresh-token',
    ...overrides
  };
}

// 生成模拟注册请求数据
export function createMockRegisterRequest(overrides: Partial<RegisterRequest> = {}): RegisterRequest {
  return {
    username: 'newuser',
    password: 'password123',
    ...overrides
  };
}

// 生成模拟注册响应数据
export function createMockRegisterResponse(overrides: Partial<RegisterResponse> = {}): RegisterResponse {
  return {
    user: createMockUser({ username: 'newuser' }),
    avatar: 'https://example.com/avatar.jpg',
    token: 'mock-jwt-token',
    expiresIn: 3600,
    refreshToken: 'mock-refresh-token',
    ...overrides
  };
}

// 生成模拟刷新令牌请求数据
export function createMockRefreshTokenRequest(overrides: Partial<RefreshTokenRequest> = {}): RefreshTokenRequest {
  return {
    refreshToken: 'mock-refresh-token',
    ...overrides
  };
}

// 生成模拟刷新令牌响应数据
export function createMockRefreshTokenResponse(overrides: Partial<RefreshTokenResponse> = {}): RefreshTokenResponse {
  return {
    token: 'new-mock-jwt-token',
    expiresIn: 3600,
    refreshToken: 'new-mock-refresh-token',
    ...overrides
  };
}

// 生成模拟用户档案更新请求数据
export function createMockUserProfileUpdateRequest(overrides: Partial<UserProfileUpdateRequest> = {}): UserProfileUpdateRequest {
  return {
    avatar: 'https://example.com/new-avatar.jpg',
    introduction: 'Updated introduction',
    level: 'expert',
    ...overrides
  };
}

// 生成模拟用户档案更新响应数据
export function createMockUserProfileUpdateResponse(overrides: Partial<UserProfileUpdateResponse> = {}): UserProfileUpdateResponse {
  return {
    profile: createMockUserProfile({
      avatar: 'https://example.com/new-avatar.jpg',
      introduction: 'Updated introduction',
      level: 'expert'
    }),
    ...overrides
  };
}

// 生成模拟用户关注请求数据
export function createMockUserFollowRequest(overrides: Partial<UserFollowRequest> = {}): UserFollowRequest {
  return {
    userId: 'user-456',
    ...overrides
  };
}

// 生成模拟用户关注响应数据
export function createMockUserFollowResponse(overrides: Partial<UserFollowResponse> = {}): UserFollowResponse {
  return {
    success: true,
    ...overrides
  };
}

// 生成模拟帖子数据
export function createMockPost(overrides: Partial<Post> = {}): Post {
  const now = new Date();
  return {
    id: 'post-123',
    createdAt: now,
    updatedAt: now,
    title: 'Test Post Title',
    excerpt: 'This is a test post excerpt',
    tags: ['test', 'mock'],
    stars: 5,
    likes: 10,
    comments: 2,
    type: 'article',
    authorId: 'user-123',
    author: { user: createMockUser() },
    images: ['https://example.com/image.jpg'],
    publishedAt: now,
    ...overrides
  };
}

// 生成模拟创建帖子请求数据
export function createMockCreatePostRequest(overrides: Partial<CreatePostRequest> = {}): CreatePostRequest {
  return {
    title: 'New Test Post',
    excerpt: 'This is a new test post excerpt',
    tags: ['new', 'test'],
    stars: 0,
    likes: 0,
    comments: 0,
    type: 'article',
    images: ['https://example.com/new-image.jpg'],
    publishedAt: new Date(),
    ...overrides
  };
}

// 生成模拟创建帖子响应数据
export function createMockCreatePostResponse(overrides: Partial<CreatePostResponse> = {}): CreatePostResponse {
  return {
    post: createMockPost(),
    ...overrides
  };
}

// 生成模拟获取帖子列表请求数据
export function createMockGetPostsRequest(overrides: Partial<GetPostsRequest> = {}): GetPostsRequest {
  return {
    page: 1,
    limit: 10,
    sortBy: 'createdAt',
    type: 'article',
    sortOrder: 'desc',
    authorId: 'user-123',
    search: 'test query',
    ...overrides
  };
}

// 生成模拟获取帖子列表响应数据
export function createMockGetPostsResponse(overrides: Partial<GetPostsResponse> = {}): GetPostsResponse {
  return {
    data: [createMockPost(), createMockPost({ id: 'post-456' })],
    total: 2,
    page: 1,
    limit: 10,
    hasMore: false,
    sortBy: 'createdAt',
    ...overrides
  };
}

// 生成模拟获取帖子详情请求数据
export function createMockGetPostRequest(overrides: Partial<GetPostRequest> = {}): GetPostRequest {
  return {
    postId: 'post-123',
    ...overrides
  };
}

// 生成模拟获取帖子详情响应数据
export function createMockGetPostResponse(overrides: Partial<GetPostResponse> = {}): GetPostResponse {
  return {
    post: createMockPost(),
    ...overrides
  };
}

// 生成模拟点赞帖子请求数据
export function createMockLikePostRequest(overrides: Partial<LikePostRequest> = {}): LikePostRequest {
  return {
    postId: 'post-123',
    ...overrides
  };
}

// 生成模拟点赞帖子响应数据
export function createMockLikePostResponse(overrides: Partial<LikePostResponse> = {}): LikePostResponse {
  return {
    success: true,
    ...overrides
  };
}

// 生成模拟收藏帖子请求数据
export function createMockBookmarkPostRequest(overrides: Partial<BookmarkPostRequest> = {}): BookmarkPostRequest {
  return {
    postId: 'post-123',
    ...overrides
  };
}

// 生成模拟收藏帖子响应数据
export function createMockBookmarkPostResponse(overrides: Partial<BookmarkPostResponse> = {}): BookmarkPostResponse {
  return {
    success: true,
    ...overrides
  };
}

// 生成模拟帖子评论数据
export function createMockPostComment(overrides: Partial<PostComment> = {}): PostComment {
  const now = new Date();
  return {
    id: 'comment-123',
    createdAt: now,
    updatedAt: now,
    authorId: 'user-456',
    author: { user: createMockUser({ id: 'user-456', username: 'commenter' }) },
    content: 'This is a test comment',
    parentId: 'parent-comment-123',
    ...overrides
  };
}

// 生成模拟创建评论请求数据
export function createMockCreateCommentRequest(overrides: Partial<CreateCommentRequest> = {}): CreateCommentRequest {
  return {
    postId: 'post-123',
    content: 'This is a new test comment',
    parentId: 'parent-comment-123',
    ...overrides
  };
}

// 生成模拟创建评论响应数据
export function createMockCreateCommentResponse(overrides: Partial<CreateCommentResponse> = {}): CreateCommentResponse {
  return {
    comment: createMockPostComment(),
    ...overrides
  };
}

// 生成模拟获取评论列表请求数据
export function createMockGetCommentsRequest(overrides: Partial<GetCommentsRequest> = {}): GetCommentsRequest {
  return {
    page: 1,
    limit: 10,
    sortOrder: 'desc',
    postId: 'post-123',
    parentId: 'parent-comment-123',
    sortBy: 'createdAt',
    ...overrides
  };
}

// 生成模拟获取评论列表响应数据
export function createMockGetCommentsResponse(overrides: Partial<GetCommentsResponse> = {}): GetCommentsResponse {
  return {
    data: [createMockPostComment(), createMockPostComment({ id: 'comment-456' })],
    total: 2,
    page: 1,
    limit: 10,
    hasMore: false,
    ...overrides
  };
}

// 生成模拟点赞评论请求数据
export function createMockLikeCommentRequest(overrides: Partial<LikeCommentRequest> = {}): LikeCommentRequest {
  return {
    commentId: 'comment-123',
    ...overrides
  };
}

// 生成模拟点赞评论响应数据
export function createMockLikeCommentResponse(overrides: Partial<LikeCommentResponse> = {}): LikeCommentResponse {
  return {
    success: true,
    ...overrides
  };
}

// 生成模拟AI模型数据
export function createMockAIModel(overrides: Partial<AIModel> = {}): AIModel {
  return {
    id: 'model-123',
    name: 'Test AI Model',
    description: 'This is a test AI model description',
    avatar: 'https://example.com/model-avatar.jpg',
    tags: ['test', 'ai', 'model'],
    website: 'https://example.com/model-website',
    clickCount: 1000,
    likeCount: 50,
    ...overrides
  };
}

// 生成模拟AI模型评论数据
export function createMockModelComment(overrides: Partial<ModelComment> = {}): ModelComment {
  const now = new Date();
  return {
    id: 'model-comment-123',
    createdAt: now,
    updatedAt: now,
    modelId: 'model-123',
    authorId: 'user-456',
    author: { user: createMockUser({ id: 'user-456', username: 'reviewer' }) },
    content: 'This is a test model review',
    parentId: 'parent-comment-123',
    stats: {
      stars: 5,
      likes: 10,
      comments: 2,
      replies: 1
    },
    ...overrides
  };
}

// 生成模拟获取AI模型广场请求数据
export function createMockGetAIPlazaRequest(overrides: Partial<GetAIPlazaRequest> = {}): GetAIPlazaRequest {
  return {
    ...overrides
  };
}

// 生成模拟获取AI模型广场响应数据
export function createMockGetAIPlazaResponse(overrides: Partial<GetAIPlazaResponse> = {}): GetAIPlazaResponse {
  return {
    models: [createMockAIModel(), createMockAIModel({ id: 'model-456' })],
    hotRankings: [
      { model: createMockAIModel(), rank: 1, change: 'up' },
      { model: createMockAIModel({ id: 'model-456' }), rank: 2, change: 'same' }
    ],
    clickRankings: [
      { model: createMockAIModel(), rank: 1, change: 'down' },
      { model: createMockAIModel({ id: 'model-456' }), rank: 2, change: 'up' }
    ],
    ...overrides
  };
}

// 生成模拟获取模型详情请求数据
export function createMockGetModelDetailRequest(overrides: Partial<GetModelDetailRequest> = {}): GetModelDetailRequest {
  return {
    modelId: 'model-123',
    page: 1,
    limit: 10,
    sortBy: 'createdAt',
    ...overrides
  };
}

// 生成模拟获取模型详情响应数据
export function createMockGetModelDetailResponse(overrides: Partial<GetModelDetailResponse> = {}): GetModelDetailResponse {
  return {
    model: createMockAIModel(),
    comments: [createMockModelComment(), createMockModelComment({ id: 'model-comment-456' })],
    totalComments: 2,
    hasMoreComments: false,
    ...overrides
  };
}

// 生成模拟获取模型评论请求数据
export function createMockGetModelCommentsRequest(overrides: Partial<GetModelCommentsRequest> = {}): GetModelCommentsRequest {
  return {
    modelId: 'model-123',
    page: 1,
    limit: 10,
    sortBy: 'createdAt',
    parentId: 'parent-comment-123',
    ...overrides
  };
}

// 生成模拟获取模型评论响应数据
export function createMockGetModelCommentsResponse(overrides: Partial<GetModelCommentsResponse> = {}): GetModelCommentsResponse {
  return {
    comments: [createMockModelComment(), createMockModelComment({ id: 'model-comment-456' })],
    total: 2,
    page: 1,
    limit: 10,
    hasMore: false,
    ...overrides
  };
}

// 生成模拟创建模型评论请求数据
export function createMockCreateModelCommentRequest(overrides: Partial<CreateModelCommentRequest> = {}): CreateModelCommentRequest {
  return {
    modelId: 'model-123',
    content: 'This is a new test model review',
    parentId: 'parent-comment-123',
    ...overrides
  };
}

// 生成模拟创建模型评论响应数据
export function createMockCreateModelCommentResponse(overrides: Partial<CreateModelCommentResponse> = {}): CreateModelCommentResponse {
  return {
    comment: createMockModelComment(),
    ...overrides
  };
}

// 生成模拟点赞模型评论请求数据
export function createMockLikeModelCommentRequest(overrides: Partial<LikeModelCommentRequest> = {}): LikeModelCommentRequest {
  return {
    commentId: 'model-comment-123',
    ...overrides
  };
}

// 生成模拟点赞模型评论响应数据
export function createMockLikeModelCommentResponse(overrides: Partial<LikeModelCommentResponse> = {}): LikeModelCommentResponse {
  return {
    success: true,
    ...overrides
  };
}

// 生成模拟聊天会话数据
export function createMockChatSession(overrides: Partial<ChatSession> = {}): ChatSession {
  const now = new Date();
  const user1 = createMockUser({ id: 'user-1', username: 'user1' });
  const user2 = createMockUser({ id: 'user-2', username: 'user2' });
  
  return {
    id: 'session-123',
    participant1Id: 'user-1',
    participant2Id: 'user-2',
    participant1: user1,
    participant2: user2,
    lastMessage: {
      id: 'message-123',
      content: 'This is the last message',
      senderId: 'user-1',
      createdAt: now
    },
    unreadCount1: 0,
    unreadCount2: 1,
    createdAt: now,
    updatedAt: now,
    metadata: {
      backgroundColor: '#f0f0f0',
      customProperty: 'test-value'
    },
    ...overrides
  };
}

// 生成模拟聊天消息数据
export function createMockChatMessage(overrides: Partial<ChatMessage> = {}): ChatMessage {
  const now = new Date();
  const sender = createMockUser({ id: 'user-1', username: 'sender' });
  const receiver = createMockUser({ id: 'user-2', username: 'receiver' });
  
  return {
    id: 'message-123',
    sessionId: 'session-123',
    sender,
    receiver,
    content: 'This is a test message',
    type: 'text',
    status: 'sent',
    createdAt: now,
    metadata: {
      fileName: 'test-file.txt',
      fileSize: 1024,
      duration: 30,
      thumbnail: 'https://example.com/thumbnail.jpg'
    },
    ...overrides
  };
}

// 生成模拟创建聊天会话请求数据
export function createMockCreateChatSessionRequest(overrides: Partial<CreateChatSessionRequest> = {}): CreateChatSessionRequest {
  return {
    participantId: 'user-456',
    ...overrides
  };
}

// 生成模拟更新聊天会话请求数据
export function createMockUpdateChatSessionRequest(overrides: Partial<UpdateChatSessionRequest> = {}): UpdateChatSessionRequest {
  return {
    sessionId: 'session-123',
    ...overrides
  };
}

// 生成模拟发送消息请求数据
export function createMockSendMessageRequest(overrides: Partial<SendMessageRequest> = {}): SendMessageRequest {
  return {
    sessionId: 'session-123',
    content: 'This is a new test message',
    type: 'text',
    metadata: {
      fileName: 'new-file.txt',
      fileSize: 2048
    },
    ...overrides
  };
}

// 生成模拟获取聊天会话列表请求数据
export function createMockGetChatSessionsRequest(overrides: Partial<GetChatSessionsRequest> = {}): GetChatSessionsRequest {
  return {
    page: 1,
    limit: 10,
    ...overrides
  };
}

// 生成模拟获取聊天会话列表响应数据
export function createMockGetChatSessionsResponse(overrides: Partial<GetChatSessionsResponse> = {}): GetChatSessionsResponse {
  return {
    sessions: [createMockChatSession(), createMockChatSession({ id: 'session-456' })],
    total: 2,
    page: 1,
    limit: 10,
    ...overrides
  };
}

// 生成模拟获取聊天消息请求数据
export function createMockGetChatMessagesRequest(overrides: Partial<GetChatMessagesRequest> = {}): GetChatMessagesRequest {
  return {
    sessionId: 'session-123',
    page: 1,
    limit: 10,
    before: 'message-456',
    after: 'message-123',
    ...overrides
  };
}

// 生成模拟获取聊天消息响应数据
export function createMockGetChatMessagesResponse(overrides: Partial<GetChatMessagesResponse> = {}): GetChatMessagesResponse {
  return {
    messages: [createMockChatMessage(), createMockChatMessage({ id: 'message-456' })],
    total: 2,
    page: 1,
    limit: 10,
    hasMore: false,
    ...overrides
  };
}

// 生成模拟标记消息已读请求数据
export function createMockMarkMessagesAsReadRequest(overrides: Partial<MarkMessagesAsReadRequest> = {}): MarkMessagesAsReadRequest {
  return {
    sessionId: 'session-123',
    messageIds: ['message-123', 'message-456'],
    ...overrides
  };
}

// 生成模拟标记消息已读响应数据
export function createMockMarkMessagesAsReadResponse(overrides: Partial<MarkMessagesAsReadResponse> = {}): MarkMessagesAsReadResponse {
  return {
    success: true,
    markedMessageIds: ['message-123', 'message-456'],
    failedMessageIds: ['message-789'],
    ...overrides
  };
}

// 生成模拟API响应
export function createMockApiResponse<T>(data: T, overrides: Partial<ApiResponse<T>> = {}): ApiResponse<T> {
  return {
    success: true,
    data,
    message: 'Success',
    code: 200,
    ...overrides
  };
}

// 生成模拟API请求配置
export function createMockApiRequestConfig(overrides: Partial<ApiRequestConfig> = {}): ApiRequestConfig {
  return {
    url: '/api/test',
    method: 'GET',
    headers: {
      'Content-Type': 'application/json'
    },
    timeout: 10000,
    ...overrides
  };
}

// 生成模拟错误响应
export function createMockErrorResponse(message: string, code: number = 400) {
  return {
    success: false,
    data: null,
    message,
    code
  };
}