mini-starter/packages/delivery-address-module/tests/integration/admin-routes.integration.test.ts

import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
import { testClient } from 'hono/testing';
import { IntegrationTestDatabase, setupIntegrationDatabaseHooksWithEntities } from '@d8d/shared-test-util';
import { JWTUtil } from '@d8d/shared-utils';
import { UserEntity, Role } from '@d8d/user-module';
import { AreaEntity, AreaLevel } from '@d8d/geo-areas';
import { adminDeliveryAddressRoutes } from '../../src/routes';
import { DeliveryAddress } from '../../src/entities';

// 设置集成测试钩子
setupIntegrationDatabaseHooksWithEntities([UserEntity, Role, AreaEntity, DeliveryAddress])

describe('管理员配送地址管理API集成测试', () => {
  let client: ReturnType<typeof testClient<typeof adminDeliveryAddressRoutes>>;
  let adminToken: string;
  let testUser: UserEntity;
  let testAdmin: UserEntity;
  let testProvince: AreaEntity;
  let testCity: AreaEntity;
  let testDistrict: AreaEntity;

  beforeEach(async () => {
    // 创建测试客户端
    client = testClient(adminDeliveryAddressRoutes);

    // 获取数据源
    const dataSource = await IntegrationTestDatabase.getDataSource();

    // 创建测试用户
    const userRepository = dataSource.getRepository(UserEntity);
    testUser = userRepository.create({
      username: `test_user_${Date.now()}`,
      password: 'test_password',
      nickname: '测试用户',
      registrationSource: 'web'
    });
    await userRepository.save(testUser);

    // 创建测试管理员用户
    testAdmin = userRepository.create({
      username: `test_admin_${Date.now()}`,
      password: 'admin_password',
      nickname: '测试管理员',
      registrationSource: 'web'
    });
    await userRepository.save(testAdmin);

    // 创建测试地区数据 - 省
    const areaRepository = dataSource.getRepository(AreaEntity);
    testProvince = areaRepository.create({
      name: '北京市',
      code: '110000',
      level: AreaLevel.PROVINCE,
      parentId: null
    });
    await areaRepository.save(testProvince);

    // 创建测试地区数据 - 市
    testCity = areaRepository.create({
      name: '北京市',
      code: '110100',
      level: AreaLevel.CITY,
      parentId: testProvince.id
    });
    await areaRepository.save(testCity);

    // 创建测试地区数据 - 区
    testDistrict = areaRepository.create({
      name: '朝阳区',
      code: '110105',
      level: AreaLevel.DISTRICT,
      parentId: testCity.id
    });
    await areaRepository.save(testDistrict);

    // 生成测试管理员的token
    adminToken = JWTUtil.generateToken({
      id: testAdmin.id,
      username: testAdmin.username,
      roles: [{name:'admin'}]
    });
  });

  describe('GET /delivery-address', () => {
    it('应该返回配送地址列表', async () => {
      const response = await client.index.$get({
        query: {}
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('配送地址列表响应状态:', response.status);
      expect(response.status).toBe(200);

      if (response.status === 200) {
        const data = await response.json();
        expect(data).toHaveProperty('data');
        expect(Array.isArray(data.data)).toBe(true);
      }
    });

    it('应该拒绝未认证用户的访问', async () => {
      const response = await client.index.$get({
        query: {}
      });
      expect(response.status).toBe(401);
    });
  });

  describe('POST /delivery-address', () => {
    it('应该成功创建配送地址', async () => {
      const createData = {
        userId: testUser.id,
        name: '张三',
        phone: '13800138000',
        address: '朝阳区建国路88号',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 1
      };

      const response = await client.index.$post({
        json: createData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('创建配送地址响应状态:', response.status);
      expect(response.status).toBe(201);

      if (response.status === 201) {
        const data = await response.json();
        expect(data).toHaveProperty('id');
        expect(data.name).toBe(createData.name);
        expect(data.phone).toBe(createData.phone);
        expect(data.address).toBe(createData.address);
        expect(data.receiverProvince).toBe(createData.receiverProvince);
        expect(data.receiverCity).toBe(createData.receiverCity);
        expect(data.receiverDistrict).toBe(createData.receiverDistrict);
        expect(data.isDefault).toBe(createData.isDefault);
      }
    });

    it('应该验证创建配送地址的必填字段', async () => {
      const invalidData = {
        // 缺少必填字段
        userId: testUser.id,
        name: '',
        phone: '',
        address: '',
        receiverProvince: 0,
        receiverCity: 0,
        receiverDistrict: 0
      };

      const response = await client.index.$post({
        json: invalidData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      expect(response.status).toBe(400);
    });

    it('应该验证地区层级关系', async () => {
      // 使用不存在的地区ID
      const invalidAreaData = {
        userId: testUser.id,
        name: '李四',
        phone: '13900139000',
        address: '测试地址',
        receiverProvince: 999999, // 不存在的省份
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0
      };

      const response = await client.index.$post({
        json: invalidAreaData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('地区验证响应状态:', response.status);
      expect(response.status).toBe(400);
    });
  });

  describe('GET /delivery-address/:id', () => {
    it('应该返回指定配送地址的详情', async () => {
      // 先创建一个配送地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);
      const testDeliveryAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '王五',
        phone: '13600136000',
        address: '海淀区中关村大街1号',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(testDeliveryAddress);

      const response = await client[':id'].$get({
        param: { id: testDeliveryAddress.id }
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('配送地址详情响应状态:', response.status);
      expect(response.status).toBe(200);

      if (response.status === 200) {
        const data = await response.json();
        expect(data.id).toBe(testDeliveryAddress.id);
        expect(data.name).toBe(testDeliveryAddress.name);
        expect(data.phone).toBe(testDeliveryAddress.phone);
        expect(data.address).toBe(testDeliveryAddress.address);

        // 验证地区数据关联
        if (data.province) {
          expect(data.province.id).toBe(testProvince.id);
        }
        if (data.city) {
          expect(data.city.id).toBe(testCity.id);
        }
        if (data.district) {
          expect(data.district.id).toBe(testDistrict.id);
        }
      }
    });

    it('应该处理不存在的配送地址', async () => {
      const response = await client[':id'].$get({
        param: { id: 999999 }
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      expect(response.status).toBe(404);
    });
  });

  describe('PUT /delivery-address/:id', () => {
    it('应该成功更新配送地址', async () => {
      // 先创建一个配送地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);
      const testDeliveryAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '原始姓名',
        phone: '13500135000',
        address: '原始地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(testDeliveryAddress);

      const updateData = {
        name: '更新后的姓名',
        phone: '13700137000',
        address: '更新后的地址',
        isDefault: 1
      };

      const response = await client[':id'].$put({
        param: { id: testDeliveryAddress.id },
        json: updateData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('更新配送地址响应状态:', response.status);
      expect(response.status).toBe(200);

      if (response.status === 200) {
        const data = await response.json();
        expect(data.name).toBe(updateData.name);
        expect(data.phone).toBe(updateData.phone);
        expect(data.address).toBe(updateData.address);
        expect(data.isDefault).toBe(updateData.isDefault);
      }
    });
  });

  describe('DELETE /delivery-address/:id', () => {
    it('应该成功删除配送地址', async () => {
      // 先创建一个配送地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);
      const testDeliveryAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '待删除地址',
        phone: '13400134000',
        address: '待删除地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(testDeliveryAddress);

      const response = await client[':id'].$delete({
        param: { id: testDeliveryAddress.id }
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('删除配送地址响应状态:', response.status);
      expect(response.status).toBe(204);

      // 验证配送地址确实被删除
      const deletedDeliveryAddress = await deliveryAddressRepository.findOne({
        where: { id: testDeliveryAddress.id }
      });
      expect(deletedDeliveryAddress).toBeNull();
    });
  });

  describe('省市区关联测试', () => {
    it('应该正确关联省市区数据', async () => {
      // 创建配送地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);
      const testDeliveryAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '关联测试',
        phone: '13300133000',
        address: '关联测试地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(testDeliveryAddress);

      // 查询配送地址详情，验证地区关联
      const response = await client[':id'].$get({
        param: { id: testDeliveryAddress.id }
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      expect(response.status).toBe(200);
      const data = await response.json();

      // 验证省市区关联数据
      if ('province' in data && data.province) {
        expect(data.province.name).toBe('北京市');
        expect(data.province.level).toBe(AreaLevel.PROVINCE);
      }

      if ('city' in data && data.city) {
        expect(data.city.name).toBe('北京市');
        expect(data.city.level).toBe(AreaLevel.CITY);
      }

      if ('district' in data && data.district) {
        expect(data.district.name).toBe('朝阳区');
        expect(data.district.level).toBe(AreaLevel.DISTRICT);
      }
    });

    it('应该验证地区层级关系', async () => {
      // 创建另一个区级地区，但父级不是市级
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const areaRepository = dataSource.getRepository(AreaEntity);

      const invalidDistrict = areaRepository.create({
        name: '无效区',
        code: '999999',
        level: AreaLevel.DISTRICT,
        parentId: testProvince.id // 父级是省，不是市
      });
      await areaRepository.save(invalidDistrict);

      // 尝试使用无效的地区层级关系创建地址
      const createData = {
        userId: testUser.id,
        name: '层级测试',
        phone: '13200132000',
        address: '层级测试地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: invalidDistrict.id, // 这个区的父级不是testCity
        receiverTown: 0,
        state: 1,
        isDefault: 0
      };

      const response = await client.index.$post({
        json: createData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('地区层级验证响应状态:', response.status);
      // 这里期望返回400，因为地区层级关系不匹配
      expect(response.status).toBe(400);
    });
  });

  describe('管理员权限测试', () => {
    it('管理员应该可以为其他用户创建地址', async () => {
      const createData = {
        userId: testUser.id, // 为其他用户创建地址
        name: '其他用户地址',
        phone: '13800138001',
        address: '其他用户地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0
      };

      const response = await client.index.$post({
        json: createData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('管理员为其他用户创建地址响应状态:', response.status);
      expect(response.status).toBe(201);

      if (response.status === 201) {
        const data = await response.json();
        expect(data.userId).toBe(testUser.id); // 验证地址确实属于其他用户
        expect(data.name).toBe(createData.name);
      }
    });

    it('管理员应该可以访问所有用户的地址', async () => {
      // 为测试用户创建一些地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);

      const userAddress1 = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '用户地址1',
        phone: '13800138002',
        address: '用户地址1',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(userAddress1);

      const userAddress2 = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '用户地址2',
        phone: '13800138003',
        address: '用户地址2',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(userAddress2);

      // 管理员应该能看到所有地址
      const response = await client.index.$get({
        query: {}
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      expect(response.status).toBe(200);
      const data = await response.json();
      if (data && 'data' in data) {
        expect(Array.isArray(data.data)).toBe(true);
        expect(data.data.length).toBeGreaterThanOrEqual(2); // 至少包含我们创建的两个地址
      }
    });

    it('管理员应该可以更新其他用户的地址', async () => {
      // 先为测试用户创建一个地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);
      const testDeliveryAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '原始地址',
        phone: '13800138004',
        address: '原始地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(testDeliveryAddress);

      const updateData = {
        name: '管理员更新的地址',
        phone: '13900139000',
        address: '管理员更新的地址'
      };

      const response = await client[':id'].$put({
        param: { id: testDeliveryAddress.id },
        json: updateData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('管理员更新其他用户地址响应状态:', response.status);
      expect(response.status).toBe(200);

      if (response.status === 200) {
        const data = await response.json();
        expect(data.name).toBe(updateData.name);
        expect(data.phone).toBe(updateData.phone);
        expect(data.address).toBe(updateData.address);
      }
    });

    it('管理员应该可以删除其他用户的地址', async () => {
      // 先为测试用户创建一个地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);
      const testDeliveryAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '待删除地址',
        phone: '13800138005',
        address: '待删除地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(testDeliveryAddress);

      const response = await client[':id'].$delete({
        param: { id: testDeliveryAddress.id }
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      console.debug('管理员删除其他用户地址响应状态:', response.status);
      expect(response.status).toBe(204);

      // 验证地址确实被删除
      const deletedDeliveryAddress = await deliveryAddressRepository.findOne({
        where: { id: testDeliveryAddress.id }
      });
      expect(deletedDeliveryAddress).toBeNull();
    });

    it('管理员应该可以查询指定用户的地址', async () => {
      // 为测试用户创建一些地址
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const deliveryAddressRepository = dataSource.getRepository(DeliveryAddress);

      const userAddress = deliveryAddressRepository.create({
        userId: testUser.id,
        name: '指定用户地址',
        phone: '13800138006',
        address: '指定用户地址',
        receiverProvince: testProvince.id,
        receiverCity: testCity.id,
        receiverDistrict: testDistrict.id,
        receiverTown: 0,
        state: 1,
        isDefault: 0,
        createdBy: testUser.id
      });
      await deliveryAddressRepository.save(userAddress);

      // 管理员可以查询指定用户的地址
      const response = await client.index.$get({
        query: { filters: JSON.stringify({ userId: testUser.id }) }
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      expect(response.status).toBe(200);
      const data = await response.json();
      if (data && 'data' in data) {
        expect(Array.isArray(data.data)).toBe(true);

        // 验证返回的地址都属于指定用户
        if (data.data.length > 0) {
          data.data.forEach((address: any) => {
            expect(address.userId).toBe(testUser.id);
          });
        }
      }
    });
  });
});