huang
477a9fc98d
Some checks failed
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Has been cancelled
- 新增 GET /api/admin/devices/by-imei/:imei 接口，支持通过设备号查询设备详情 - 新增 GET /api/admin/iot-cards/by-iccid/:iccid 接口，支持通过ICCID查询单卡详情 - 添加对应的 Service 层方法和 Handler - 更新 OpenAPI 文档 - 添加集成测试并修复测试环境配置（使用环境变量） - 归档已完成的 OpenSpec 变更记录 Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
409 lines
12 KiB
Go
409 lines
12 KiB
Go
package integration
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/break/junhong_cmp_fiber/internal/bootstrap"
|
|
internalMiddleware "github.com/break/junhong_cmp_fiber/internal/middleware"
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/internal/routes"
|
|
"github.com/break/junhong_cmp_fiber/pkg/auth"
|
|
"github.com/break/junhong_cmp_fiber/pkg/config"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/queue"
|
|
"github.com/break/junhong_cmp_fiber/pkg/response"
|
|
"github.com/break/junhong_cmp_fiber/tests/testutil"
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/redis/go-redis/v9"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/zap"
|
|
"gorm.io/driver/postgres"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/logger"
|
|
)
|
|
|
|
type deviceTestEnv struct {
|
|
db *gorm.DB
|
|
rdb *redis.Client
|
|
tokenManager *auth.TokenManager
|
|
app *fiber.App
|
|
adminToken string
|
|
t *testing.T
|
|
}
|
|
|
|
func setupDeviceTestEnv(t *testing.T) *deviceTestEnv {
|
|
t.Helper()
|
|
|
|
// 设置测试环境变量
|
|
t.Setenv("JUNHONG_DATABASE_HOST", "cxd.whcxd.cn")
|
|
t.Setenv("JUNHONG_DATABASE_PORT", "16159")
|
|
t.Setenv("JUNHONG_DATABASE_USER", "erp_pgsql")
|
|
t.Setenv("JUNHONG_DATABASE_PASSWORD", "erp_2025")
|
|
t.Setenv("JUNHONG_DATABASE_DBNAME", "junhong_cmp_test")
|
|
t.Setenv("JUNHONG_REDIS_ADDRESS", "cxd.whcxd.cn")
|
|
t.Setenv("JUNHONG_REDIS_PORT", "16299")
|
|
t.Setenv("JUNHONG_REDIS_PASSWORD", "cpNbWtAaqgo1YJmbMp3h")
|
|
t.Setenv("JUNHONG_JWT_SECRET_KEY", "test_secret_key_for_integration_tests")
|
|
|
|
cfg, err := config.Load()
|
|
require.NoError(t, err)
|
|
err = config.Set(cfg)
|
|
require.NoError(t, err)
|
|
|
|
zapLogger, _ := zap.NewDevelopment()
|
|
|
|
dsn := "host=cxd.whcxd.cn port=16159 user=erp_pgsql password=erp_2025 dbname=junhong_cmp_test sslmode=disable TimeZone=Asia/Shanghai"
|
|
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
|
|
Logger: logger.Default.LogMode(logger.Silent),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
rdb := redis.NewClient(&redis.Options{
|
|
Addr: "cxd.whcxd.cn:16299",
|
|
Password: "cpNbWtAaqgo1YJmbMp3h",
|
|
DB: 15,
|
|
})
|
|
|
|
ctx := context.Background()
|
|
err = rdb.Ping(ctx).Err()
|
|
require.NoError(t, err)
|
|
|
|
testPrefix := fmt.Sprintf("test:%s:", t.Name())
|
|
keys, _ := rdb.Keys(ctx, testPrefix+"*").Result()
|
|
if len(keys) > 0 {
|
|
rdb.Del(ctx, keys...)
|
|
}
|
|
|
|
tokenManager := auth.NewTokenManager(rdb, 24*time.Hour, 7*24*time.Hour)
|
|
superAdmin := testutil.CreateSuperAdmin(t, db)
|
|
adminToken, _ := testutil.GenerateTestToken(t, rdb, superAdmin, "web")
|
|
|
|
queueClient := queue.NewClient(rdb, zapLogger)
|
|
|
|
deps := &bootstrap.Dependencies{
|
|
DB: db,
|
|
Redis: rdb,
|
|
Logger: zapLogger,
|
|
TokenManager: tokenManager,
|
|
QueueClient: queueClient,
|
|
}
|
|
|
|
result, err := bootstrap.Bootstrap(deps)
|
|
require.NoError(t, err)
|
|
|
|
app := fiber.New(fiber.Config{
|
|
ErrorHandler: internalMiddleware.ErrorHandler(zapLogger),
|
|
})
|
|
|
|
routes.RegisterRoutes(app, result.Handlers, result.Middlewares)
|
|
|
|
return &deviceTestEnv{
|
|
db: db,
|
|
rdb: rdb,
|
|
tokenManager: tokenManager,
|
|
app: app,
|
|
adminToken: adminToken,
|
|
t: t,
|
|
}
|
|
}
|
|
|
|
func (e *deviceTestEnv) teardown() {
|
|
// 清理测试数据
|
|
e.db.Exec("DELETE FROM tb_device WHERE device_no LIKE 'TEST%'")
|
|
e.db.Exec("DELETE FROM tb_device_sim_binding WHERE device_id IN (SELECT id FROM tb_device WHERE device_no LIKE 'TEST%')")
|
|
e.db.Exec("DELETE FROM tb_device_import_task WHERE task_no LIKE 'TEST%'")
|
|
|
|
ctx := context.Background()
|
|
testPrefix := fmt.Sprintf("test:%s:", e.t.Name())
|
|
keys, _ := e.rdb.Keys(ctx, testPrefix+"*").Result()
|
|
if len(keys) > 0 {
|
|
e.rdb.Del(ctx, keys...)
|
|
}
|
|
|
|
e.rdb.Close()
|
|
}
|
|
|
|
func TestDevice_List(t *testing.T) {
|
|
env := setupDeviceTestEnv(t)
|
|
defer env.teardown()
|
|
|
|
// 创建测试设备
|
|
devices := []*model.Device{
|
|
{DeviceNo: "TEST_DEVICE_001", DeviceName: "测试设备1", DeviceType: "router", MaxSimSlots: 4, Status: constants.DeviceStatusInStock},
|
|
{DeviceNo: "TEST_DEVICE_002", DeviceName: "测试设备2", DeviceType: "router", MaxSimSlots: 2, Status: constants.DeviceStatusInStock},
|
|
{DeviceNo: "TEST_DEVICE_003", DeviceName: "测试设备3", DeviceType: "mifi", MaxSimSlots: 1, Status: constants.DeviceStatusDistributed},
|
|
}
|
|
for _, device := range devices {
|
|
require.NoError(t, env.db.Create(device).Error)
|
|
}
|
|
|
|
t.Run("获取设备列表-无过滤", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", "/api/admin/devices?page=1&page_size=20", nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
})
|
|
|
|
t.Run("获取设备列表-按设备类型过滤", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", "/api/admin/devices?device_type=router", nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
})
|
|
|
|
t.Run("获取设备列表-按状态过滤", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", fmt.Sprintf("/api/admin/devices?status=%d", constants.DeviceStatusInStock), nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
})
|
|
|
|
t.Run("未认证请求应返回错误", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", "/api/admin/devices", nil)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.NotEqual(t, 0, result.Code, "未认证请求应返回错误码")
|
|
})
|
|
}
|
|
|
|
func TestDevice_GetByID(t *testing.T) {
|
|
env := setupDeviceTestEnv(t)
|
|
defer env.teardown()
|
|
|
|
// 创建测试设备
|
|
device := &model.Device{
|
|
DeviceNo: "TEST_DEVICE_GET_001",
|
|
DeviceName: "测试设备详情",
|
|
DeviceType: "router",
|
|
MaxSimSlots: 4,
|
|
Status: constants.DeviceStatusInStock,
|
|
}
|
|
require.NoError(t, env.db.Create(device).Error)
|
|
|
|
t.Run("获取设备详情-成功", func(t *testing.T) {
|
|
url := fmt.Sprintf("/api/admin/devices/%d", device.ID)
|
|
req := httptest.NewRequest("GET", url, nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
|
|
// 验证返回数据
|
|
dataMap, ok := result.Data.(map[string]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, "TEST_DEVICE_GET_001", dataMap["device_no"])
|
|
})
|
|
|
|
t.Run("获取不存在的设备-应返回错误", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", "/api/admin/devices/999999", nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.NotEqual(t, 0, result.Code, "不存在的设备应返回错误码")
|
|
})
|
|
}
|
|
|
|
func TestDevice_Delete(t *testing.T) {
|
|
env := setupDeviceTestEnv(t)
|
|
defer env.teardown()
|
|
|
|
// 创建测试设备
|
|
device := &model.Device{
|
|
DeviceNo: "TEST_DEVICE_DEL_001",
|
|
DeviceName: "测试删除设备",
|
|
DeviceType: "router",
|
|
MaxSimSlots: 4,
|
|
Status: constants.DeviceStatusInStock,
|
|
}
|
|
require.NoError(t, env.db.Create(device).Error)
|
|
|
|
t.Run("删除设备-成功", func(t *testing.T) {
|
|
url := fmt.Sprintf("/api/admin/devices/%d", device.ID)
|
|
req := httptest.NewRequest("DELETE", url, nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
|
|
// 验证设备已被软删除
|
|
var deletedDevice model.Device
|
|
err = env.db.Unscoped().First(&deletedDevice, device.ID).Error
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, deletedDevice.DeletedAt)
|
|
})
|
|
}
|
|
|
|
func TestDeviceImport_TaskList(t *testing.T) {
|
|
env := setupDeviceTestEnv(t)
|
|
defer env.teardown()
|
|
|
|
// 创建测试导入任务
|
|
task := &model.DeviceImportTask{
|
|
TaskNo: "TEST_DEVICE_IMPORT_001",
|
|
Status: model.ImportTaskStatusCompleted,
|
|
BatchNo: "TEST_BATCH_001",
|
|
TotalCount: 100,
|
|
}
|
|
require.NoError(t, env.db.Create(task).Error)
|
|
|
|
t.Run("获取导入任务列表", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", "/api/admin/devices/import-tasks?page=1&page_size=20", nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
})
|
|
|
|
t.Run("获取导入任务详情", func(t *testing.T) {
|
|
url := fmt.Sprintf("/api/admin/devices/import-tasks/%d", task.ID)
|
|
req := httptest.NewRequest("GET", url, nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
})
|
|
}
|
|
|
|
func TestDevice_GetByIMEI(t *testing.T) {
|
|
env := setupDeviceTestEnv(t)
|
|
defer env.teardown()
|
|
|
|
// 创建测试设备
|
|
device := &model.Device{
|
|
DeviceNo: "TEST_IMEI_001",
|
|
DeviceName: "测试IMEI查询设备",
|
|
DeviceType: "router",
|
|
MaxSimSlots: 4,
|
|
Status: constants.DeviceStatusInStock,
|
|
}
|
|
require.NoError(t, env.db.Create(device).Error)
|
|
|
|
t.Run("通过IMEI查询设备详情-成功", func(t *testing.T) {
|
|
url := fmt.Sprintf("/api/admin/devices/by-imei/%s", device.DeviceNo)
|
|
req := httptest.NewRequest("GET", url, nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, 200, resp.StatusCode)
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, result.Code)
|
|
|
|
// 验证返回数据
|
|
dataMap, ok := result.Data.(map[string]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, "TEST_IMEI_001", dataMap["device_no"])
|
|
assert.Equal(t, "测试IMEI查询设备", dataMap["device_name"])
|
|
})
|
|
|
|
t.Run("通过不存在的IMEI查询-应返回错误", func(t *testing.T) {
|
|
req := httptest.NewRequest("GET", "/api/admin/devices/by-imei/NONEXISTENT_IMEI", nil)
|
|
req.Header.Set("Authorization", "Bearer "+env.adminToken)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.NotEqual(t, 0, result.Code, "不存在的IMEI应返回错误码")
|
|
})
|
|
|
|
t.Run("未认证请求-应返回错误", func(t *testing.T) {
|
|
url := fmt.Sprintf("/api/admin/devices/by-imei/%s", device.DeviceNo)
|
|
req := httptest.NewRequest("GET", url, nil)
|
|
|
|
resp, err := env.app.Test(req, -1)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
var result response.Response
|
|
err = json.NewDecoder(resp.Body).Decode(&result)
|
|
require.NoError(t, err)
|
|
assert.NotEqual(t, 0, result.Code, "未认证请求应返回错误码")
|
|
})
|
|
}
|