feat: 同步失败台账双向可重试 + 拧紧枪按工位配置 + 虚拟工位体系 + 去Redis与文档口径对齐

- 同步失败台账:MES/WMS 双端新增台账与页面,跨系统通知失败落台账、人工重试或标记已处理,不自动重传;重试前先判对端终态;叫料、配送、出库回写失败提示指向台账;补幂等建表脚本与菜单权限。
- 拧紧枪:新增按工位配置页,展示控制器地址与三把枪通道号(仅供查看,不参与采集校验);「允许手填」由全局开关改为每工位开关,关闭时校验该工位已配控制器;终端启动/登录上报配置并按本工位拉取,扭矩手填框按本工位置灰;补全局值迁移到各工位的脚本。
- 工位体系:终端未配置工位号时登录页可选(含虚拟工位),固定工位模式保留;虚拟/线下位不叫料、不退料、不作转产目标,未采集绑定放行并说明原因;叫料期望接驳台改为选填。
- AGV与出库:补「出库单已送达」回写;空车回充、接驳台传感器失联、配送状态更新失败均落预警或留痕并提示人工核对;人工出库不引入送达状态;出库单支持目标工位/接驳台并扩展导出列。
- 基础设施:看板缓存由Redis改为MES进程内实现,文档与启动脚本同步去Redis;扫码监听支持多地址、端口被占自动降级;PLC对账与工位报警在MES不可达时降级放行并留日志。
- 文档与帮助:案例与部署手册按实测订正(工位绑定、菜单名称、补料由班组长代提、菜单覆盖对照、虚拟工位);迁移脚本改为本地即时执行并登记7个已执行脚本;三端页面帮助改为「业务/操作/影响范围/后果」四要素。
- 测试:新增独立Go模块,按三个业务场景做真实HTTP与真实写库的流水测试,含运行报告。
This commit is contained in:
SunYF
2026-11-09 18:58:47 +08:00
parent 5e2640c13a
commit af554cea75
149 changed files with 35119 additions and 296 deletions
+151
View File
@@ -0,0 +1,151 @@
// Package assert 四层断言 + 每步六字段报告。
package assert
import (
"context"
"fmt"
"strings"
"bj_power_test/internal/client"
"bj_power_test/internal/db"
"bj_power_test/internal/fixture"
)
// Layer 断言分层。
type Layer string
const (
L1 Layer = "L1 接口响应"
L2 Layer = "L2 数据库落库"
L3 Layer = "L3 状态流转"
L4 Layer = "L4 交付物"
)
// Result 每步报告:步骤ID + 案例.md行号 + 期望 + 实际 + 通过/失败 + 失败原因。
type Result struct {
StepID string `json:"stepId"`
CaseLine string `json:"caseLine"`
Layer Layer `json:"layer"`
Expect string `json:"expect"`
Actual string `json:"actual"`
Pass bool `json:"pass"`
FailReason string `json:"failReason"`
Status string `json:"status"` // 通过 / 失败 / 阻断
}
// Ctx 用例执行上下文。
type Ctx struct {
C context.Context
Run *fixture.Run
Client *client.Set
DB *db.DB
Results []Result
Blocked bool
}
func NewCtx(c context.Context, run *fixture.Run, cl *client.Set, d *db.DB) *Ctx {
return &Ctx{C: c, Run: run, Client: cl, DB: d}
}
func (c *Ctx) add(r Result) {
if r.Status == "" {
if r.Pass {
r.Status = "通过"
} else {
r.Status = "失败"
}
}
c.Results = append(c.Results, r)
}
// Block 标记阻断:服务/库不可用时不编造数据,明确写「阻断」。
func (c *Ctx) Block(stepID, caseLine, expect, reason string) {
c.Blocked = true
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L1, Expect: expect,
Actual: "未执行(前置条件不满足)", FailReason: reason, Status: "阻断"})
}
// L1 接口响应:HTTP 状态码、业务码、提示文案(三者都判)。
func (c *Ctx) L1(stepID, caseLine, expect string, resp *client.Response, callErr error, wantHTTP, wantCode int, wantMsg string) {
if callErr != nil {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L1, Expect: expect,
Actual: "调用异常:" + callErr.Error(), FailReason: "HTTP 请求未送达(服务未启动或网络不通)", Status: "阻断"})
c.Blocked = true
return
}
var reasons []string
if resp.HTTPStatus != wantHTTP {
reasons = append(reasons, fmt.Sprintf("HTTP 状态码期望 %d 实际 %d", wantHTTP, resp.HTTPStatus))
}
if resp.Code != wantCode {
reasons = append(reasons, fmt.Sprintf("业务码期望 %d 实际 %d", wantCode, resp.Code))
}
if wantMsg != "" && !strings.Contains(resp.Message+resp.Raw, wantMsg) {
reasons = append(reasons, fmt.Sprintf("提示文案未包含 %q", wantMsg))
}
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L1, Expect: expect,
Actual: resp.Brief(), Pass: len(reasons) == 0, FailReason: strings.Join(reasons, ";")})
}
// L2 数据库落库:直连库执行 SQL,比对期望值。
func (c *Ctx) L2(stepID, caseLine, expect string, target db.Target, query string, args []any, want string) {
if !c.DB.Ready(target) {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L2, Expect: expect,
Actual: "库未连接", FailReason: string(target) + " 库不可用", Status: "阻断"})
return
}
got, err := c.DB.Scalar(c.C, target, query, args...)
actual := fmt.Sprintf("%s = %q", query, got)
if err != nil {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L2, Expect: expect,
Actual: "SQL 执行失败:" + err.Error(), FailReason: err.Error()})
return
}
pass := got == want
reason := ""
if !pass {
reason = fmt.Sprintf("期望 %q,实际 %q", want, got)
}
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L2, Expect: expect, Actual: actual,
Pass: pass, FailReason: reason})
}
// L3 状态流转:查单据当前状态是否与状态机期望一致。
func (c *Ctx) L3(stepID, caseLine, expect string, target db.Target, query string, args []any, allow []string) {
if !c.DB.Ready(target) {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L3, Expect: expect,
Actual: "库未连接", FailReason: string(target) + " 库不可用", Status: "阻断"})
return
}
got, err := c.DB.Scalar(c.C, target, query, args...)
if err != nil {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L3, Expect: expect,
Actual: "SQL 执行失败:" + err.Error(), FailReason: err.Error()})
return
}
pass := false
for _, a := range allow {
if got == a {
pass = true
break
}
}
reason := ""
if !pass {
reason = fmt.Sprintf("状态期望属于 %v,实际 %q", allow, got)
}
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L3, Expect: expect,
Actual: fmt.Sprintf("当前状态 = %q", got), Pass: pass, FailReason: reason})
}
// L4 交付物:接口返回或聚合查询是否产出交付物数据。
func (c *Ctx) L4(stepID, caseLine, expect, actual string, pass bool, reason string) {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L4, Expect: expect,
Actual: actual, Pass: pass, FailReason: reason})
}
// Note 记录一条不带断言的事实(例如前一步真实单号),便于报告串起流水。
func (c *Ctx) Note(stepID, caseLine, fact string) {
c.add(Result{StepID: stepID, CaseLine: caseLine, Layer: L1, Expect: "记录本步真实产出供下一步使用",
Actual: fact, Pass: true, Status: "通过"})
}
+231
View File
@@ -0,0 +1,231 @@
// Package client 四服务统一 HTTP 客户端。
// 统一响应为 {code, message, data},HTTP 业务失败可能 200 也可能 4xx/5xx,两者均由 L1 断言判读。
package client
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"bj_power_test/internal/env"
)
// Response 一次真实调用的完整结果。
type Response struct {
HTTPStatus int `json:"httpStatus"`
Code int `json:"code"`
Message string `json:"message"`
Data json.RawMessage `json:"data"`
Raw string `json:"raw"`
URL string `json:"url"`
}
// DataGet 从 data 里按层级取字符串值,支持数组首元素;用于把上一步产生的真实单号传给下一步。
func (r *Response) DataGet(keys ...string) string {
if r == nil || len(r.Data) == 0 {
return ""
}
var cur any
if err := json.Unmarshal(r.Data, &cur); err != nil {
return ""
}
for _, k := range keys {
switch v := cur.(type) {
case map[string]any:
cur = v[k]
case []any:
if len(v) == 0 {
return ""
}
if m, ok := v[0].(map[string]any); ok {
cur = m[k]
} else {
return ""
}
default:
return ""
}
if cur == nil {
return ""
}
}
switch v := cur.(type) {
case string:
return v
case float64:
return fmt.Sprintf("%.0f", v)
case bool:
return fmt.Sprintf("%v", v)
default:
return fmt.Sprint(v)
}
}
// DataArray 取 data 里的数组字段(如 list/items),返回原始对象切片。
func (r *Response) DataArray(keys ...string) []map[string]any {
if r == nil || len(r.Data) == 0 {
return nil
}
var cur any
if err := json.Unmarshal(r.Data, &cur); err != nil {
return nil
}
for _, k := range keys {
m, ok := cur.(map[string]any)
if !ok {
return nil
}
cur = m[k]
}
arr, ok := cur.([]any)
if !ok {
return nil
}
out := make([]map[string]any, 0, len(arr))
for _, item := range arr {
if m, ok := item.(map[string]any); ok {
out = append(out, m)
}
}
return out
}
// Set 持有四端 baseURL 与登录凭证。
type Set struct {
cfg env.Config
tokens env.Tokens
hc *http.Client
}
func New(cfg env.Config, tk env.Tokens) *Set {
return &Set{cfg: cfg, tokens: tk, hc: &http.Client{Timeout: cfg.HTTPTimeout}}
}
func (s *Set) baseURL(svc env.Service) string {
switch svc {
case env.MES:
return s.cfg.MESURL
case env.WMS:
return s.cfg.WMSURL
case env.WS:
return s.cfg.WSURL
case env.Board:
return s.cfg.BoardURL
}
return ""
}
func (s *Set) token(svc env.Service) string {
switch svc {
case env.MES:
return s.tokens.MES
case env.WMS:
return s.tokens.WMS
case env.WS:
return s.tokens.WS
}
return ""
}
// stationNoFromBody 从请求体取工位号:test 自己持有工位号,不依赖工位终端 yaml 配置。
func stationNoFromBody(body any) int {
m, ok := body.(map[string]any)
if !ok {
return 0
}
switch v := m["stationNo"].(type) {
case int:
return v
case float64:
return int(v)
case string:
n, _ := strconv.Atoi(v)
return n
}
return 0
}
// Do 发起真实 HTTP 调用。
// MES /api/internal/* 同时受 InternalAuth(X-API-TOKEN) 与 StationSessionAuth(Bearer) 保护,
// 二者互补而非二选一;工位号由 X-Station-No 头显式指定(默认取 body.stationNo)。
func (s *Set) Do(ctx context.Context, svc env.Service, method, path string, body any) (*Response, error) {
return s.DoWithStation(ctx, svc, method, path, body, stationNoFromBody(body))
}
// DoWithStation 同 Do,但显式指定工位号(工位 3/6/12 可在同一进程内切换)。
func (s *Set) DoWithStation(ctx context.Context, svc env.Service, method, path string, body any, stationNo int) (*Response, error) {
var reader io.Reader
if body != nil {
b, err := json.Marshal(body)
if err != nil {
return nil, err
}
reader = bytes.NewReader(b)
}
url := s.baseURL(svc) + path
req, err := http.NewRequestWithContext(ctx, method, url, reader)
if err != nil {
return nil, err
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
if strings.HasPrefix(path, "/api/internal/") {
req.Header.Set("X-API-TOKEN", s.cfg.InternalToken)
if svc == env.MES {
if t := s.token(svc); t != "" {
req.Header.Set("Authorization", "Bearer "+t)
}
if stationNo > 0 {
req.Header.Set("X-Station-No", strconv.Itoa(stationNo))
}
}
} else if t := s.token(svc); t != "" {
req.Header.Set("Authorization", "Bearer "+t)
}
started := time.Now()
resp, err := s.hc.Do(req)
if err != nil {
return nil, fmt.Errorf("%s %s:%w(耗时 %s)", method, url, err, time.Since(started).Round(time.Millisecond))
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
r := &Response{HTTPStatus: resp.StatusCode, Raw: string(raw), URL: url}
var parsed struct {
Code int `json:"code"`
Message string `json:"message"`
Data json.RawMessage `json:"data"`
}
if err := json.Unmarshal(raw, &parsed); err == nil {
r.Code, r.Message, r.Data = parsed.Code, parsed.Message, parsed.Data
} else {
r.Code, r.Message = -1, "响应非 JSON"
}
return r, nil
}
func (s *Set) Get(ctx context.Context, svc env.Service, path string) (*Response, error) {
return s.Do(ctx, svc, http.MethodGet, path, nil)
}
func (s *Set) Post(ctx context.Context, svc env.Service, path string, body any) (*Response, error) {
return s.Do(ctx, svc, http.MethodPost, path, body)
}
// Brief 生成人类可读的「实际」摘要,用于报告。
func (r *Response) Brief() string {
if r == nil {
return "无响应"
}
raw := r.Raw
if len(raw) > 400 {
raw = raw[:400] + "…"
}
return fmt.Sprintf("HTTP %d / code=%d / message=%q / body=%s", r.HTTPStatus, r.Code, r.Message, raw)
}
+264
View File
@@ -0,0 +1,264 @@
// Package db 直连三个库做 L2 落库断言:
// MES PostgreSQL(bj_power_mes)、WMS PostgreSQL(bj_power_wms)、工位终端 SQLite(workstation.db)。
// 只读查询,不写库、不删测试数据。
package db
import (
"context"
"database/sql"
"fmt"
"strings"
"github.com/jackc/pgx/v5/pgtype"
"github.com/jackc/pgx/v5/pgxpool"
_ "modernc.org/sqlite"
)
// Target 目标库。
type Target string
const (
MES Target = "MES"
WMS Target = "WMS"
WS Target = "工位终端"
)
// DB 三库连接集合。
type DB struct {
mes *pgxpool.Pool
wms *pgxpool.Pool
ws *sql.DB
}
// Open 建连并 Ping 三库;任一失败返回错误清单,已成功的连接仍保留可用。
func Open(ctx context.Context, mesDSN, wmsDSN, sqlitePath string) (*DB, []error) {
d := &DB{}
var errs []error
if p, err := pgxpool.New(ctx, mesDSN); err != nil {
errs = append(errs, fmt.Errorf("MES 库建连:%w", err))
} else if err := p.Ping(ctx); err != nil {
errs = append(errs, fmt.Errorf("MES 库 Ping:%w", err))
p.Close()
} else {
d.mes = p
}
if p, err := pgxpool.New(ctx, wmsDSN); err != nil {
errs = append(errs, fmt.Errorf("WMS 库建连:%w", err))
} else if err := p.Ping(ctx); err != nil {
errs = append(errs, fmt.Errorf("WMS 库 Ping:%w", err))
p.Close()
} else {
d.wms = p
}
// 工位终端与业务服务共用同一文件,只读方式打开,避免与运行中的终端抢写锁。
if s, err := sql.Open("sqlite", "file:"+sqlitePath+"?mode=ro&_pragma=busy_timeout(5000)"); err != nil {
errs = append(errs, fmt.Errorf("工位终端 SQLite 建连:%w", err))
} else if err := s.PingContext(ctx); err != nil {
errs = append(errs, fmt.Errorf("工位终端 SQLite Ping:%w", err))
_ = s.Close()
} else {
d.ws = s
}
return d, errs
}
func (d *DB) Close() {
if d.mes != nil {
d.mes.Close()
}
if d.wms != nil {
d.wms.Close()
}
if d.ws != nil {
_ = d.ws.Close()
}
}
// Ready 某库是否可用。
func (d *DB) Ready(t Target) bool {
switch t {
case MES:
return d.mes != nil
case WMS:
return d.wms != nil
case WS:
return d.ws != nil
}
return false
}
// normalizeArgs 兼容「调用方把参数打包成 []any 整体传入」的写法:
// Scalar/Rows 是变参,若只收到一个 []any 则展开;单个 nil 视为无参数。
// (2026-11-08 断链核实:此前 scenario1 直接传 []any{code},pgx 收到的是
// 单个切片而非展开后的元素,导致查询失败/空值,进而误判为数据缺失。)
func normalizeArgs(args []any) []any {
if len(args) == 1 {
switch v := args[0].(type) {
case []any:
return v
case nil:
return nil
}
}
return args
}
// scalarString 把数据库标量统一转成可比对的字符串。
// pgx v5 把 NUMERIC 解成 pgtype.Numeric 结构体,直接 fmt.Sprint 会得到
// "{2 0 false finite true}" 这类不可比对文本(RUN20261108-05 的 S1-10/S1-16
// 库存汇总断言即由此误判为失败),故按 Int * 10^Exp 还原成十进制文本。
func scalarString(v any) string {
switch n := v.(type) {
case pgtype.Numeric:
return numericString(n)
case *pgtype.Numeric:
if n == nil {
return "<nil>"
}
return numericString(*n)
}
return fmt.Sprint(v)
}
func numericString(n pgtype.Numeric) string {
if !n.Valid || n.NaN || n.InfinityModifier != pgtype.Finite || n.Int == nil {
return "<nil>"
}
s := n.Int.String()
neg := strings.HasPrefix(s, "-")
if neg {
s = s[1:]
}
switch {
case n.Exp > 0:
s += strings.Repeat("0", int(n.Exp))
case n.Exp < 0:
k := int(-n.Exp)
if len(s) <= k {
s = strings.Repeat("0", k-len(s)+1) + s
}
s = s[:len(s)-k] + "." + s[len(s)-k:]
s = strings.TrimRight(s, "0")
s = strings.TrimSuffix(s, ".")
}
if neg && s != "0" {
s = "-" + s
}
return s
}
// Scalar 返回单值(统一转字符串,便于断言比较)。无行返回 "" 且 err=nil。
func (d *DB) Scalar(ctx context.Context, t Target, query string, args ...any) (string, error) {
args = normalizeArgs(args)
switch t {
case MES, WMS:
p := d.mes
if t == WMS {
p = d.wms
}
if p == nil {
return "", fmt.Errorf("%s 库未连接", t)
}
var v any
err := p.QueryRow(ctx, query, args...).Scan(&v)
if err != nil {
if strings.Contains(err.Error(), "no rows") {
return "", nil
}
return "", err
}
return scalarString(v), nil
case WS:
if d.ws == nil {
return "", fmt.Errorf("%s 库未连接", t)
}
var v any
err := d.ws.QueryRowContext(ctx, query, args...).Scan(&v)
if err != nil {
if err == sql.ErrNoRows {
return "", nil
}
return "", err
}
return scalarString(v), nil
}
return "", fmt.Errorf("未知目标库 %s", t)
}
// Rows 返回多行(列名 → 字符串值),用于逐行核对落库字段。
func (d *DB) Rows(ctx context.Context, t Target, query string, args ...any) ([]map[string]string, error) {
args = normalizeArgs(args)
out := []map[string]string{}
switch t {
case MES, WMS:
p := d.mes
if t == WMS {
p = d.wms
}
if p == nil {
return nil, fmt.Errorf("%s 库未连接", t)
}
rows, err := p.Query(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
fields := rows.FieldDescriptions()
for rows.Next() {
vals, err := rows.Values()
if err != nil {
return nil, err
}
m := make(map[string]string, len(fields))
for i, f := range fields {
m[f.Name] = scalarString(vals[i])
}
out = append(out, m)
}
return out, rows.Err()
case WS:
if d.ws == nil {
return nil, fmt.Errorf("%s 库未连接", t)
}
rows, err := d.ws.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
cols, err := rows.Columns()
if err != nil {
return nil, err
}
for rows.Next() {
buf := make([]any, len(cols))
ptr := make([]any, len(cols))
for i := range buf {
ptr[i] = &buf[i]
}
if err := rows.Scan(ptr...); err != nil {
return nil, err
}
m := make(map[string]string, len(cols))
for i, c := range cols {
m[c] = fmt.Sprint(buf[i])
}
out = append(out, m)
}
return out, rows.Err()
}
return nil, fmt.Errorf("未知目标库 %s", t)
}
// Count 便捷计数。
func (d *DB) Count(ctx context.Context, t Target, query string, args ...any) (int, error) {
s, err := d.Scalar(ctx, t, query, args...)
if err != nil {
return 0, err
}
if s == "" || s == "<nil>" {
return 0, nil
}
var n int
_, err = fmt.Sscan(s, &n)
return n, err
}
+212
View File
@@ -0,0 +1,212 @@
// Package env 负责探活、登录与运行配置。
// 所有地址、账号、DSN 均可由环境变量覆盖,默认值取自四服务 etc/*.yaml 实测配置。
package env
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strings"
"time"
)
// Config 一次运行所需的全部外部配置。
type Config struct {
MESURL string
WMSURL string
WSURL string
BoardURL string
MESDSN string
WMSDSN string
SQLitePath string
User string
Password string
// 工位终端登录需要额外工位号,且使用 MES 独立字段 WorkstationPassword。
StationNo int
InternalToken string
ReportDir string
HTTPTimeout time.Duration
}
func envIntOr(key string, def int) int {
if v := strings.TrimSpace(os.Getenv(key)); v != "" {
var n int
if _, err := fmt.Sscan(v, &n); err == nil && n > 0 {
return n
}
}
return def
}
func envOr(key, def string) string {
if v := strings.TrimSpace(os.Getenv(key)); v != "" {
return v
}
return def
}
// Load 读取运行配置。默认源:
// MES etc/bj_power_mes-api.yaml:1-25 / WMS etc/bj_power_wms-api.yaml:1-24 /
// 工位终端 etc/bj_power_workstation.yaml:1-22,54-55。
func Load() Config {
mesDSN := envOr("TEST_MES_DSN", "postgres://postgres:postgres@127.0.0.1:5432/bj_power_mes?sslmode=disable")
wmsDSN := envOr("TEST_WMS_DSN", "postgres://postgres:postgres@127.0.0.1:5432/bj_power_wms?sslmode=disable")
return Config{
MESURL: envOr("TEST_MES_URL", "http://127.0.0.1:8888"),
WMSURL: envOr("TEST_WMS_URL", "http://127.0.0.1:8890"),
WSURL: envOr("TEST_WS_URL", "http://127.0.0.1:8892"),
BoardURL: envOr("TEST_BOARD_URL", "http://127.0.0.1:5173"),
MESDSN: mesDSN,
WMSDSN: wmsDSN,
SQLitePath: envOr("TEST_SQLITE_PATH", "D:/hardman/bj_power/bj_power_workstation/workstation.db"),
User: envOr("TEST_USER", "admin"),
Password: envOr("TEST_PASSWORD", "123456"),
// T3:工位号由 test 自己持有,不再依赖工位终端 etc/*.yaml 的 Station.StationNo。
// 各步骤请求体显式带 stationNo(S1-05/09/14),此处仅用于工位终端登录凭证。
StationNo: envIntOr("TEST_STATION_NO", 3),
InternalToken: envOr("TEST_INTERNAL_TOKEN", "Hardman_2026"),
ReportDir: envOr("TEST_REPORT_DIR", "D:/hardman/bj_power/test/reports"),
HTTPTimeout: 15 * time.Second,
}
}
// Service 四服务标识。
type Service string
const (
MES Service = "MES"
WMS Service = "WMS"
WS Service = "工位终端"
Board Service = "看板"
)
// ProbeResult 单个服务的探活结果。
type ProbeResult struct {
Name string `json:"name"`
URL string `json:"url"`
OK bool `json:"ok"`
Detail string `json:"detail"`
}
// Probe 探活:能收到任意 HTTP 响应即视为服务在监听(404/405 也算,连接失败才算不可达)。
func (c Config) Probe(ctx context.Context) []ProbeResult {
targets := []struct {
name, base, path string
}{
{string(MES), c.MESURL, "/api/v1/login"},
{string(WMS), c.WMSURL, "/api/health"},
{string(WS), c.WSURL, "/api/health"},
{string(Board), c.BoardURL, "/"},
}
hc := &http.Client{Timeout: 3 * time.Second}
out := make([]ProbeResult, 0, len(targets))
for _, t := range targets {
r := ProbeResult{Name: t.name, URL: t.base}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, t.base+t.path, nil)
if err != nil {
r.Detail = err.Error()
out = append(out, r)
continue
}
resp, err := hc.Do(req)
if err != nil {
r.Detail = "不可达:" + err.Error()
out = append(out, r)
continue
}
_, _ = io.Copy(io.Discard, resp.Body)
_ = resp.Body.Close()
r.OK = true
r.Detail = fmt.Sprintf("HTTP %d", resp.StatusCode)
out = append(out, r)
}
return out
}
// Tokens 登录后持有的凭证。看板免登录,恒为空。
type Tokens struct {
MES string
WMS string
WS string
Board string
}
// LoginError 单端登录失败,不阻断其它端。
type LoginError struct {
Service string
Err error
}
func (e LoginError) Error() string { return e.Service + " 登录失败:" + e.Err.Error() }
type loginReply struct {
Code int `json:"code"`
Message string `json:"message"`
Data json.RawMessage `json:"data"`
}
// Login 依次登录三端,返回凭证与逐端错误清单。
// MES: POST /api/v1/login → data.accessToken(internal/logic/auth.go:26-28)
// WMS: POST /api/auth/login → data.token (internal/handler/auth.go:84-89)
// 终端: POST /api/auth/login → 原样透传 MES,data.accessToken(internal/handler/auth.go:69-93)
func (c Config) Login(ctx context.Context) (Tokens, []LoginError) {
var tk Tokens
var errs []LoginError
hc := &http.Client{Timeout: c.HTTPTimeout}
doLogin := func(name, url, body, dataKey string) string {
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBufferString(body))
if err != nil {
errs = append(errs, LoginError{name, err})
return ""
}
req.Header.Set("Content-Type", "application/json")
resp, err := hc.Do(req)
if err != nil {
errs = append(errs, LoginError{name, err})
return ""
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
var lr loginReply
if err := json.Unmarshal(raw, &lr); err != nil {
errs = append(errs, LoginError{name, fmt.Errorf("响应非 JSON:%s", truncate(string(raw), 160))})
return ""
}
if resp.StatusCode != http.StatusOK || lr.Code != 0 {
errs = append(errs, LoginError{name, fmt.Errorf("HTTP %d code=%d %s", resp.StatusCode, lr.Code, lr.Message)})
return ""
}
var m map[string]any
if err := json.Unmarshal(lr.Data, &m); err != nil {
errs = append(errs, LoginError{name, fmt.Errorf("data 解析失败:%v", err)})
return ""
}
v, _ := m[dataKey].(string)
if v == "" {
errs = append(errs, LoginError{name, fmt.Errorf("data.%s 为空", dataKey)})
}
return v
}
mesBody := fmt.Sprintf(`{"username":%q,"password":%q}`, c.User, c.Password)
wsBody := fmt.Sprintf(`{"username":%q,"password":%q,"stationNo":%d}`, c.User, c.Password, c.StationNo)
tk.MES = doLogin(string(MES), c.MESURL+"/api/v1/login", mesBody, "accessToken")
tk.WMS = doLogin(string(WMS), c.WMSURL+"/api/auth/login", mesBody, "token")
tk.WS = doLogin(string(WS), c.WSURL+"/api/auth/login", wsBody, "accessToken")
return tk, errs
}
func truncate(s string, n int) string {
if len(s) <= n {
return s
}
return s[:n] + "…"
}
+100
View File
@@ -0,0 +1,100 @@
// Package fixture 运行批次前缀、日期相对化与跨步骤真实数据传递。
// 测试数据全部保留在库里不删除,靠批次前缀隔离唯一键。
package fixture
import (
"fmt"
"os"
"time"
)
// Material 案例.md:52-55 的四件套 + 成品 DX-100。
type Material struct {
Code string
Name string
ItemType int // 1=原材料 3=成品(实测 WMS materials.item_type)
ManageMode int // 1=批次 2=序列号 3=成品(实测取值)
SnMode int // 1=按 SN 2=非 SN(实测取值)
InboundQty int
SNManaged bool
}
// Materials 场景一/二/三共用的主数据定义。
var Materials = []Material{
{Code: "DX100-XT-001", Name: "箱体", ItemType: 1, ManageMode: 1, SnMode: 2, InboundQty: 8},
{Code: "DX100-MB-002", Name: "面板", ItemType: 1, ManageMode: 1, SnMode: 2, InboundQty: 8},
{Code: "DX100-MP-005", Name: "铭牌", ItemType: 1, ManageMode: 1, SnMode: 2, InboundQty: 8},
{Code: "DX100-QL-004", Name: "微型断路器", ItemType: 1, ManageMode: 2, SnMode: 1, InboundQty: 20, SNManaged: true},
{Code: "DX-100", Name: "电表箱成品", ItemType: 3, ManageMode: 3, SnMode: 1, InboundQty: 0},
}
// State 每一步产生的真实数据,往下一步传递。禁止填 mock 值。
type State struct {
WorkOrderNo string
ProductCode string
ProcessID string
SN string
InspectionNo string
InboundNos []string
BatchNos map[string]string
SNList []string
PackageNos []string
RequestNos []string
DeliveryNo string
OutboundNos []string
ReturnNos []string
BoardCurrent string
Extra map[string]string
}
func NewState() *State {
return &State{
BatchNos: map[string]string{},
Extra: map[string]string{},
}
}
// Run 一次运行。
type Run struct {
Batch string // RUN20261107-01
Seq int
Today time.Time
Inst string // 同批次多次重跑的实例短后缀,避免唯一键相撞(数据仍全部保留)
State *State
}
// New 生成运行批次。日期全部相对化:T=今天,T+1、T+2 由 Date(1)/Date(2) 得出。
func New(seq int) *Run {
now := time.Now()
batchDate := now.Format("20060102")
if v := os.Getenv("TEST_BATCH_DATE"); v != "" {
batchDate = v // 只覆盖报告/单号的批次日期;业务日期仍取真实当天
}
return &Run{
Batch: fmt.Sprintf("RUN%s-%02d", batchDate, seq),
Seq: seq,
Today: now,
Inst: fmt.Sprintf("%05d", now.UnixNano()/int64(time.Millisecond)%100000),
State: NewState(),
}
}
// Date 相对日期字符串,offset=0 为今天,1/2 为 T+1/T+2。
func (r *Run) Date(offset int) string {
return r.Today.AddDate(0, 0, offset).Format("2006-01-02")
}
// Compact 相对日期的紧凑形式,用于单号。
func (r *Run) Compact(offset int) string {
return r.Today.AddDate(0, 0, offset).Format("20060102")
}
// No 生成带批次前缀+实例后缀的业务单号,保证同批次多次重跑也不撞唯一键。
func (r *Run) No(kind string, n int) string {
return fmt.Sprintf("%s-%s-%03d-%s", r.Batch, kind, n, r.Inst)
}
// Code 生成带批次前缀+实例后缀的物料/工件/SN 编码。
func (r *Run) Code(kind string, n int) string {
return fmt.Sprintf("%s-%s-%04d-%s", r.Batch, kind, n, r.Inst)
}
+133
View File
@@ -0,0 +1,133 @@
// Package report 生成每步六字段报告(Markdown + JSON),落盘到 test/reports/。
package report
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"time"
"bj_power_test/internal/assert"
"bj_power_test/internal/env"
)
// Report 一次运行的全部证据。
type Report struct {
RunBatch string `json:"runBatch"`
Scenario string `json:"scenario"`
StartedAt string `json:"startedAt"`
FinishedAt string `json:"finishedAt"`
Probes []env.ProbeResult `json:"probes"`
LoginErrors []string `json:"loginErrors"`
DBErrors []string `json:"dbErrors"`
Results []assert.Result `json:"results"`
Summary Summary `json:"summary"`
}
// Summary 汇总。
type Summary struct {
Total int `json:"total"`
Pass int `json:"pass"`
Fail int `json:"fail"`
Block int `json:"block"`
PassRate string `json:"passRate"`
}
func New(batch, scenario string) *Report {
return &Report{RunBatch: batch, Scenario: scenario,
StartedAt: time.Now().Format("2006-01-02 15:04:05")}
}
// Finish 计算汇总。
func (r *Report) Finish() {
r.FinishedAt = time.Now().Format("2006-01-02 15:04:05")
s := Summary{Total: len(r.Results)}
for _, x := range r.Results {
switch x.Status {
case "通过":
s.Pass++
case "阻断":
s.Block++
default:
s.Fail++
}
}
if s.Total > 0 {
s.PassRate = fmt.Sprintf("%.1f%%", float64(s.Pass)*100/float64(s.Total))
} else {
s.PassRate = "0.0%"
}
r.Summary = s
}
// Markdown 渲染人类可读报告。
func (r *Report) Markdown() string {
var b strings.Builder
b.WriteString("# 自动化流水测试报告\n\n")
fmt.Fprintf(&b, "- 运行批次:**%s**\n- 场景:%s\n- 开始:%s\n- 结束:%s\n", r.RunBatch, r.Scenario, r.StartedAt, r.FinishedAt)
fmt.Fprintf(&b, "- 汇总:共 %d 项,通过 %d / 失败 %d / 阻断 %d,通过率 %s\n\n",
r.Summary.Total, r.Summary.Pass, r.Summary.Fail, r.Summary.Block, r.Summary.PassRate)
b.WriteString("## 一、服务探活\n\n| 服务 | 地址 | 结果 | 说明 |\n| --- | --- | --- | --- |\n")
for _, p := range r.Probes {
ok := "不可达"
if p.OK {
ok = "在监听"
}
fmt.Fprintf(&b, "| %s | %s | %s | %s |\n", p.Name, p.URL, ok, p.Detail)
}
if len(r.LoginErrors) > 0 {
b.WriteString("\n**登录失败项:**\n")
for _, e := range r.LoginErrors {
fmt.Fprintf(&b, "- %s\n", e)
}
}
if len(r.DBErrors) > 0 {
b.WriteString("\n**数据库建连失败项:**\n")
for _, e := range r.DBErrors {
fmt.Fprintf(&b, "- %s\n", e)
}
}
b.WriteString("\n## 二、逐步结果(步骤ID / 案例行号 / 期望 / 实际 / 结论 / 失败原因)\n\n")
b.WriteString("| 步骤ID | 案例.md 行号 | 层级 | 期望 | 实际 | 结论 | 失败原因 |\n")
b.WriteString("| --- | --- | --- | --- | --- | --- | --- |\n")
for _, x := range r.Results {
fmt.Fprintf(&b, "| %s | %s | %s | %s | %s | %s | %s |\n",
esc(x.StepID), esc(x.CaseLine), esc(string(x.Layer)), esc(x.Expect), esc(x.Actual), x.Status, esc(x.FailReason))
}
b.WriteString("\n> 测试数据全部保留在库里,不删除;批次前缀用于隔离唯一键。\n")
return b.String()
}
func esc(s string) string {
s = strings.ReplaceAll(s, "|", "\\|")
s = strings.ReplaceAll(s, "\n", " ")
if len(s) > 300 {
s = s[:300] + "…"
}
return s
}
// Write 落盘 Markdown + JSON,返回两个路径。
func (r *Report) Write(dir string) (string, string, error) {
if err := os.MkdirAll(dir, 0o755); err != nil {
return "", "", err
}
base := filepath.Join(dir, r.RunBatch+"-"+strings.ReplaceAll(r.Scenario, " ", ""))
mdPath := base + ".md"
jsonPath := base + ".json"
if err := os.WriteFile(mdPath, []byte(r.Markdown()), 0o644); err != nil {
return "", "", err
}
data, err := json.MarshalIndent(r, "", " ")
if err != nil {
return mdPath, "", err
}
if err := os.WriteFile(jsonPath, data, 0o644); err != nil {
return mdPath, "", err
}
return mdPath, jsonPath, nil
}