639 lines
22 KiB
Go
639 lines
22 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"encoding/json"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"strings"
|
||
"testing"
|
||
"time"
|
||
|
||
"cmautobuy/admin/config"
|
||
"cmautobuy/admin/model"
|
||
"cmautobuy/admin/repository"
|
||
"cmautobuy/admin/syb"
|
||
)
|
||
|
||
// ── 增量边界：本工单最容易写错的地方 ─────────────────────
|
||
|
||
func TestSyncDateRange_首次同步用配置的SyncFrom(t *testing.T) {
|
||
now := time.Date(2026, 8, 9, 15, 0, 0, 0, time.UTC)
|
||
from, to, err := syncDateRange("", "2026-07-01", now)
|
||
if err != nil {
|
||
t.Fatalf("计算日期范围失败: %v", err)
|
||
}
|
||
if from != "2026-07-01" {
|
||
t.Errorf("首次同步应该用 sync_from，实际 from=%q", from)
|
||
}
|
||
if to != "2026-08-09" {
|
||
t.Errorf("结束日期应该是今天，实际 to=%q", to)
|
||
}
|
||
}
|
||
|
||
func TestSyncDateRange_首次同步且未配置SyncFrom时报错(t *testing.T) {
|
||
_, _, err := syncDateRange("", "", time.Now())
|
||
if err == nil {
|
||
t.Fatal("从未同步过又没配置 sync_from 时应该报错，而不是拿一个空日期硬拉")
|
||
}
|
||
}
|
||
|
||
func TestSyncDateRange_增量从上次同步日期当天重拉不是第二天(t *testing.T) {
|
||
// `[必须]` 这是工单 #46 明确点名"最容易写错的地方"：
|
||
// 上次同步 2026-08-09 14:30，下次必须还从 2026-08-09 开始拉，
|
||
// 不能从 2026-08-10 开始——否则会漏掉 8-09 14:30 之后创建的单，
|
||
// 而且不会报错，没人会发现。
|
||
lastSyncedAt := "2026-08-09T14:30:00Z"
|
||
now := time.Date(2026, 8, 10, 9, 0, 0, 0, time.UTC)
|
||
|
||
from, to, err := syncDateRange(lastSyncedAt, "2026-07-01", now)
|
||
if err != nil {
|
||
t.Fatalf("计算日期范围失败: %v", err)
|
||
}
|
||
if from != "2026-08-09" {
|
||
t.Fatalf("增量同步应该从上次同步的当天（2026-08-09）重新拉，实际 from=%q"+
|
||
"——如果这里算成了 2026-08-10，就是漏单且不报错的那个坑", from)
|
||
}
|
||
if to != "2026-08-10" {
|
||
t.Errorf("结束日期应该是 now 对应的日期，实际 to=%q", to)
|
||
}
|
||
}
|
||
|
||
func TestSyncDateRange_上次同步时间格式错误时报错(t *testing.T) {
|
||
_, _, err := syncDateRange("不是一个合法的时间", "2026-07-01", time.Now())
|
||
if err == nil {
|
||
t.Fatal("last_synced_at 解析失败时应该报错，不能悄悄退化成一个随便的日期")
|
||
}
|
||
}
|
||
|
||
func TestSyncDateRange_结束日期按顺运宝服务端时区UTC加8算不是UTC(t *testing.T) {
|
||
// `[必须]` 顺运宝 created 是 UTC+8（08 §5.2 有 HAR 实测证据）。
|
||
// now = 2026-08-09T23:00:00Z，也就是本地（UTC+8）2026-08-10 07:00——
|
||
// 如果日期运算错误地用了 UTC，会把"今天"算成 2026-08-09，
|
||
// 当天早晨（UTC+8）创建的单这一轮就拉不到，操作员会以为同步坏了。
|
||
now := time.Date(2026, 8, 9, 23, 0, 0, 0, time.UTC)
|
||
|
||
_, to, err := syncDateRange("", "2026-07-01", now)
|
||
if err != nil {
|
||
t.Fatalf("计算日期范围失败: %v", err)
|
||
}
|
||
if to != "2026-08-10" {
|
||
t.Fatalf("结束日期应该按顺运宝服务端时区（UTC+8）算成 2026-08-10，实际 to=%q"+
|
||
"——如果这里算成了 2026-08-09，就是用错了 UTC 而不是 UTC+8", to)
|
||
}
|
||
}
|
||
|
||
func TestNewSybSyncOptions_指定日期校验(t *testing.T) {
|
||
now := time.Date(2026, 8, 9, 23, 0, 0, 0, time.UTC) // UTC+8 已是 8 月 10 日
|
||
cases := []struct {
|
||
name, from, to string
|
||
wantErr string
|
||
}{
|
||
{name: "两端都空是自动增量"},
|
||
{name: "合法闭区间", from: "2026-08-01", to: "2026-08-10"},
|
||
{name: "只填开始", from: "2026-08-01", wantErr: "同时填写"},
|
||
{name: "开始格式错误", from: "2026/08/01", to: "2026-08-02", wantErr: "开始日期格式"},
|
||
{name: "结束格式错误", from: "2026-08-01", to: "2026/08/02", wantErr: "结束日期格式"},
|
||
{name: "起止倒置", from: "2026-08-03", to: "2026-08-02", wantErr: "不能晚于"},
|
||
{name: "晚于UTC加8今天", from: "2026-08-10", to: "2026-08-11", wantErr: "不能晚于"},
|
||
}
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
got, err := NewSybSyncOptions(tc.from, tc.to, now)
|
||
if tc.wantErr == "" {
|
||
if err != nil {
|
||
t.Fatalf("不应该报错: %v", err)
|
||
}
|
||
if got.From != tc.from || got.To != tc.to {
|
||
t.Fatalf("范围被意外改变：%+v", got)
|
||
}
|
||
return
|
||
}
|
||
if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
|
||
t.Fatalf("错误应包含 %q，实际 %v", tc.wantErr, err)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// ── 金额换算 ──────────────────────────────────────────
|
||
|
||
func TestRoundYuanToCent_先四舍五入再转整数(t *testing.T) {
|
||
cases := []struct {
|
||
yuan float64
|
||
want int64
|
||
}{
|
||
{239.0, 23900},
|
||
{612.5, 61250},
|
||
{5.05, 505}, // 08 §5.1 明确点名的样本
|
||
{0, 0},
|
||
}
|
||
for _, c := range cases {
|
||
got := roundYuanToCent(c.yuan)
|
||
if got != c.want {
|
||
t.Errorf("roundYuanToCent(%v) = %d，期望 %d", c.yuan, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── 端到端：httptest 假服务端 ─────────────────────────────
|
||
//
|
||
// `[必须]` 绝不能打真实的 shunyunbaoerp.com，见工单 #46。
|
||
|
||
// fakeDetail 是假服务端里一条货运单明细行的最小描述。
|
||
type fakeDetail struct {
|
||
ID int64
|
||
ProductID int64
|
||
ProductTitle string
|
||
ProductSpec string
|
||
ProductQty int
|
||
ProductPrice float64
|
||
ProductThumb int64
|
||
}
|
||
|
||
// fakeStock 是假服务端里一张货运单。
|
||
type fakeStock struct {
|
||
ID int64
|
||
Code string
|
||
ShopName string
|
||
Receiver string // 用来验证个人信息确实没有落库
|
||
Details []fakeDetail
|
||
}
|
||
|
||
// fakeSybServer 起一个 httptest 假服务端，模拟 listTotal / list /
|
||
// detail/listByStock 三个接口，数据来自内存里的 stocks 切片。
|
||
//
|
||
// failListPageIndex：如果 > 0，/am/stock/list 请求到这一页时返回失败，
|
||
// 用来测"中途失败不更新 last_synced_at"。
|
||
func fakeSybServer(t *testing.T, stocks []fakeStock, failListPageIndex int) *httptest.Server {
|
||
t.Helper()
|
||
byID := map[int64]fakeStock{}
|
||
for _, s := range stocks {
|
||
byID[s.ID] = s
|
||
}
|
||
|
||
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
switch r.URL.Path {
|
||
case "/am/stock/listTotal":
|
||
writeEnvelope(t, w, true, "ok", len(stocks), nil)
|
||
|
||
case "/am/stock/list":
|
||
var body map[string]any
|
||
json.NewDecoder(r.Body).Decode(&body)
|
||
pageIndex := int(body["pageIndex"].(float64))
|
||
length := int(body["length"].(float64))
|
||
start := int(body["start"].(float64))
|
||
|
||
if failListPageIndex > 0 && pageIndex == failListPageIndex {
|
||
writeEnvelope(t, w, false, "模拟的服务端故障", nil, "500")
|
||
return
|
||
}
|
||
|
||
end := start + length
|
||
if end > len(stocks) {
|
||
end = len(stocks)
|
||
}
|
||
var list []map[string]any
|
||
if start < len(stocks) {
|
||
for _, s := range stocks[start:end] {
|
||
list = append(list, map[string]any{
|
||
"id": s.ID, "code": s.Code, "shopName": s.ShopName,
|
||
"receiver": s.Receiver, "orderStatus": "待出货",
|
||
})
|
||
}
|
||
}
|
||
writeEnvelope(t, w, true, "ok", map[string]any{"list": list}, nil)
|
||
|
||
case "/am/stock/detail/listByStock":
|
||
var body struct {
|
||
IDs []int64 `json:"ids"`
|
||
}
|
||
json.NewDecoder(r.Body).Decode(&body)
|
||
var list []map[string]any
|
||
for _, id := range body.IDs {
|
||
s, ok := byID[id]
|
||
if !ok {
|
||
continue
|
||
}
|
||
var details []map[string]any
|
||
for _, d := range s.Details {
|
||
details = append(details, map[string]any{
|
||
"id": d.ID, "productId": d.ProductID, "productTitle": d.ProductTitle,
|
||
"productSpec": d.ProductSpec, "productQty": d.ProductQty,
|
||
"productPrice": d.ProductPrice, "productThumb": d.ProductThumb,
|
||
})
|
||
}
|
||
list = append(list, map[string]any{
|
||
"id": s.ID, "code": s.Code, "shopName": s.ShopName,
|
||
"receiver": s.Receiver, "details": details,
|
||
})
|
||
}
|
||
writeEnvelope(t, w, true, "ok", map[string]any{"list": list}, nil)
|
||
|
||
default:
|
||
t.Errorf("测试假服务端没有实现这个路径: %s", r.URL.Path)
|
||
w.WriteHeader(http.StatusNotFound)
|
||
}
|
||
}))
|
||
}
|
||
|
||
func writeEnvelope(t *testing.T, w http.ResponseWriter, status bool, msg string, data any, code any) {
|
||
t.Helper()
|
||
b, err := json.Marshal(map[string]any{"status": status, "msg": msg, "data": data, "code": code})
|
||
if err != nil {
|
||
t.Fatalf("构造响应失败: %v", err)
|
||
}
|
||
w.Write(b)
|
||
}
|
||
|
||
func newSyncTestDB(t *testing.T) *sql.DB {
|
||
t.Helper()
|
||
db, err := repository.Open(t.TempDir())
|
||
if err != nil {
|
||
t.Fatalf("打开测试库失败: %v", err)
|
||
}
|
||
t.Cleanup(func() { db.Close() })
|
||
if err := repository.Migrate(db); err != nil {
|
||
t.Fatalf("迁移失败: %v", err)
|
||
}
|
||
return db
|
||
}
|
||
|
||
func TestRunSybSync_已有的ShopeeSKUID同步后仍在(t *testing.T) {
|
||
// `[必须]` 端到端版本：整条 RunSybSync 流程跑完，人工匹配的
|
||
// shopee_sku_id 必须还在——这是工单 #46 唯一"错了要几周后才发现"的点。
|
||
srv := fakeSybServer(t, []fakeStock{
|
||
{
|
||
ID: 75104587, Code: "260728TB95MJTQ", ShopName: "测试店铺", Receiver: "张三",
|
||
Details: []fakeDetail{
|
||
{ID: 145306175, ProductID: 50209124255, ProductTitle: "蕾絲花邊拼接背心女",
|
||
ProductSpec: "白色,L【建議50-60公斤】", ProductQty: 1, ProductPrice: 239.0, ProductThumb: 190639637},
|
||
},
|
||
},
|
||
}, 0)
|
||
defer srv.Close()
|
||
|
||
db := newSyncTestDB(t)
|
||
client, err := syb.New(srv.URL)
|
||
if err != nil {
|
||
t.Fatalf("创建客户端失败: %v", err)
|
||
}
|
||
cfg := config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 500, SyncFrom: "2026-07-01"}
|
||
now := time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC)
|
||
|
||
report1 := RunSybSync(context.Background(), db, client, cfg, now)
|
||
if report1.Err != nil {
|
||
t.Fatalf("首次同步失败: %v", report1.Err)
|
||
}
|
||
if report1.Created != 1 {
|
||
t.Fatalf("首次同步应该新增 1 条，实际 Created=%d", report1.Created)
|
||
}
|
||
|
||
// 操作员在界面上完成规格匹配，手工写入 shopee_sku_id。
|
||
if _, err := db.Exec(`UPDATE syb_orders SET shopee_sku_id = ? WHERE syb_id = ?`,
|
||
"MANUAL-MATCHED-SKU", "145306175"); err != nil {
|
||
t.Fatalf("模拟人工匹配失败: %v", err)
|
||
}
|
||
|
||
// 再同步一次（模拟顺运宝那边这张单信息有更新）。
|
||
report2 := RunSybSync(context.Background(), db, client, cfg, now.Add(time.Hour))
|
||
if report2.Err != nil {
|
||
t.Fatalf("二次同步失败: %v", report2.Err)
|
||
}
|
||
if report2.Updated != 1 {
|
||
t.Fatalf("二次同步应该是更新，实际 Updated=%d Created=%d", report2.Updated, report2.Created)
|
||
}
|
||
|
||
var skuID string
|
||
if err := db.QueryRow(`SELECT shopee_sku_id FROM syb_orders WHERE syb_id = ?`,
|
||
"145306175").Scan(&skuID); err != nil {
|
||
t.Fatalf("查询失败: %v", err)
|
||
}
|
||
if skuID != "MANUAL-MATCHED-SKU" {
|
||
t.Fatalf("同步后 shopee_sku_id 应该还是 MANUAL-MATCHED-SKU，实际 %q"+
|
||
"——人工匹配成果被顺运宝同步洗掉了", skuID)
|
||
}
|
||
|
||
// 收件人信息不应该出现在 syb_data 里。
|
||
var sybData string
|
||
if err := db.QueryRow(`SELECT syb_data FROM syb_orders WHERE syb_id = ?`,
|
||
"145306175").Scan(&sybData); err != nil {
|
||
t.Fatalf("查询失败: %v", err)
|
||
}
|
||
if strings.Contains(sybData, "张三") {
|
||
t.Errorf("syb_data 不应该包含收件人姓名，实际: %s", sybData)
|
||
}
|
||
|
||
// 价格换算：239.0 元 -> 23900 分。
|
||
var priceCent int64
|
||
if err := db.QueryRow(`SELECT price_twd_cent FROM syb_orders WHERE syb_id = ?`,
|
||
"145306175").Scan(&priceCent); err != nil {
|
||
t.Fatalf("查询失败: %v", err)
|
||
}
|
||
if priceCent != 23900 {
|
||
t.Errorf("price_twd_cent 应该是 23900，实际 %d", priceCent)
|
||
}
|
||
|
||
// image_url 拼接。
|
||
var imageURL string
|
||
if err := db.QueryRow(`SELECT image_url FROM syb_orders WHERE syb_id = ?`,
|
||
"145306175").Scan(&imageURL); err != nil {
|
||
t.Fatalf("查询失败: %v", err)
|
||
}
|
||
wantImage := srv.URL + "/api/p/file?id=190639637"
|
||
if imageURL != wantImage {
|
||
t.Errorf("image_url 应该是 %q，实际 %q", wantImage, imageURL)
|
||
}
|
||
}
|
||
|
||
func TestRunSybSync_中途失败不更新last_synced_at(t *testing.T) {
|
||
// 两页数据，pageSize=1，第二页请求失败——模拟"拉到一半服务端出错"。
|
||
srv := fakeSybServer(t, []fakeStock{
|
||
{ID: 1, Code: "A", Details: []fakeDetail{{ID: 1, ProductID: 111, ProductQty: 1, ProductPrice: 1}}},
|
||
{ID: 2, Code: "B", Details: []fakeDetail{{ID: 2, ProductID: 222, ProductQty: 1, ProductPrice: 1}}},
|
||
}, 2) // 第 2 页失败
|
||
defer srv.Close()
|
||
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
cfg := config.SybConfig{BaseURL: srv.URL, PageSize: 1, MaxMatches: 500, SyncFrom: "2026-07-01"}
|
||
now := time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC)
|
||
|
||
report := RunSybSync(context.Background(), db, client, cfg, now)
|
||
if report.Err == nil {
|
||
t.Fatal("第二页失败时同步应该报错")
|
||
}
|
||
|
||
_, found, err := repository.GetSybLastSyncedAt(db)
|
||
if err != nil {
|
||
t.Fatalf("查询同步进度失败: %v", err)
|
||
}
|
||
if found {
|
||
t.Fatal("中途失败不应该更新 last_synced_at——更新了的话下次同步会跳过这段区间，" +
|
||
"漏掉的单永远补不回来")
|
||
}
|
||
}
|
||
|
||
func TestRunSybSync_全部成功后更新last_synced_at(t *testing.T) {
|
||
srv := fakeSybServer(t, []fakeStock{
|
||
{ID: 1, Code: "A", Details: []fakeDetail{{ID: 1, ProductID: 111, ProductQty: 1, ProductPrice: 1}}},
|
||
}, 0)
|
||
defer srv.Close()
|
||
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
cfg := config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 500, SyncFrom: "2026-07-01"}
|
||
now := time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC)
|
||
|
||
report := RunSybSync(context.Background(), db, client, cfg, now)
|
||
if report.Err != nil {
|
||
t.Fatalf("同步失败: %v", report.Err)
|
||
}
|
||
|
||
at, found, err := repository.GetSybLastSyncedAt(db)
|
||
if err != nil {
|
||
t.Fatalf("查询同步进度失败: %v", err)
|
||
}
|
||
if !found || at == "" {
|
||
t.Fatal("全部成功后应该更新 last_synced_at")
|
||
}
|
||
}
|
||
|
||
func TestRunSybSyncWithOptions_历史补拉不推进游标(t *testing.T) {
|
||
srv := fakeSybServer(t, nil, 0)
|
||
defer srv.Close()
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
const original = "2026-07-20T06:30:00Z"
|
||
if err := repository.SetSybLastSyncedAt(db, original); err != nil {
|
||
t.Fatalf("准备同步游标失败: %v", err)
|
||
}
|
||
|
||
report := RunSybSyncWithOptions(context.Background(), db, client,
|
||
config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 500, SyncFrom: "2026-07-01"},
|
||
time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC),
|
||
SybSyncOptions{From: "2026-07-01", To: "2026-07-10"})
|
||
if report.Err != nil {
|
||
t.Fatalf("历史补拉失败: %v", report.Err)
|
||
}
|
||
if !report.Specified || !strings.HasPrefix(report.Summary(), "指定日期同步完成") {
|
||
t.Fatalf("报告没有标明指定日期同步：%+v / %s", report, report.Summary())
|
||
}
|
||
at, _, err := repository.GetSybLastSyncedAt(db)
|
||
if err != nil {
|
||
t.Fatalf("读取同步游标失败: %v", err)
|
||
}
|
||
if at != original {
|
||
t.Fatalf("局部历史补拉不应推进游标，原值 %q，实际 %q", original, at)
|
||
}
|
||
}
|
||
|
||
func TestRunSybSyncWithOptions_完整覆盖自动范围才推进游标(t *testing.T) {
|
||
srv := fakeSybServer(t, nil, 0)
|
||
defer srv.Close()
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
const original = "2026-07-20T06:30:00Z" // UTC+8 仍是 7 月 20 日
|
||
if err := repository.SetSybLastSyncedAt(db, original); err != nil {
|
||
t.Fatalf("准备同步游标失败: %v", err)
|
||
}
|
||
|
||
report := RunSybSyncWithOptions(context.Background(), db, client,
|
||
config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 500, SyncFrom: "2026-07-01"},
|
||
time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC),
|
||
SybSyncOptions{From: "2026-07-20", To: "2026-07-28"})
|
||
if report.Err != nil {
|
||
t.Fatalf("完整范围同步失败: %v", report.Err)
|
||
}
|
||
at, _, err := repository.GetSybLastSyncedAt(db)
|
||
if err != nil {
|
||
t.Fatalf("读取同步游标失败: %v", err)
|
||
}
|
||
if at == original || at == "" {
|
||
t.Fatalf("完整覆盖自动范围后应该推进游标，实际仍为 %q", at)
|
||
}
|
||
}
|
||
|
||
func TestRunSybSync_数量小于等于0被跳过并计入报告(t *testing.T) {
|
||
srv := fakeSybServer(t, []fakeStock{
|
||
{ID: 1, Code: "A", Details: []fakeDetail{
|
||
{ID: 1, ProductID: 111, ProductQty: 1, ProductPrice: 10},
|
||
{ID: 2, ProductID: 222, ProductQty: 0, ProductPrice: 10}, // 应该被跳过
|
||
{ID: 3, ProductID: 333, ProductQty: -1, ProductPrice: 10}, // 应该被跳过
|
||
}},
|
||
}, 0)
|
||
defer srv.Close()
|
||
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
cfg := config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 500, SyncFrom: "2026-07-01"}
|
||
now := time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC)
|
||
|
||
report := RunSybSync(context.Background(), db, client, cfg, now)
|
||
if report.Err != nil {
|
||
t.Fatalf("同步失败: %v", report.Err)
|
||
}
|
||
if report.SkippedZero != 2 {
|
||
t.Fatalf("应该跳过 2 条 quantity<=0 的明细，实际 SkippedZero=%d", report.SkippedZero)
|
||
}
|
||
if len(report.Notes) != 2 {
|
||
t.Fatalf("跳过的明细应该在报告里列出来，实际 Notes=%v", report.Notes)
|
||
}
|
||
if report.Created != 1 {
|
||
t.Fatalf("只有 1 条应该真正写库，实际 Created=%d", report.Created)
|
||
}
|
||
|
||
n, err := repository.CountSybOrdersTotal(db)
|
||
if err != nil {
|
||
t.Fatalf("统计失败: %v", err)
|
||
}
|
||
if n != 1 {
|
||
t.Fatalf("库里应该只有 1 行，实际 %d 行", n)
|
||
}
|
||
}
|
||
|
||
func TestRunSybSync_超过最大条数报错不硬拉(t *testing.T) {
|
||
srv := fakeSybServer(t, []fakeStock{
|
||
{ID: 1, Code: "A"}, {ID: 2, Code: "B"}, {ID: 3, Code: "C"},
|
||
}, 0)
|
||
defer srv.Close()
|
||
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
cfg := config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 2, SyncFrom: "2026-07-01"}
|
||
now := time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC)
|
||
|
||
report := RunSybSync(context.Background(), db, client, cfg, now)
|
||
if report.Err == nil {
|
||
t.Fatal("总数 3 超过 max_matches=2 时应该报错")
|
||
}
|
||
if !strings.Contains(report.Err.Error(), "缩小") {
|
||
t.Errorf("错误信息应该提示缩小日期范围，实际: %v", report.Err)
|
||
}
|
||
|
||
if _, found, _ := repository.GetSybLastSyncedAt(db); found {
|
||
t.Error("超限报错不应该更新 last_synced_at")
|
||
}
|
||
n, _ := repository.CountSybOrdersTotal(db)
|
||
if n != 0 {
|
||
t.Errorf("超限报错不应该写入任何数据，实际写了 %d 行", n)
|
||
}
|
||
}
|
||
|
||
func TestRunSybSync_一张货运单多个商品各落一行(t *testing.T) {
|
||
srv := fakeSybServer(t, []fakeStock{
|
||
{ID: 1, Code: "A", Details: []fakeDetail{
|
||
{ID: 1, ProductID: 111, ProductQty: 1, ProductPrice: 10, ProductSpec: "白色,L"},
|
||
{ID: 2, ProductID: 222, ProductQty: 2, ProductPrice: 20, ProductSpec: "黑色,M"},
|
||
}},
|
||
}, 0)
|
||
defer srv.Close()
|
||
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New(srv.URL)
|
||
cfg := config.SybConfig{BaseURL: srv.URL, PageSize: 20, MaxMatches: 500, SyncFrom: "2026-07-01"}
|
||
now := time.Date(2026, 7, 28, 12, 0, 0, 0, time.UTC)
|
||
|
||
report := RunSybSync(context.Background(), db, client, cfg, now)
|
||
if report.Err != nil {
|
||
t.Fatalf("同步失败: %v", report.Err)
|
||
}
|
||
if report.Created != 2 {
|
||
t.Fatalf("一张货运单两个商品应该各落一行，实际 Created=%d", report.Created)
|
||
}
|
||
|
||
n, _ := repository.CountSybOrdersTotal(db)
|
||
if n != 2 {
|
||
t.Fatalf("库里应该有 2 行，实际 %d 行", n)
|
||
}
|
||
}
|
||
|
||
// ── 同步互斥标志 ──────────────────────────────────────
|
||
|
||
func TestSybSyncMutex_同一时间只允许一个同步(t *testing.T) {
|
||
t.Cleanup(func() { FinishSybSync(SyncReport{}) })
|
||
|
||
if !TryStartSybSync() {
|
||
t.Fatal("第一次应该能拿到互斥标志")
|
||
}
|
||
if TryStartSybSync() {
|
||
t.Fatal("同步进行中时，第二次不应该能拿到互斥标志")
|
||
}
|
||
FinishSybSync(SyncReport{From: "2026-08-09", To: "2026-08-09"})
|
||
if !TryStartSybSync() {
|
||
t.Fatal("上一次同步结束后应该能重新拿到互斥标志")
|
||
}
|
||
|
||
status := GetSybSyncStatus()
|
||
if !status.Running {
|
||
t.Error("刚拿到互斥标志后 Running 应该是 true")
|
||
}
|
||
FinishSybSync(SyncReport{From: "2026-08-09", To: "2026-08-09"})
|
||
status = GetSybSyncStatus()
|
||
if status.Running {
|
||
t.Error("FinishSybSync 之后 Running 应该是 false")
|
||
}
|
||
if status.Report == nil || status.Report.From != "2026-08-09" {
|
||
t.Errorf("应该能读到最近一次的报告，实际: %+v", status.Report)
|
||
}
|
||
}
|
||
|
||
// ── 会话有效性判断 ────────────────────────────────────
|
||
|
||
func TestEnsureSybSession_没有缓存时要求登录(t *testing.T) {
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New("https://example.invalid")
|
||
err := EnsureSybSession(db, client, "tester", time.Now())
|
||
if err != ErrSybLoginRequired {
|
||
t.Fatalf("没有缓存的会话时应该返回 ErrSybLoginRequired，实际: %v", err)
|
||
}
|
||
}
|
||
|
||
func TestEnsureSybSession_已过期时要求登录(t *testing.T) {
|
||
db := newSyncTestDB(t)
|
||
if err := repository.SaveSybSession(db, "tester", `[]`, "2026-08-01T00:00:00Z"); err != nil {
|
||
t.Fatalf("保存会话失败: %v", err)
|
||
}
|
||
client, _ := syb.New("https://example.invalid")
|
||
now := time.Date(2026, 8, 9, 0, 0, 0, 0, time.UTC)
|
||
|
||
err := EnsureSybSession(db, client, "tester", now)
|
||
if err != ErrSybLoginRequired {
|
||
t.Fatalf("过期会话应该返回 ErrSybLoginRequired，实际: %v", err)
|
||
}
|
||
}
|
||
|
||
func TestEnsureSybSession_未过期时恢复Cookie不要求登录(t *testing.T) {
|
||
db := newSyncTestDB(t)
|
||
cookiesJSON := `[{"name":"erp_session","value":"abc"}]`
|
||
if err := repository.SaveSybSession(db, "tester", cookiesJSON, "2026-08-10T00:00:00Z"); err != nil {
|
||
t.Fatalf("保存会话失败: %v", err)
|
||
}
|
||
client, _ := syb.New("https://example.invalid")
|
||
now := time.Date(2026, 8, 9, 0, 0, 0, 0, time.UTC)
|
||
|
||
if err := EnsureSybSession(db, client, "tester", now); err != nil {
|
||
t.Fatalf("未过期的会话不应该要求重新登录: %v", err)
|
||
}
|
||
}
|
||
|
||
func TestSaveSybLoginSession_写库和读回(t *testing.T) {
|
||
db := newSyncTestDB(t)
|
||
client, _ := syb.New("https://example.invalid")
|
||
|
||
expiresAt := time.Date(2026, 8, 10, 0, 0, 0, 0, time.UTC)
|
||
if err := SaveSybLoginSession(db, client, "tester", expiresAt); err != nil {
|
||
t.Fatalf("保存登录会话失败: %v", err)
|
||
}
|
||
|
||
cached, err := repository.GetSybSession(db, "tester")
|
||
if err != nil || cached == nil {
|
||
t.Fatalf("应该能读到刚保存的会话: cached=%v err=%v", cached, err)
|
||
}
|
||
got, ok := model.ParseISO(cached.ExpiresAt)
|
||
if !ok || !got.Equal(expiresAt) {
|
||
t.Errorf("expires_at 应该是 %v，实际 %v（parsed=%v）", expiresAt, cached.ExpiresAt, got)
|
||
}
|
||
}
|