csxj2026/junhong_cmp_fiber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

test(integration): 添加 Gateway 接口集成测试

Browse Source 
- 添加 6 个卡 Gateway 接口测试（查询状态、流量、实名、获取链接、停机、复机）
- 添加 7 个设备 Gateway 接口测试（查询信息、卡槽、限速、WiFi、切卡、重启、恢复出厂）
- 每个接口测试包含成功场景和权限校验场景
- 更新测试环境初始化，添加 Gateway 客户端 mock 支持
- 所有 13 个接口测试通过
This commit is contained in:
huang
2026-02-02 17:44:24 +08:00
parent 543c454f16
commit 2ae585225b
3 changed files with 840 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

447
tests/integration/device_gateway_test.go Normal file
View File

@@ -0,0 +1,447 @@
package integration
import (
"encoding/json"
"fmt"
"testing"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/response"
"github.com/break/junhong_cmp_fiber/tests/testutils/integ"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestGatewayDevice_GetInfo 测试查询设备信息接口
func TestGatewayDevice_GetInfo(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000001",
DeviceName: "测试设备1",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功查询设备信息", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/devices/by-imei/%s/gateway-info", device.DeviceNo), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺8",
ShopCode: "SHOP_008",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000002",
DeviceName: "测试设备2",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_1",
Phone: "13800000201",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("GET", fmt.Sprintf("/api/admin/devices/by-imei/%s/gateway-info", device.DeviceNo), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayDevice_GetSlots 测试查询卡槽信息接口
func TestGatewayDevice_GetSlots(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000003",
DeviceName: "测试设备3",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功查询卡槽信息", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/devices/by-imei/%s/gateway-slots", device.DeviceNo), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺9",
ShopCode: "SHOP_009",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000004",
DeviceName: "测试设备4",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_2",
Phone: "13800000202",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("GET", fmt.Sprintf("/api/admin/devices/by-imei/%s/gateway-slots", device.DeviceNo), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayDevice_SetSpeedLimit 测试设置限速接口
func TestGatewayDevice_SetSpeedLimit(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000005",
DeviceName: "测试设备5",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功设置限速", func(t *testing.T) {
body := []byte(`{"uploadSpeed": 1024, "downloadSpeed": 2048}`)
resp, err := env.AsSuperAdmin().Request("PUT", fmt.Sprintf("/api/admin/devices/by-imei/%s/speed-limit", device.DeviceNo), body)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺10",
ShopCode: "SHOP_010",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000006",
DeviceName: "测试设备6",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_3",
Phone: "13800000203",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
body := []byte(`{"uploadSpeed": 1024, "downloadSpeed": 2048}`)
resp, err := env.AsUser(agentAccount).Request("PUT", fmt.Sprintf("/api/admin/devices/by-imei/%s/speed-limit", device.DeviceNo), body)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayDevice_SetWiFi 测试设置WiFi接口
func TestGatewayDevice_SetWiFi(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000007",
DeviceName: "测试设备7",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功设置WiFi", func(t *testing.T) {
body := []byte(`{"ssid": "TestWiFi", "password": "password123", "enabled": 1}`)
resp, err := env.AsSuperAdmin().Request("PUT", fmt.Sprintf("/api/admin/devices/by-imei/%s/wifi", device.DeviceNo), body)
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("无权限设置其他店铺设备的WiFi", func(t *testing.T) {
shop2 := &model.Shop{
ShopName: "测试店铺11",
ShopCode: "SHOP_011",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000008",
DeviceName: "测试设备8",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_4",
Phone: "13800000204",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
body := []byte(`{"ssid": "TestWiFi", "password": "password123", "enabled": 1}`)
resp, err := env.AsUser(agentAccount).Request("PUT", fmt.Sprintf("/api/admin/devices/by-imei/%s/wifi", device.DeviceNo), body)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayDevice_SwitchCard 测试切卡接口
func TestGatewayDevice_SwitchCard(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000009",
DeviceName: "测试设备9",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功切卡", func(t *testing.T) {
body := []byte(`{"targetIccid": "89860001234567890013"}`)
resp, err := env.AsSuperAdmin().Request("POST", fmt.Sprintf("/api/admin/devices/by-imei/%s/switch-card", device.DeviceNo), body)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺12",
ShopCode: "SHOP_012",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000010",
DeviceName: "测试设备10",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_5",
Phone: "13800000205",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
body := []byte(`{"targetIccid": "89860001234567890013"}`)
resp, err := env.AsUser(agentAccount).Request("POST", fmt.Sprintf("/api/admin/devices/by-imei/%s/switch-card", device.DeviceNo), body)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayDevice_RebootDevice 测试重启设备接口
func TestGatewayDevice_RebootDevice(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000011",
DeviceName: "测试设备11",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功重启设备", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("POST", fmt.Sprintf("/api/admin/devices/by-imei/%s/reboot", device.DeviceNo), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺13",
ShopCode: "SHOP_013",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000012",
DeviceName: "测试设备12",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_6",
Phone: "13800000206",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("POST", fmt.Sprintf("/api/admin/devices/by-imei/%s/reboot", device.DeviceNo), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayDevice_ResetDevice 测试恢复出厂接口
func TestGatewayDevice_ResetDevice(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
device := &model.Device{
DeviceNo: "86000000000000000013",
DeviceName: "测试设备13",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
}
require.NoError(t, env.TX.Create(device).Error)
t.Run("成功恢复出厂", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("POST", fmt.Sprintf("/api/admin/devices/by-imei/%s/reset", device.DeviceNo), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺14",
ShopCode: "SHOP_014",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
device2 := &model.Device{
DeviceNo: "86000000000000000014",
DeviceName: "测试设备14",
DeviceType: "router",
MaxSimSlots: 4,
Status: constants.DeviceStatusInStock,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(device2).Error)
agentAccount := &model.Account{
Username: "agent_test_device_gateway_7",
Phone: "13800000207",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("POST", fmt.Sprintf("/api/admin/devices/by-imei/%s/reset", device.DeviceNo), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}

368
tests/integration/iot_card_gateway_test.go Normal file
View File

@@ -0,0 +1,368 @@
package integration
import (
"encoding/json"
"fmt"
"testing"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/response"
"github.com/break/junhong_cmp_fiber/tests/testutils/integ"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestGatewayCard_GetStatus 测试查询卡状态接口
func TestGatewayCard_GetStatus(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
card := &model.IotCard{
ICCID: "89860001234567890001",
CardType: "data_card",
CarrierID: 1,
Status: 1,
}
require.NoError(t, env.TX.Create(card).Error)
t.Run("成功查询卡状态", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/gateway-status", card.ICCID), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺2",
ShopCode: "SHOP_002",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
card2 := &model.IotCard{
ICCID: "89860001234567890002",
CardType: "data_card",
CarrierID: 1,
Status: 1,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(card2).Error)
agentAccount := &model.Account{
Username: "agent_test_gateway_1",
Phone: "13800000101",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/gateway-status", card.ICCID), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayCard_GetFlow 测试查询流量接口
func TestGatewayCard_GetFlow(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
card := &model.IotCard{
ICCID: "89860001234567890003",
CardType: "data_card",
CarrierID: 1,
Status: 1,
}
require.NoError(t, env.TX.Create(card).Error)
t.Run("成功查询流量使用", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/gateway-flow", card.ICCID), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺3",
ShopCode: "SHOP_003",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
card2 := &model.IotCard{
ICCID: "89860001234567890004",
CardType: "data_card",
CarrierID: 1,
Status: 1,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(card2).Error)
agentAccount := &model.Account{
Username: "agent_test_gateway_2",
Phone: "13800000102",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/gateway-flow", card.ICCID), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayCard_GetRealname 测试查询实名状态接口
func TestGatewayCard_GetRealname(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
card := &model.IotCard{
ICCID: "89860001234567890005",
CardType: "data_card",
CarrierID: 1,
Status: 1,
}
require.NoError(t, env.TX.Create(card).Error)
t.Run("成功查询实名状态", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/gateway-realname", card.ICCID), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺4",
ShopCode: "SHOP_004",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
card2 := &model.IotCard{
ICCID: "89860001234567890006",
CardType: "data_card",
CarrierID: 1,
Status: 1,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(card2).Error)
agentAccount := &model.Account{
Username: "agent_test_gateway_3",
Phone: "13800000103",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/gateway-realname", card.ICCID), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayCard_GetRealnameLink 测试获取实名链接接口
func TestGatewayCard_GetRealnameLink(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
card := &model.IotCard{
ICCID: "89860001234567890007",
CardType: "data_card",
CarrierID: 1,
Status: 1,
}
require.NoError(t, env.TX.Create(card).Error)
t.Run("成功获取实名链接", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/realname-link", card.ICCID), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺5",
ShopCode: "SHOP_005",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
card2 := &model.IotCard{
ICCID: "89860001234567890008",
CardType: "data_card",
CarrierID: 1,
Status: 1,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(card2).Error)
agentAccount := &model.Account{
Username: "agent_test_gateway_4",
Phone: "13800000104",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("GET", fmt.Sprintf("/api/admin/iot-cards/%s/realname-link", card.ICCID), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayCard_StopCard 测试停机接口
func TestGatewayCard_StopCard(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
card := &model.IotCard{
ICCID: "89860001234567890009",
CardType: "data_card",
CarrierID: 1,
Status: 1,
}
require.NoError(t, env.TX.Create(card).Error)
t.Run("成功停机", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("POST", fmt.Sprintf("/api/admin/iot-cards/%s/stop", card.ICCID), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺6",
ShopCode: "SHOP_006",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
card2 := &model.IotCard{
ICCID: "89860001234567890010",
CardType: "data_card",
CarrierID: 1,
Status: 1,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(card2).Error)
agentAccount := &model.Account{
Username: "agent_test_gateway_5",
Phone: "13800000105",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("POST", fmt.Sprintf("/api/admin/iot-cards/%s/stop", card.ICCID), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}
// TestGatewayCard_StartCard 测试复机接口
func TestGatewayCard_StartCard(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
card := &model.IotCard{
ICCID: "89860001234567890011",
CardType: "data_card",
CarrierID: 1,
Status: 1,
}
require.NoError(t, env.TX.Create(card).Error)
t.Run("成功复机", func(t *testing.T) {
resp, err := env.AsSuperAdmin().Request("POST", fmt.Sprintf("/api/admin/iot-cards/%s/start", card.ICCID), nil)
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) {
shop2 := &model.Shop{
ShopName: "测试店铺7",
ShopCode: "SHOP_007",
Level: 1,
}
require.NoError(t, env.TX.Create(shop2).Error)
card2 := &model.IotCard{
ICCID: "89860001234567890012",
CardType: "data_card",
CarrierID: 1,
Status: 1,
ShopID: &shop2.ID,
}
require.NoError(t, env.TX.Create(card2).Error)
agentAccount := &model.Account{
Username: "agent_test_gateway_6",
Phone: "13800000106",
UserType: constants.UserTypeAgent,
ShopID: &shop2.ID,
Status: 1,
}
require.NoError(t, env.TX.Create(agentAccount).Error)
resp, err := env.AsUser(agentAccount).Request("POST", fmt.Sprintf("/api/admin/iot-cards/%s/start", card.ICCID), nil)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, 404, resp.StatusCode)
})
}

29
tests/testutils/integ/integration.go
View File

@@ -3,6 +3,7 @@ package integ
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
@@ -12,6 +13,7 @@ import (
"time"
"github.com/break/junhong_cmp_fiber/internal/bootstrap"
"github.com/break/junhong_cmp_fiber/internal/gateway"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/routes"
"github.com/break/junhong_cmp_fiber/pkg/auth"
@@ -76,11 +78,14 @@ func NewIntegrationTestEnv(t *testing.T) *IntegrationTestEnv {
logger, _ := zap.NewDevelopment()
tokenManager := auth.NewTokenManager(rdb, 24*time.Hour, 7*24*time.Hour)
gatewayClient := createMockGatewayClient()
deps := &bootstrap.Dependencies{
DB: tx,
Redis: rdb,
Logger: logger,
TokenManager: tokenManager,
DB: tx,
Redis: rdb,
Logger: logger,
TokenManager: tokenManager,
GatewayClient: gatewayClient,
}
result, err := bootstrap.Bootstrap(deps)
@@ -106,6 +111,22 @@ func NewIntegrationTestEnv(t *testing.T) *IntegrationTestEnv {
return env
}
func createMockGatewayClient() *gateway.Client {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
resp := gateway.GatewayResponse{
Code: 200,
Msg: "success",
TraceID: "test-trace-id",
Data: json.RawMessage(`{}`),
}
json.NewEncoder(w).Encode(resp)
}))
client := gateway.NewClient(server.URL, "test-app-id", "test-app-secret")
return client
}
// AsSuperAdmin 设置当前请求使用超级管理员身份
// 返回 IntegrationTestEnv 以支持链式调用
//