427 lines
17 KiB
Go
427 lines
17 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"net/http"
|
||
"os"
|
||
"strings"
|
||
"testing"
|
||
|
||
// 测试进程不会执行 main.go 的驱动注册，这里显式引入 MySQL 驱动
|
||
_ "github.com/gogf/gf/contrib/drivers/mysql/v2"
|
||
"github.com/gogf/gf/v2/database/gdb"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/net/ghttp"
|
||
"github.com/gogf/gf/v2/os/gtime"
|
||
|
||
v1 "tool-api/api/admin/v1"
|
||
"tool-api/internal/consts"
|
||
)
|
||
|
||
// ============================================================================
|
||
// 软删除真实库集成测试（默认跳过；需真实 MySQL）
|
||
//
|
||
// 运行：$env:IT_DB=1; go test ./internal/logic/ -run TestSoftDelete -count=1 -v
|
||
//
|
||
// 说明：
|
||
// - 连的是 dev 库（默认 mysql:root:root@tcp(127.0.0.1:3306)/nl_toolbox，可用 IT_DB_LINK 覆盖）。
|
||
// 测试进程 cwd 是包目录，GoFrame 未必能找到 manifest/config，故这里显式 SetConfig。
|
||
// - 仅使用带 __probe 前缀 / 极大假 enterprise_id 的临时数据，结束即清理。
|
||
// - 若 users 缺 deleted_at/deleted_from 列或 employees 表不存在，测试会按 migrate 的定义补建，
|
||
// 与线上启动迁移一致（幂等）。
|
||
// ============================================================================
|
||
|
||
func requireIT(t *testing.T) {
|
||
t.Helper()
|
||
if os.Getenv("IT_DB") == "" {
|
||
t.Skip("set IT_DB=1 以运行真实库集成测试")
|
||
}
|
||
link := os.Getenv("IT_DB_LINK")
|
||
if link == "" {
|
||
link = "mysql:root:root@tcp(127.0.0.1:3306)/nl_toolbox"
|
||
}
|
||
gdb.SetConfig(gdb.Config{
|
||
"default": gdb.ConfigGroup{
|
||
gdb.ConfigNode{Link: link},
|
||
},
|
||
})
|
||
}
|
||
|
||
// ensureUserSoftDeleteCols 确保 users 具备 deleted_at / deleted_from 列（与 migrateColumns 一致）。
|
||
func ensureUserSoftDeleteCols(ctx context.Context, t *testing.T) {
|
||
t.Helper()
|
||
cols := []struct{ name, ddl string }{
|
||
{"deleted_at", "ALTER TABLE `users` ADD COLUMN `deleted_at` datetime DEFAULT NULL COMMENT '软删除时间，NULL=未删除'"},
|
||
{"deleted_from", "ALTER TABLE `users` ADD COLUMN `deleted_from` text COMMENT '软删前唯一键原值(JSON)，便于恢复'"},
|
||
}
|
||
for _, c := range cols {
|
||
exists, err := columnExists(ctx, "users", c.name)
|
||
if err != nil {
|
||
t.Fatalf("columnExists users.%s: %v", c.name, err)
|
||
}
|
||
if !exists {
|
||
if _, err = g.DB().Exec(ctx, c.ddl); err != nil {
|
||
t.Fatalf("add users.%s: %v", c.name, err)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ensureEmployeesTable 确保 employees 表存在（与 migrateTables 的 DDL 一致）。
|
||
func ensureEmployeesTable(ctx context.Context, t *testing.T) {
|
||
t.Helper()
|
||
ddl := "CREATE TABLE IF NOT EXISTS `employees` (" +
|
||
"`id` bigint unsigned NOT NULL AUTO_INCREMENT," +
|
||
"`enterprise_id` bigint NOT NULL," +
|
||
"`name` varchar(64) NOT NULL," +
|
||
"`phone` varchar(20) NOT NULL," +
|
||
"`dept` varchar(64) NOT NULL DEFAULT ''," +
|
||
"`remark` varchar(255) NOT NULL DEFAULT ''," +
|
||
"`status` tinyint NOT NULL DEFAULT 1," +
|
||
"`deleted_at` datetime DEFAULT NULL COMMENT '软删除时间，NULL=未删除'," +
|
||
"`deleted_from` text COMMENT '软删前 phone 原值(JSON)，便于恢复'," +
|
||
"`created_at` datetime DEFAULT NULL,`updated_at` datetime DEFAULT NULL," +
|
||
"PRIMARY KEY (`id`)," +
|
||
"UNIQUE KEY `uk_ent_phone` (`enterprise_id`,`phone`)," +
|
||
"KEY `idx_ent_name` (`enterprise_id`,`name`)" +
|
||
") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='企业员工库（跨活动复用）'"
|
||
if _, err := g.DB().Exec(ctx, ddl); err != nil {
|
||
t.Fatalf("ensure employees: %v", err)
|
||
}
|
||
}
|
||
|
||
// ensureToolsSoftDeleteCol 确保 tools 具备 deleted_at 列（与 migrateColumns 一致；dev 库未必跑过迁移）。
|
||
func ensureToolsSoftDeleteCol(ctx context.Context, t *testing.T) {
|
||
t.Helper()
|
||
exists, err := columnExists(ctx, "tools", "deleted_at")
|
||
if err != nil {
|
||
t.Fatalf("columnExists tools.deleted_at: %v", err)
|
||
}
|
||
if !exists {
|
||
if _, err = g.DB().Exec(ctx,
|
||
"ALTER TABLE `tools` ADD COLUMN `deleted_at` datetime DEFAULT NULL COMMENT '软删除时间，NULL=未删除'"); err != nil {
|
||
t.Fatalf("add tools.deleted_at: %v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestSoftDeleteUsers_ReRegisterSucceeds 软删用户后：未删列表看不到 + 原 openid/用户名释放 +
|
||
// 同 openid/用户名可重新注册 + 重复软删幂等。
|
||
func TestSoftDeleteUsers_ReRegisterSucceeds(t *testing.T) {
|
||
requireIT(t)
|
||
ctx := context.Background()
|
||
ensureUserSoftDeleteCols(ctx, t)
|
||
|
||
const openid = "__probe_openid_softdel__"
|
||
const username = "__probe_user_softdel__"
|
||
var probeId int64
|
||
cleanup := func() {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE openid=? OR username=?", openid, username)
|
||
if probeId != 0 {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE id=?", probeId)
|
||
}
|
||
}
|
||
cleanup()
|
||
defer cleanup()
|
||
|
||
id, err := g.Model(consts.TableUsers).Data(g.Map{
|
||
"openid": openid, "username": username, "nickname": "probe",
|
||
"level_key": consts.DefaultLevelKey, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("insert probe user: %v", err)
|
||
}
|
||
probeId = id
|
||
|
||
if err = softDeleteUsers(ctx, []int64{id}); err != nil {
|
||
t.Fatalf("softDeleteUsers: %v", err)
|
||
}
|
||
// 1) 过滤：未删列表（deleted_at IS NULL）查不到
|
||
if n, _ := g.Model(consts.TableUsers).Where("openid", openid).WhereNull("deleted_at").Count(); n != 0 {
|
||
t.Fatalf("软删用户仍出现在未删列表: n=%d", n)
|
||
}
|
||
// 2) 墓碑化：原 openid / username 已释放（不过滤也查不到该原值）
|
||
if n, _ := g.Model(consts.TableUsers).Where("openid", openid).Count(); n != 0 {
|
||
t.Fatalf("原 openid 仍被占用: n=%d", n)
|
||
}
|
||
if n, _ := g.Model(consts.TableUsers).Where("username", username).Count(); n != 0 {
|
||
t.Fatalf("原 username 仍被占用: n=%d", n)
|
||
}
|
||
// 3) 重新注册同 openid + username 必须成功
|
||
if _, err = g.Model(consts.TableUsers).Data(g.Map{
|
||
"openid": openid, "username": username, "nickname": "probe2",
|
||
"level_key": consts.DefaultLevelKey, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).Insert(); err != nil {
|
||
t.Fatalf("同 openid/username 重新注册失败: %v", err)
|
||
}
|
||
// 4) 幂等：再次软删同一已删 id 不报错
|
||
if err = softDeleteUsers(ctx, []int64{id}); err != nil {
|
||
t.Fatalf("重复软删不幂等: %v", err)
|
||
}
|
||
}
|
||
|
||
// TestSoftDeleteEmployees_ReAddSucceeds 软删员工后：同企业同手机号可重新录入（uk_ent_phone 复合唯一）+ 幂等。
|
||
func TestSoftDeleteEmployees_ReAddSucceeds(t *testing.T) {
|
||
requireIT(t)
|
||
ctx := context.Background()
|
||
ensureEmployeesTable(ctx, t)
|
||
|
||
const entId int64 = 9223372036854775 // 极大假企业 id，避开真实数据
|
||
const phone = "__probe_phone__"
|
||
cleanup := func() {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM employees WHERE enterprise_id=?", entId)
|
||
}
|
||
cleanup()
|
||
defer cleanup()
|
||
|
||
id, err := g.Model(consts.TableEmployees).Data(g.Map{
|
||
"enterprise_id": entId, "name": "probe", "phone": phone, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("insert probe employee: %v", err)
|
||
}
|
||
if err = softDeleteEmployees(ctx, []int64{id}); err != nil {
|
||
t.Fatalf("softDeleteEmployees: %v", err)
|
||
}
|
||
// 过滤
|
||
if n, _ := g.Model(consts.TableEmployees).Where("enterprise_id", entId).Where("phone", phone).WhereNull("deleted_at").Count(); n != 0 {
|
||
t.Fatalf("软删员工仍在未删列表: n=%d", n)
|
||
}
|
||
// 同企业同手机号重新录入必须成功
|
||
if _, err = g.Model(consts.TableEmployees).Data(g.Map{
|
||
"enterprise_id": entId, "name": "probe2", "phone": phone, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).Insert(); err != nil {
|
||
t.Fatalf("同企业同手机号重新录入失败: %v", err)
|
||
}
|
||
// 幂等
|
||
if err = softDeleteEmployees(ctx, []int64{id}); err != nil {
|
||
t.Fatalf("重复软删不幂等: %v", err)
|
||
}
|
||
}
|
||
|
||
// TestSoftDeleteUsers_UsernameSquattingBlocked 抢注通道关闭的真实库验证（回归修复前的漏洞）：
|
||
//
|
||
// 修复前：软删 victim 会把 username 改成短墓碑 "#del<victimId>"，其长度 5-20，
|
||
// 落在 username 的合法区间（required|length:3,32）内，**可被攻击者提前抢注**。
|
||
// 抢注成功后，软删 victim 就会撞 uk_username → AdminUserBatch 整体报错 → 整个批量删除失败。
|
||
//
|
||
// 本测试：先让攻击者注册 username="#del<victimId>"（修复前这能插进去，正说明漏洞真实存在），
|
||
// 再软删 victim；断言软删仍成功（长墓碑 >32，攻击者抢不到），
|
||
// 且 victim.username 等于长墓碑、deleted_from 保存了原值。
|
||
func TestSoftDeleteUsers_UsernameSquattingBlocked(t *testing.T) {
|
||
requireIT(t)
|
||
ctx := context.Background()
|
||
ensureUserSoftDeleteCols(ctx, t)
|
||
|
||
const victimOpenid = "__probe_victim_openid_squat__"
|
||
const victimName = "__probe_victim_name_squat__"
|
||
const attackerOpenid = "__probe_attacker_openid_squat__"
|
||
var victimId, attackerId int64
|
||
cleanup := func() {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE openid IN (?,?)", victimOpenid, attackerOpenid)
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE username=?", victimName)
|
||
// victim 被软删后 openid/username 已墓碑化，按主键删；同时按 deleted_from 扫历史残留探测行
|
||
if victimId != 0 {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE id=?", victimId)
|
||
}
|
||
if attackerId != 0 {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE id=?", attackerId)
|
||
}
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE deleted_from LIKE ?", "%"+victimOpenid+"%")
|
||
}
|
||
cleanup()
|
||
defer cleanup()
|
||
|
||
// 1) 先插 victim，拿到 victimId（短墓碑名依赖它）
|
||
id, err := g.Model(consts.TableUsers).Data(g.Map{
|
||
"openid": victimOpenid, "username": victimName, "nickname": "victim",
|
||
"level_key": consts.DefaultLevelKey, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("insert victim: %v", err)
|
||
}
|
||
victimId = id
|
||
|
||
// 2) 攻击者抢注「修复前会生成的短墓碑」——修复前它是合法且能插入的
|
||
squatName := tombstoneShort(victimId)
|
||
if len(squatName) < 3 || len(squatName) > 32 {
|
||
t.Fatalf("抢注名 %q 长度 %d 不在合法区间，测试前提不成立", squatName, len(squatName))
|
||
}
|
||
attackerId, err = g.Model(consts.TableUsers).Data(g.Map{
|
||
"openid": attackerOpenid, "username": squatName, "nickname": "attacker",
|
||
"level_key": consts.DefaultLevelKey, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("攻击者抢注短墓碑名 %q 失败（测试前提不成立）: %v", squatName, err)
|
||
}
|
||
|
||
// 3) 软删 victim：修复后必须成功（长墓碑不与攻击者占用的短墓碑相撞）
|
||
if err = softDeleteUsers(ctx, []int64{victimId}); err != nil {
|
||
t.Fatalf("软删 victim 失败（抢注通道未关闭？）: %v", err)
|
||
}
|
||
|
||
// 4) 直接查库（raw SQL，绕过 ORM 软删过滤）：victim.username 必须是长墓碑
|
||
rows, err := g.DB().GetAll(ctx, "SELECT username, deleted_from, deleted_at FROM users WHERE id=?", victimId)
|
||
if err != nil {
|
||
t.Fatalf("query victim: %v", err)
|
||
}
|
||
if len(rows) != 1 {
|
||
t.Fatalf("victim 行数=%d 期望 1", len(rows))
|
||
}
|
||
if got := rows[0]["username"].String(); got != tombstoneLong(victimId) {
|
||
t.Fatalf("victim.username=%q 期望长墓碑 %q", got, tombstoneLong(victimId))
|
||
}
|
||
// 5) deleted_from 保存原值，便于恢复
|
||
if df := rows[0]["deleted_from"].String(); !strings.Contains(df, victimName) {
|
||
t.Fatalf("deleted_from=%q 未保存原 username %q", df, victimName)
|
||
}
|
||
// 6) ORM 软删过滤：Model 查询看不到已软删 victim（GoFrame v2.10 soft-time 自动过滤）
|
||
if n, _ := g.Model(consts.TableUsers).Where("id", victimId).Count(); n != 0 {
|
||
t.Fatalf("Model 仍能看到已软删 victim: n=%d", n)
|
||
}
|
||
// 7) 原 username 已释放：未删用户里查不到该原值
|
||
if n, _ := g.Model(consts.TableUsers).Where("username", victimName).Count(); n != 0 {
|
||
t.Fatalf("原 username 仍被占用: n=%d", n)
|
||
}
|
||
}
|
||
|
||
// TestSoftDeleteBatchDelete_Idempotent 幂等契约（回归 existingIdSet 被框架软删过滤的真 bug）：
|
||
// 对同一批 id **连续 delete 两次**，第二次仍须 success=N / failed=0。
|
||
//
|
||
// 修复前：existingIdSet 用 Model 查询，被框架自动追加 `deleted_at IS NULL` → 已软删 id 查不出
|
||
//
|
||
// → 落进 missing → 返回 failed，违反「重复删除已删 id 计成功」的冻结契约。
|
||
//
|
||
// 修复后：existingIdSet 加 `.Unscoped()`，软删行照常可见 → 计入 ok。
|
||
func TestSoftDeleteBatchDelete_Idempotent(t *testing.T) {
|
||
requireIT(t)
|
||
// AdminUserBatch 内部会 WriteAudit → CtxAdminId → g.RequestFromCtx(ctx)，需要对非 nil 的
|
||
// *ghttp.Request（否则 GetCtxVar 在 nil 上解引用 panic）。这里构造一个最小请求上下文，
|
||
// 使该链路可跑（审计是旁路，写失败也仅告警）。
|
||
req := &ghttp.Request{Request: &http.Request{}}
|
||
ctx := req.Context()
|
||
ensureUserSoftDeleteCols(ctx, t)
|
||
ensureEmployeesTable(ctx, t)
|
||
ensureToolsSoftDeleteCol(ctx, t)
|
||
|
||
// 审计是旁路（WriteAudit 失败仅告警），但若该表存在会留下记录；清理本次产生、admin_id=0 的批量删除审计
|
||
defer func() {
|
||
_, _ = g.DB().Exec(ctx,
|
||
"DELETE FROM `"+consts.TableAdminAuditLog+"` WHERE admin_id=0 AND action IN ('user.batch_delete','tool.batch_delete','employee.batch_delete')")
|
||
}()
|
||
|
||
// ---------- users（existingIdSet + softDeleteUsers 路径）----------
|
||
const uOpenid = "__probe_idem_openid__"
|
||
const uName = "__probe_idem_name__"
|
||
var uid int64
|
||
uCleanup := func() {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE openid=? OR username=?", uOpenid, uName)
|
||
if uid != 0 {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE id=?", uid)
|
||
}
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM users WHERE deleted_from LIKE ?", "%"+uOpenid+"%")
|
||
}
|
||
uCleanup()
|
||
defer uCleanup()
|
||
|
||
uid, err := g.Model(consts.TableUsers).Data(g.Map{
|
||
"openid": uOpenid, "username": uName, "nickname": "idem",
|
||
"level_key": consts.DefaultLevelKey, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("insert probe user: %v", err)
|
||
}
|
||
|
||
ur1, err := AdminUserBatch(ctx, &v1.UserBatchReq{Ids: []int64{uid}, Action: "delete"})
|
||
if err != nil {
|
||
t.Fatalf("user 第1次 delete: %v", err)
|
||
}
|
||
if ur1.Success != 1 || ur1.Failed != 0 {
|
||
t.Fatalf("user 第1次 delete 期望 success=1/failed=0，实得 %d/%d failures=%+v", ur1.Success, ur1.Failed, ur1.Failures)
|
||
}
|
||
ur2, err := AdminUserBatch(ctx, &v1.UserBatchReq{Ids: []int64{uid}, Action: "delete"})
|
||
if err != nil {
|
||
t.Fatalf("user 第2次 delete: %v", err)
|
||
}
|
||
if ur2.Success != 1 || ur2.Failed != 0 {
|
||
t.Fatalf("user 重复 delete 必须幂等 success=1/failed=0，实得 %d/%d failures=%+v（existingIdSet 漏了 Unscoped？）",
|
||
ur2.Success, ur2.Failed, ur2.Failures)
|
||
}
|
||
|
||
// ---------- tools（existingIdSet + softDeleteSimple 路径）----------
|
||
const toolKey = "__probe_idem_tool__"
|
||
var tid int64
|
||
tCleanup := func() {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM tools WHERE tool_key=?", toolKey)
|
||
if tid != 0 {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM tools WHERE id=?", tid)
|
||
}
|
||
}
|
||
tCleanup()
|
||
defer tCleanup()
|
||
|
||
tid, err = g.Model(consts.TableTools).Data(g.Map{
|
||
"tool_key": toolKey, "module_key": "image", "name": "idem-probe",
|
||
"icon": "picture", "description": "probe", "sort": 999, "is_hot": 0,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("insert probe tool: %v", err)
|
||
}
|
||
|
||
tr1, err := AdminToolsBatch(ctx, &v1.ToolsBatchReq{Ids: []int64{tid}, Action: "delete"})
|
||
if err != nil {
|
||
t.Fatalf("tool 第1次 delete: %v", err)
|
||
}
|
||
if tr1.Success != 1 || tr1.Failed != 0 {
|
||
t.Fatalf("tool 第1次 delete 期望 success=1/failed=0，实得 %d/%d", tr1.Success, tr1.Failed)
|
||
}
|
||
tr2, err := AdminToolsBatch(ctx, &v1.ToolsBatchReq{Ids: []int64{tid}, Action: "delete"})
|
||
if err != nil {
|
||
t.Fatalf("tool 第2次 delete: %v", err)
|
||
}
|
||
if tr2.Success != 1 || tr2.Failed != 0 {
|
||
t.Fatalf("tool 重复 delete 必须幂等 success=1/failed=0，实得 %d/%d failures=%+v", tr2.Success, tr2.Failed, tr2.Failures)
|
||
}
|
||
|
||
// ---------- employees（existingIdSet + softDeleteEmployees 路径）----------
|
||
const entId int64 = 9223372036854774 // 极大假企业 id，避开真实数据
|
||
const ePhone = "__probe_idem_phone__"
|
||
var eid int64
|
||
eCleanup := func() {
|
||
_, _ = g.DB().Exec(ctx, "DELETE FROM employees WHERE enterprise_id=?", entId)
|
||
}
|
||
eCleanup()
|
||
defer eCleanup()
|
||
|
||
eid, err = g.Model(consts.TableEmployees).Data(g.Map{
|
||
"enterprise_id": entId, "name": "idem-probe", "phone": ePhone, "status": 1,
|
||
"created_at": gtime.Now(), "updated_at": gtime.Now(),
|
||
}).InsertAndGetId()
|
||
if err != nil {
|
||
t.Fatalf("insert probe employee: %v", err)
|
||
}
|
||
|
||
er1, err := AdminEmployeeBatch(ctx, &v1.EmployeeBatchReq{Ids: []int64{eid}, Action: "delete"})
|
||
if err != nil {
|
||
t.Fatalf("employee 第1次 delete: %v", err)
|
||
}
|
||
if er1.Success != 1 || er1.Failed != 0 {
|
||
t.Fatalf("employee 第1次 delete 期望 success=1/failed=0，实得 %d/%d", er1.Success, er1.Failed)
|
||
}
|
||
er2, err := AdminEmployeeBatch(ctx, &v1.EmployeeBatchReq{Ids: []int64{eid}, Action: "delete"})
|
||
if err != nil {
|
||
t.Fatalf("employee 第2次 delete: %v", err)
|
||
}
|
||
if er2.Success != 1 || er2.Failed != 0 {
|
||
t.Fatalf("employee 重复 delete 必须幂等 success=1/failed=0，实得 %d/%d failures=%+v", er2.Success, er2.Failed, er2.Failures)
|
||
}
|
||
}
|