mirror of
https://github.com/larksuite/cli.git
synced 2026-09-14 18:42:53 +08:00
chenxingyang1019
e0e90a4e1b
* fix(apps): classify the online DDL/DCL ban on +db-execute
Running DDL against the online branch of a multi-env app came back as
api/server_error with exit 1, hinted "fix the SQL and re-run", and carried a
statement position that did not exist. All three point the caller the wrong way:
- server_error means "upstream 5xx, retryable"; this is a product rule and no
number of retries changes it;
- the SQL is fine — the target environment is what has to change;
- "(at statement 1 of 1)" is fabricated. The server pre-validates the whole
batch and returns a single ERROR sentinel, so a 5-statement request with the
DDL in position 4 still rendered as "1 of 1". The CLI does not split the SQL,
so it cannot know the real count and cannot detect the mismatch generally —
only codes known to be batch-level rejections can drop the suffix.
Give code 4000001 its own arm: validation/failed_precondition (exit 2, "change
the environment, do not retry"), a hint pointing at dev plus +db-env-migrate, and
no statement position. Every other code keeps its current classification, wording
and position suffix; a test pins that.
4000001 is a dedicated server-side code (ErrOnlineEnvForbidDDLDCL, client-error
band), raised only by the pre-validation pass when env==online on a multi-env
workspace. Syntax errors and PG errors use different codes, so keying on it is
safe. Matching on the numeric value also covers the "k_dl_4000001" wire form,
since codeString already strips that prefix — both forms are tested.
"No statements were applied" is stated rather than inferred here: the validator
walks every statement and rejects the batch on the first DDL, so nothing lands.
The default arm would have inferred the opposite for a DDL in a later position
("Earlier statements were committed"), which is wrong for this code.
* fix(apps): classify tenant file storage quota exceeded
+file-upload against a tenant whose file storage is full returned api/unknown with
no hint at all, so a caller could not tell "the quota is full, stop" from "the
upstream had a bad minute, retry" — and had no next step either.
Register 400000055 as api/quota_exceeded. That is a dedicated server-side code
(ErrTenantStorageQuotaExceeded, client-error band) raised only on the upload path,
and the subtype already carries "retrying will not help", so the framework's
existing quota wording is enough and no domain-specific hint is added.
Left in CategoryAPI (exit 1) rather than Validation (exit 2): a full quota is not
something a different argument fixes, and exit 2 would imply it is.
The test asserts the hint is non-empty on purpose. The wording comes from the
shared APIHint table, so if quota_exceeded is ever dropped from there this fails
and says the code now needs its own wording, instead of silently shipping an
empty hint.
1074 lines
42 KiB
Go
1074 lines
42 KiB
Go
// Copyright (c) 2026 Lark Technologies Pte. Ltd.
|
||
// SPDX-License-Identifier: MIT
|
||
|
||
package apps
|
||
|
||
import (
|
||
"encoding/json"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"testing"
|
||
|
||
"github.com/larksuite/cli/errs"
|
||
"github.com/larksuite/cli/internal/httpmock"
|
||
"github.com/larksuite/cli/internal/output"
|
||
)
|
||
|
||
// TestAppsDBExecute_SingleSELECTJSONIsRowArray 断言单条 SELECT 的 JSON data 直接是行数组（不再透传 result 字符串）。
|
||
func TestAppsDBExecute_SingleSELECTJSONIsRowArray(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
// DBA 模式 result：结构化数组 JSON 字符串
|
||
"result": `[{"sql_type":"SELECT","data":"[{\"id\":101,\"total_cents\":2500}]","record_count":1}]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "select 1", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
// PRD 单 SELECT：data 直接是行数组（不再是 data.results[].data 字符串）
|
||
var env struct {
|
||
Data []map[string]interface{} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
|
||
t.Fatalf("decode envelope: %v\n%s", err, stdout.String())
|
||
}
|
||
if len(env.Data) != 1 {
|
||
t.Fatalf("data = %d rows (want 1)\n%s", len(env.Data), stdout.String())
|
||
}
|
||
if env.Data[0]["id"] != float64(101) || env.Data[0]["total_cents"] != float64(2500) {
|
||
t.Fatalf("data[0] = %v, want {id:101,total_cents:2500}", env.Data[0])
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_SingleDMLJSONShape 断言单条 DML 的 JSON data 形如 {command, rows_affected}。
|
||
func TestAppsDBExecute_SingleDMLJSONShape(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[{"sql_type":"INSERT","data":"","affected_rows":3}]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "insert", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
// PRD 单 DML：data = {command, rows_affected}
|
||
var env struct {
|
||
Data struct {
|
||
Command string `json:"command"`
|
||
RowsAffected int `json:"rows_affected"`
|
||
} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
|
||
t.Fatalf("decode: %v\n%s", err, stdout.String())
|
||
}
|
||
if env.Data.Command != "INSERT" || env.Data.RowsAffected != 3 {
|
||
t.Fatalf("data = %+v, want {command:INSERT, rows_affected:3}", env.Data)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_SingleDDLJSONShape 断言单条 DDL 的 JSON data 形如 {command}。
|
||
func TestAppsDBExecute_SingleDDLJSONShape(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[{"sql_type":"CREATE_TABLE","data":"[]"}]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "create", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
// PRD 单 DDL：data = {command}
|
||
var env struct {
|
||
Data struct {
|
||
Command string `json:"command"`
|
||
} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
|
||
t.Fatalf("decode: %v\n%s", err, stdout.String())
|
||
}
|
||
if env.Data.Command != "CREATE_TABLE" {
|
||
t.Fatalf("data.command = %q, want CREATE_TABLE", env.Data.Command)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_MultiStatementJSONShape 断言多语句的 JSON data 是元素数组，且 SELECT 包成 {command:"SELECT", rows:[...]}。
|
||
func TestAppsDBExecute_MultiStatementJSONShape(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[` +
|
||
`{"sql_type":"INSERT","data":"","affected_rows":1},` +
|
||
`{"sql_type":"SELECT","data":"[{\"id\":999}]","record_count":1}` +
|
||
`]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
// PRD 多语句：data 是元素数组；SELECT 包成 {command:"SELECT", rows:[...]}
|
||
var env struct {
|
||
Data []map[string]interface{} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
|
||
t.Fatalf("decode: %v\n%s", err, stdout.String())
|
||
}
|
||
if len(env.Data) != 2 {
|
||
t.Fatalf("data = %d elements (want 2)\n%s", len(env.Data), stdout.String())
|
||
}
|
||
if env.Data[0]["command"] != "INSERT" || env.Data[0]["rows_affected"] != float64(1) {
|
||
t.Fatalf("data[0] = %v, want {command:INSERT, rows_affected:1}", env.Data[0])
|
||
}
|
||
if env.Data[1]["command"] != "SELECT" {
|
||
t.Fatalf("data[1].command = %v, want SELECT", env.Data[1]["command"])
|
||
}
|
||
rows, ok := env.Data[1]["rows"].([]interface{})
|
||
if !ok || len(rows) != 1 {
|
||
t.Fatalf("data[1].rows = %v, want 1 row", env.Data[1]["rows"])
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_DryRunSendsTransactionalFalse 断言 dry-run 发出的请求是 POST、params 带 transactional=false（DBA 模式）且 transactional 不在 body 里。
|
||
func TestAppsDBExecute_DryRunSendsTransactionalFalse(t *testing.T) {
|
||
factory, stdout, _ := newAppsExecuteFactory(t)
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "select 1", "--environment", "dev", "--dry-run", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("dry-run err=%v", err)
|
||
}
|
||
var env dryRunAPIEnvelope
|
||
if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
|
||
t.Fatalf("decode: %v\n%s", err, stdout.String())
|
||
}
|
||
if env.API[0].Method != "POST" || env.API[0].URL != "/open-apis/spark/v1/apps/app_x/sql_commands" {
|
||
t.Fatalf("method/url = %s %s", env.API[0].Method, env.API[0].URL)
|
||
}
|
||
if env.API[0].Body["sql"] != "select 1" {
|
||
t.Fatalf("body.sql = %v", env.API[0].Body["sql"])
|
||
}
|
||
if env.API[0].Params["env"] != "dev" {
|
||
t.Fatalf("params.env = %v", env.API[0].Params["env"])
|
||
}
|
||
if env.API[0].Params["transactional"] != false {
|
||
t.Fatalf("params.transactional = %v (want false, CLI is DBA mode)", env.API[0].Params["transactional"])
|
||
}
|
||
if _, ok := env.API[0].Body["transactional"]; ok {
|
||
t.Fatalf("transactional should NOT be in body, got body=%v", env.API[0].Body)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_RejectsEmptySQL 断言 --sql 全空白时校验报错（提示需要 --sql 或 --file）。
|
||
func TestAppsDBExecute_RejectsEmptySQL(t *testing.T) {
|
||
factory, stdout, _ := newAppsExecuteFactory(t)
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", " ", "--as", "user"}, factory, stdout)
|
||
if err == nil || !strings.Contains(err.Error(), "--sql or --file") {
|
||
t.Fatalf("expected empty-sql error, got %v", err)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_LegacyEnvFlagRejected 钉死：旧名 --env 已移除，显式传入报 validation 错并指向 --environment。
|
||
func TestAppsDBExecute_LegacyEnvFlagRejected(t *testing.T) {
|
||
factory, stdout, _ := newAppsExecuteFactory(t)
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "select 1", "--env", "dev", "--as", "user"}, factory, stdout)
|
||
if err == nil {
|
||
t.Fatalf("--env should be rejected; stdout:\n%s", stdout.String())
|
||
}
|
||
p, ok := errs.ProblemOf(err)
|
||
if !ok || p.Category != errs.CategoryValidation {
|
||
t.Fatalf("want a typed validation error, got %T: %v", err, err)
|
||
}
|
||
if !strings.Contains(p.Message, "--environment") {
|
||
t.Errorf("message should point to --environment: %q", p.Message)
|
||
}
|
||
}
|
||
|
||
// --sql 与 --file 互斥
|
||
func TestAppsDBExecute_RejectsSQLAndFileTogether(t *testing.T) {
|
||
factory, stdout, _ := newAppsExecuteFactory(t)
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "SELECT 1", "--file", "x.sql", "--as", "user"}, factory, stdout)
|
||
if err == nil || !strings.Contains(err.Error(), "mutually exclusive") {
|
||
t.Fatalf("expected mutual-exclusion error, got %v", err)
|
||
}
|
||
}
|
||
|
||
// --file 读取相对路径 .sql 文件 → 内容进 body.sql（dry-run 验证）
|
||
func TestAppsDBExecute_FileReadsSQLIntoBody(t *testing.T) {
|
||
dir := t.TempDir()
|
||
sqlPath := filepath.Join(dir, "m.sql")
|
||
if err := os.WriteFile(sqlPath, []byte("SELECT 42 AS answer;\n"), 0o600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// 切到临时目录，使相对路径校验通过（CLI 仅接受 cwd 内相对路径）。
|
||
// 用 os.Chdir + 还原而非 t.Chdir：后者要 Go 1.24，本仓库 go.mod 为 1.23。
|
||
oldWD, err := os.Getwd()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := os.Chdir(dir); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Cleanup(func() { _ = os.Chdir(oldWD) })
|
||
|
||
factory, stdout, _ := newAppsExecuteFactory(t)
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--app-id", "app_x", "--environment", "dev", "--file", "m.sql", "--dry-run", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("dry-run err=%v", err)
|
||
}
|
||
var env dryRunAPIEnvelope
|
||
if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
|
||
t.Fatalf("decode: %v\n%s", err, stdout.String())
|
||
}
|
||
if env.API[0].Body["sql"] != "SELECT 42 AS answer;\n" {
|
||
t.Fatalf("body.sql = %v, want file content", env.API[0].Body["sql"])
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// legacy wire 形态测试 —— BOE server 实测返这种 ["rows-json-string", ...]
|
||
// 形态而非 spec 里的 [{sql_type, data, ...}]，CLI 端必须兼容。
|
||
// 输入用 BOE 真实抓包数据（test_scripts/boe_e2e/run.log）。
|
||
// ============================================================================
|
||
|
||
// TestAppsDBExecute_LegacyWireSingleSelect 断言 legacy 字符串数组 wire 的单 SELECT 能正常渲染表格、不回退到 RAW。
|
||
func TestAppsDBExecute_LegacyWireSingleSelect(t *testing.T) {
|
||
// BOE 实测：SELECT 1 AS x → result: "[\"[{\\\"x\\\":1}]\"]"
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `["[{\"x\":1}]"]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "SELECT 1 AS x", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
if !strings.Contains(got, "x") {
|
||
t.Errorf("missing header 'x':\n%s", got)
|
||
}
|
||
if !strings.Contains(got, "1") {
|
||
t.Errorf("missing value row '1':\n%s", got)
|
||
}
|
||
// 不应回退到 RAW
|
||
if strings.Contains(got, "RAW") || strings.Contains(got, "[\\\"") {
|
||
t.Errorf("should not fall back to RAW or raw-string passthrough:\n%s", got)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_LegacyWireSingleSelectJSONIsRowArray 断言 legacy wire 的 SELECT 同样归一化成 PRD 行数组形态。
|
||
func TestAppsDBExecute_LegacyWireSingleSelectJSONIsRowArray(t *testing.T) {
|
||
// 验证 legacy wire 的 SELECT 也归一化成 PRD 行数组形态（data 直接是行）
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `["[{\"x\":1}]"]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "SELECT 1 AS x", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
var env struct {
|
||
Data []map[string]interface{} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
|
||
t.Fatalf("decode: %v\n%s", err, stdout.String())
|
||
}
|
||
if len(env.Data) != 1 {
|
||
t.Fatalf("data length = %d, want 1; got: %v", len(env.Data), env.Data)
|
||
}
|
||
if env.Data[0]["x"] != float64(1) {
|
||
t.Fatalf("data[0].x = %v, want 1", env.Data[0]["x"])
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_LegacyWireMultiSelect 断言 legacy wire 多 SELECT 输出带 Statement N header 与末尾 "✓ N statements executed" 汇总。
|
||
func TestAppsDBExecute_LegacyWireMultiSelect(t *testing.T) {
|
||
// BOE 实测：SELECT 1; SELECT 2 → result: "[\"[{\\\"?column?\\\":1}]\",\"[{\\\"?column?\\\":2}]\"]"
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `["[{\"?column?\":1}]","[{\"?column?\":2}]"]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "SELECT 1; SELECT 2;", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
// 多语句应有 Statement N: header
|
||
if !strings.Contains(got, "Statement 1: SELECT") || !strings.Contains(got, "Statement 2: SELECT") {
|
||
t.Errorf("missing Statement headers:\n%s", got)
|
||
}
|
||
// 末尾应有 ✓ N statements executed
|
||
if !strings.Contains(got, "✓ 2 statements executed") {
|
||
t.Errorf("missing summary line:\n%s", got)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_LegacyWireDDLEmptyResult 断言 result 为空字符串时（legacy DDL）pretty 输出 "(empty result)"。
|
||
func TestAppsDBExecute_LegacyWireDDLEmptyResult(t *testing.T) {
|
||
// BOE 实测：CREATE TABLE → result: "" （空字符串，无 rows）
|
||
// 老 wire 不区分 DDL/DML/无返回，统一标 "ok"
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": ``, // 空字符串
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "CREATE TABLE foo (id INT)", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
// result="" 触发 parseSQLResult 返 nil → renderSQLPretty 输出 "(empty result)"
|
||
if !strings.Contains(got, "(empty result)") {
|
||
t.Errorf("expected '(empty result)' for empty result string, got:\n%s", got)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_LegacyWireMultiSelectWithRealTable 断言含 CJK / uuid / int 字段的真实表行能正确显示在 pretty 表格里。
|
||
func TestAppsDBExecute_LegacyWireMultiSelectWithRealTable(t *testing.T) {
|
||
// BOE 实测真实表抓包（course 表第一行）：复杂 JSON 含 CJK / timestamp / uuid 字段
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `["[{\"id\":\"abc-123\",\"title\":\"高效沟通\",\"capacity\":30}]"]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "SELECT id,title,capacity FROM course LIMIT 1", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
// 验证 CJK / uuid / int 都能正确显示在表格里
|
||
for _, want := range []string{"id", "title", "capacity", "abc-123", "高效沟通", "30"} {
|
||
if !strings.Contains(got, want) {
|
||
t.Errorf("missing %q in pretty output:\n%s", want, got)
|
||
}
|
||
}
|
||
}
|
||
|
||
// pretty 单 SELECT：表格输出，列间两空格，无 Statement header。
|
||
func TestAppsDBExecute_PrettySingleSelectTable(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[{"sql_type":"SELECT","data":"[{\"id\":101,\"total_cents\":2500},{\"id\":102,\"total_cents\":1800}]","record_count":2}]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "select", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
if strings.Contains(got, "Statement 1:") {
|
||
t.Errorf("single statement pretty should NOT have Statement header\noutput:\n%s", got)
|
||
}
|
||
// 列按字典序排序：id / total_cents
|
||
if !strings.Contains(got, "id total_cents") {
|
||
t.Errorf("missing header row\noutput:\n%s", got)
|
||
}
|
||
if !strings.Contains(got, "101 2500") || !strings.Contains(got, "102 1800") {
|
||
t.Errorf("missing data rows\noutput:\n%s", got)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_PrettyEmptySelect 断言空 SELECT 的 pretty 输出为 "(0 rows)"。
|
||
func TestAppsDBExecute_PrettyEmptySelect(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[{"sql_type":"SELECT","data":"[]","record_count":0}]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "select", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
if !strings.Contains(stdout.String(), "(0 rows)") {
|
||
t.Fatalf("empty SELECT should print (0 rows), got:\n%s", stdout.String())
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_PrettySingleDMLAndDDL 断言单条 DML 渲染 "✓ N row(s) <verb>"、各类 DDL（含细粒度动词）渲染 "✓ DDL executed"。
|
||
func TestAppsDBExecute_PrettySingleDMLAndDDL(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
result string
|
||
wantStr string
|
||
}{
|
||
{"INSERT_1_row", `[{"sql_type":"INSERT","data":"","affected_rows":1}]`, "✓ 1 row inserted"},
|
||
{"UPDATE_5_rows", `[{"sql_type":"UPDATE","data":"","affected_rows":5}]`, "✓ 5 rows updated"},
|
||
{"DELETE_0_rows", `[{"sql_type":"DELETE","data":"","affected_rows":0}]`, "✓ 0 rows deleted"},
|
||
{"DDL", `[{"sql_type":"DDL","data":"","affected_rows":0}]`, "✓ DDL executed"},
|
||
// 真机 boe 实测：DDL 的 sql_type 是细粒度动词（CREATE_TABLE / DROP_TABLE / ALTER_TABLE...），
|
||
// data 是 "[]"、无 affected_rows。必须识别为 DDL，而不是落到 dmlSummary 渲染成 "0 rows affected"。
|
||
{"CREATE_TABLE", `[{"sql_type":"CREATE_TABLE","data":"[]"}]`, "✓ DDL executed"},
|
||
{"DROP_TABLE", `[{"sql_type":"DROP_TABLE","data":"[]"}]`, "✓ DDL executed"},
|
||
{"ALTER_TABLE", `[{"sql_type":"ALTER_TABLE","data":"[]"}]`, "✓ DDL executed"},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"result": c.result}},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
if !strings.Contains(stdout.String(), c.wantStr) {
|
||
t.Errorf("want %q\ngot:\n%s", c.wantStr, stdout.String())
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_PrettyMultiStatementsAllSuccess 断言多语句全成功时逐条 Statement 摘要 + 末尾 "✓ N statements executed"。
|
||
func TestAppsDBExecute_PrettyMultiStatementsAllSuccess(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[` +
|
||
`{"sql_type":"INSERT","data":"","affected_rows":1},` +
|
||
`{"sql_type":"UPDATE","data":"","affected_rows":1},` +
|
||
`{"sql_type":"SELECT","data":"[{\"id\":999}]","record_count":1}` +
|
||
`]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
for _, line := range []string{
|
||
"Statement 1: ✓ 1 row inserted",
|
||
"Statement 2: ✓ 1 row updated",
|
||
"Statement 3: SELECT (1 row)",
|
||
"✓ 3 statements executed",
|
||
} {
|
||
if !strings.Contains(got, line) {
|
||
t.Errorf("missing %q in pretty output\nfull:\n%s", line, got)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_PrettyMultiStatementsDDL 钉住真机 boe 多语句 DDL 的 wire：
|
||
// CREATE_TABLE / DROP_TABLE（data="[]"、无 affected_rows）须渲染成 "✓ DDL executed"，
|
||
// 不能落到 dmlSummary 变成 "0 rows affected"。
|
||
func TestAppsDBExecute_PrettyMultiStatementsDDL(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[{"sql_type":"CREATE_TABLE","data":"[]"},{"sql_type":"DROP_TABLE","data":"[]"}]`,
|
||
},
|
||
},
|
||
})
|
||
if err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--format", "pretty", "--as", "user"},
|
||
factory, stdout); err != nil {
|
||
t.Fatalf("execute err=%v", err)
|
||
}
|
||
got := stdout.String()
|
||
for _, line := range []string{
|
||
"Statement 1: ✓ DDL executed",
|
||
"Statement 2: ✓ DDL executed",
|
||
"✓ 2 statements executed",
|
||
} {
|
||
if !strings.Contains(got, line) {
|
||
t.Errorf("missing %q in pretty output\nfull:\n%s", line, got)
|
||
}
|
||
}
|
||
if strings.Contains(got, "rows affected") {
|
||
t.Errorf("DDL must not render as 'rows affected'\nfull:\n%s", got)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_PrettyMultiStatementsPartialFailureWithErrorSentinel 断言多语句部分失败时 pretty 仍打逐条 ✓/✗ 摘要、声明前序已 commit 未回滚，且返回 typed error、不打成功汇总。
|
||
func TestAppsDBExecute_PrettyMultiStatementsPartialFailureWithErrorSentinel(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[` +
|
||
`{"sql_type":"INSERT","data":"","affected_rows":1},` +
|
||
`{"sql_type":"ERROR","data":"{\"code\":1300015,\"message\":\"syntax error at or near 'SELEC'\"}"}` +
|
||
`]`,
|
||
},
|
||
},
|
||
})
|
||
// pretty 失败路径：逐条 ✓/✗ 摘要照打到 stdout（人看），同时返回 typed error（exit 非 0）。
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--format", "pretty", "--as", "user"},
|
||
factory, stdout)
|
||
if err == nil {
|
||
t.Fatalf("pretty multi-statement failure must still return a typed error; stdout:\n%s", stdout.String())
|
||
}
|
||
got := stdout.String()
|
||
for _, line := range []string{
|
||
"Statement 1: ✓ 1 row inserted",
|
||
"Statement 2: ✗ syntax error at or near 'SELEC' [1300015]",
|
||
} {
|
||
if !strings.Contains(got, line) {
|
||
t.Errorf("missing %q in pretty output\nfull:\n%s", line, got)
|
||
}
|
||
}
|
||
// 非事务（transactional=false）前序语句已逐条 commit 落地，须如实说明「committed and not rolled back」，
|
||
// 绝不能误报整批回滚。
|
||
if !strings.Contains(got, "committed and not rolled back") {
|
||
t.Errorf("non-tx failure must state prior statements committed & not rolled back; got:\n%s", got)
|
||
}
|
||
if strings.Contains(got, "statements executed") {
|
||
t.Errorf("failed run should NOT print success summary; got:\n%s", got)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_MultiStatementFailureReturnsTypedError 钉死「多语句失败 → typed errs.APIError」：
|
||
// json 默认不再打 ok:true 假成功，而是返回 typed errs.* 错误（type=api / subtype=server_error、
|
||
// exit=1）。失败位置在 message 的 "(at statement N of M)"，前序是否落地/是否回滚写在 hint。
|
||
// 本例无 BEGIN → 前序逐条 commit、未回滚（hint 含 "committed and not rolled back"）。
|
||
func TestAppsDBExecute_MultiStatementFailureReturnsTypedError(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[` +
|
||
`{"sql_type":"INSERT","data":"","affected_rows":1},` +
|
||
`{"sql_type":"ERROR","data":"{\"code\":\"k_dl_1300002\",\"message\":\"duplicate key value violates unique constraint\"}"}` +
|
||
`]`,
|
||
},
|
||
},
|
||
})
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--as", "user"},
|
||
factory, stdout)
|
||
if err == nil {
|
||
t.Fatalf("multi-statement failure must return a typed error; stdout:\n%s", stdout.String())
|
||
}
|
||
// json 失败路径不得打成功 envelope。
|
||
if strings.Contains(stdout.String(), `"ok": true`) {
|
||
t.Errorf("must not emit ok:true success envelope on failure; stdout:\n%s", stdout.String())
|
||
}
|
||
p, ok := errs.ProblemOf(err)
|
||
if !ok {
|
||
t.Fatalf("want a typed errs.* error, got %T: %v", err, err)
|
||
}
|
||
if p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeServerError {
|
||
t.Errorf("category/subtype = %s/%s, want api/server_error", p.Category, p.Subtype)
|
||
}
|
||
if p.Code != 1300002 {
|
||
t.Errorf("code = %d, want 1300002", p.Code)
|
||
}
|
||
if !strings.Contains(p.Message, "(at statement 2 of 2)") {
|
||
t.Errorf("message missing statement locator: %q", p.Message)
|
||
}
|
||
// 无 BEGIN → 前序逐条 commit、未回滚，语义写在 hint。
|
||
if !strings.Contains(p.Hint, "committed and not rolled back") {
|
||
t.Errorf("hint should state prior statements committed & not rolled back: %q", p.Hint)
|
||
}
|
||
if output.ExitCodeOf(err) != output.ExitAPI {
|
||
t.Errorf("exit = %d, want %d (ExitAPI)", output.ExitCodeOf(err), output.ExitAPI)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_SingleErrorReturnsTypedError 单条语句失败（server 也返 code:0 + ERROR 哨兵）
|
||
// 同样升级成 typed error：statement_index=0、completed 空、message 标注 (at statement 1 of 1)。
|
||
func TestAppsDBExecute_SingleErrorReturnsTypedError(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
"result": `[{"sql_type":"ERROR","data":"{\"code\":\"k_dl_000002\",\"message\":\"syntax error at or near 'SELEC'\"}"}]`,
|
||
},
|
||
},
|
||
})
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--as", "user"},
|
||
factory, stdout)
|
||
if err == nil {
|
||
t.Fatalf("single ERROR sentinel must return a typed error; stdout:\n%s", stdout.String())
|
||
}
|
||
p, ok := errs.ProblemOf(err)
|
||
if !ok {
|
||
t.Fatalf("want a typed errs.* error, got %T: %v", err, err)
|
||
}
|
||
if p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeServerError {
|
||
t.Errorf("category/subtype = %s/%s, want api/server_error", p.Category, p.Subtype)
|
||
}
|
||
if !strings.Contains(p.Message, "(at statement 1 of 1)") {
|
||
t.Errorf("message missing locator: %q", p.Message)
|
||
}
|
||
// 第一条就失败、无落地 的语义写在 hint。
|
||
if !strings.Contains(p.Hint, "No statements were applied") {
|
||
t.Errorf("hint should state nothing applied: %q", p.Hint)
|
||
}
|
||
}
|
||
|
||
// TestAppsDBExecute_TransactionFailureRolledBack 钉死「显式事务内失败 → 整批回滚」：
|
||
// 实测后端把 BEGIN 也作为 statement 返回；completed 含未配对 BEGIN → inferRolledBack 判定回滚。
|
||
// 回滚语义现写在 hint（miaoda 原句 "Transaction rolled back; no changes persisted."），失败位置在 message。
|
||
func TestAppsDBExecute_TransactionFailureRolledBack(t *testing.T) {
|
||
factory, stdout, reg := newAppsExecuteFactory(t)
|
||
reg.Register(&httpmock.Stub{
|
||
Method: "POST",
|
||
URL: "/open-apis/spark/v1/apps/app_x/sql_commands",
|
||
Body: map[string]interface{}{
|
||
"code": 0,
|
||
"data": map[string]interface{}{
|
||
// BOE 实测 wire：BEGIN; CREATE; INSERT(ok); INSERT(dup→ERROR)
|
||
"result": `[` +
|
||
`{"sql_type":"BEGIN","data":"[]"},` +
|
||
`{"sql_type":"CREATE_TABLE","data":"[]"},` +
|
||
`{"sql_type":"INSERT","data":"[{\"rowCount\":1}]","affected_rows":1},` +
|
||
`{"sql_type":"ERROR","data":"{\"code\":\"k_dl_1300002\",\"message\":\"duplicate key value violates unique constraint\"}"}` +
|
||
`]`,
|
||
},
|
||
},
|
||
})
|
||
err := runAppsShortcut(t, AppsDBExecute,
|
||
[]string{"+db-execute", "--yes", "--app-id", "app_x", "--sql", "x", "--as", "user"},
|
||
factory, stdout)
|
||
if err == nil {
|
||
t.Fatalf("transaction failure must return a typed error; stdout:\n%s", stdout.String())
|
||
}
|
||
p, ok := errs.ProblemOf(err)
|
||
if !ok {
|
||
t.Fatalf("want a typed errs.* error, got %T: %v", err, err)
|
||
}
|
||
if p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeServerError {
|
||
t.Errorf("category/subtype = %s/%s, want api/server_error", p.Category, p.Subtype)
|
||
}
|
||
if !strings.Contains(p.Message, "(at statement 4 of 4)") {
|
||
t.Errorf("message missing statement locator: %q", p.Message)
|
||
}
|
||
// 事务整批回滚 / 前序未落库 的语义写在 hint（miaoda 原句）。
|
||
if !strings.Contains(p.Hint, "Transaction rolled back; no changes persisted.") {
|
||
t.Errorf("hint should state transaction rolled back & nothing persisted: %q", p.Hint)
|
||
}
|
||
}
|
||
|
||
// TestInferRolledBack_Cases 断言 inferRolledBack 按 BEGIN/COMMIT/ROLLBACK 计数判定失败时事务是否仍开着（即整批回滚）。
|
||
func TestInferRolledBack_Cases(t *testing.T) {
|
||
stmt := func(t string) map[string]interface{} { return map[string]interface{}{"sql_type": t} }
|
||
cases := []struct {
|
||
name string
|
||
completed []map[string]interface{}
|
||
want bool
|
||
}{
|
||
{"empty", nil, false},
|
||
{"autocommit single", []map[string]interface{}{stmt("INSERT")}, false},
|
||
{"open tx (unmatched BEGIN)", []map[string]interface{}{stmt("BEGIN"), stmt("CREATE_TABLE"), stmt("INSERT")}, true},
|
||
{"closed tx (BEGIN+COMMIT)", []map[string]interface{}{stmt("BEGIN"), stmt("INSERT"), stmt("COMMIT")}, false},
|
||
{"reopened tx", []map[string]interface{}{stmt("BEGIN"), stmt("COMMIT"), stmt("BEGIN"), stmt("INSERT")}, true},
|
||
{"rollback closes tx", []map[string]interface{}{stmt("BEGIN"), stmt("INSERT"), stmt("ROLLBACK")}, false},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
if got := inferRolledBack(c.completed); got != c.want {
|
||
t.Errorf("inferRolledBack(%s) = %v, want %v", c.name, got, c.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestCellString_AllKinds 断言 cellString 对 nil/string/bool/整数/小数/对象各类型的字符串化结果。
|
||
func TestCellString_AllKinds(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
in interface{}
|
||
want string
|
||
}{
|
||
{"nil", nil, ""},
|
||
{"string", "hello", "hello"},
|
||
{"bool true", true, "true"},
|
||
{"bool false", false, "false"},
|
||
{"int float", float64(101), "101"},
|
||
{"fractional", float64(1.25), "1.25"},
|
||
{"object", map[string]interface{}{"a": float64(1)}, `{"a":1}`},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
if got := cellString(c.in); got != c.want {
|
||
t.Errorf("cellString(%v)=%q want %q", c.in, got, c.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestCodeString_Forms 断言 codeString 处理 nil / "k_dl_xxx" / 纯数字串 / float64 / 不支持类型各形态。
|
||
func TestCodeString_Forms(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
in interface{}
|
||
want string
|
||
}{
|
||
{"nil", nil, ""},
|
||
{"k_dl prefix", "k_dl_1300015", "1300015"},
|
||
{"plain string", "1300015", "1300015"},
|
||
{"float64", float64(42), "42"},
|
||
{"unsupported", []int{1}, ""},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
if got := codeString(c.in); got != c.want {
|
||
t.Errorf("codeString(%v)=%q want %q", c.in, got, c.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestDmlVerb_AllVerbs 断言 dmlVerb 对 INSERT/UPDATE/DELETE/MERGE 的动词映射（大小写不敏感），非 DML 返回 affected。
|
||
func TestDmlVerb_AllVerbs(t *testing.T) {
|
||
cases := map[string]string{
|
||
"INSERT": "inserted",
|
||
"update": "updated",
|
||
"DELETE": "deleted",
|
||
"Merge": "merged",
|
||
"CREATE_TABLE": "affected",
|
||
}
|
||
for in, want := range cases {
|
||
if got := dmlVerb(in); got != want {
|
||
t.Errorf("dmlVerb(%q)=%q want %q", in, got, want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestIntOrZero_Cases 断言 intOrZero 对 JSON number 取整、对非数字 / nil 返回 0。
|
||
func TestIntOrZero_Cases(t *testing.T) {
|
||
if got := intOrZero(float64(5)); got != 5 {
|
||
t.Errorf("intOrZero(5)=%d want 5", got)
|
||
}
|
||
if got := intOrZero("x"); got != 0 {
|
||
t.Errorf("intOrZero(non-numeric)=%d want 0", got)
|
||
}
|
||
if got := intOrZero(nil); got != 0 {
|
||
t.Errorf("intOrZero(nil)=%d want 0", got)
|
||
}
|
||
}
|
||
|
||
// TestErrorSummary_Cases 断言 errorSummary 对空 / 非法 JSON / 带 code / 无 code 各情形生成 "message [code]" 文案。
|
||
func TestErrorSummary_Cases(t *testing.T) {
|
||
cases := []struct {
|
||
name, in, want string
|
||
}{
|
||
{"empty", "", "(unknown error)"},
|
||
{"malformed json", "not json", "not json"},
|
||
{"with code", `{"code":"k_dl_1300015","message":"boom"}`, "boom [1300015]"},
|
||
{"no code", `{"message":"plain"}`, "plain"},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
if got := errorSummary(c.in); got != c.want {
|
||
t.Errorf("errorSummary(%q)=%q want %q", c.in, got, c.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestParseErrorSentinel_Cases 断言 parseErrorSentinel 解析 ERROR 哨兵 data 得到数值 code 与 message（含空 / 非法 / 空 message 回退）。
|
||
func TestParseErrorSentinel_Cases(t *testing.T) {
|
||
cases := []struct {
|
||
name, in string
|
||
wantCode int
|
||
wantMsg string
|
||
}{
|
||
{"empty", "", 0, "(unknown error)"},
|
||
{"malformed", "xyz", 0, "xyz"},
|
||
{"code+msg", `{"code":"1300015","message":"boom"}`, 1300015, "boom"},
|
||
{"empty msg", `{"code":"1300015","message":""}`, 1300015, "(unknown error)"},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
code, msg := parseErrorSentinel(c.in)
|
||
if code != c.wantCode || msg != c.wantMsg {
|
||
t.Errorf("parseErrorSentinel(%q)=%d,%q want %d,%q", c.in, code, msg, c.wantCode, c.wantMsg)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestIsStructuredResult_Cases 断言 isStructuredResult 仅在首元素含 sql_type 时判为新结构化形态。
|
||
func TestIsStructuredResult_Cases(t *testing.T) {
|
||
if !isStructuredResult([]map[string]interface{}{{"sql_type": "SELECT"}}) {
|
||
t.Error("expected structured=true when sql_type present")
|
||
}
|
||
if isStructuredResult([]map[string]interface{}{{}}) {
|
||
t.Error("expected structured=false when sql_type absent")
|
||
}
|
||
if isStructuredResult(nil) {
|
||
t.Error("expected structured=false for empty")
|
||
}
|
||
}
|
||
|
||
// TestNormalizeLegacyStatement_Cases 断言 normalizeLegacyStatement 把空 / null / 非 JSON 标为 OK、把 rows 数组标为 SELECT 并带 record_count。
|
||
func TestNormalizeLegacyStatement_Cases(t *testing.T) {
|
||
t.Run("empty -> OK", func(t *testing.T) {
|
||
got := normalizeLegacyStatement("")
|
||
if got["sql_type"] != "OK" {
|
||
t.Errorf("got sql_type=%v want OK", got["sql_type"])
|
||
}
|
||
})
|
||
t.Run("null -> OK", func(t *testing.T) {
|
||
got := normalizeLegacyStatement("null")
|
||
if got["sql_type"] != "OK" {
|
||
t.Errorf("got sql_type=%v want OK", got["sql_type"])
|
||
}
|
||
})
|
||
t.Run("rows -> SELECT", func(t *testing.T) {
|
||
got := normalizeLegacyStatement(`[{"id":1}]`)
|
||
if got["sql_type"] != "SELECT" {
|
||
t.Errorf("got sql_type=%v want SELECT", got["sql_type"])
|
||
}
|
||
if got["record_count"] != float64(1) {
|
||
t.Errorf("got record_count=%v want 1", got["record_count"])
|
||
}
|
||
})
|
||
t.Run("non-json kept as OK", func(t *testing.T) {
|
||
got := normalizeLegacyStatement(`notjson`)
|
||
if got["sql_type"] != "OK" {
|
||
t.Errorf("got sql_type=%v want OK", got["sql_type"])
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestCellString_MarshalFallback 断言 cellString 对 json.Marshal 拒绝的类型（如 complex）回退到 fmt %v。
|
||
func TestCellString_MarshalFallback(t *testing.T) {
|
||
// complex128 is not switch-handled and json.Marshal rejects it →
|
||
// falls back to fmt.Sprintf("%v", v), which is deterministic for complex.
|
||
if got := cellString(complex(1, 2)); got != "(1+2i)" {
|
||
t.Errorf("cellString(complex)=%q want (1+2i)", got)
|
||
}
|
||
}
|
||
|
||
// TestRenderSingleStatementPretty_Branches 断言 renderSingleStatementPretty 对 SELECT/ERROR/DML/legacy OK/DDL 各分支的输出。
|
||
func TestRenderSingleStatementPretty_Branches(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
stmt map[string]interface{}
|
||
substr string
|
||
}{
|
||
{"select empty", map[string]interface{}{"sql_type": "SELECT", "data": "[]"}, "(0 rows)"},
|
||
{"error", map[string]interface{}{"sql_type": "ERROR", "data": `{"message":"boom"}`}, "✗ boom"},
|
||
{"dml insert", map[string]interface{}{"sql_type": "INSERT", "affected_rows": float64(3)}, "✓ 3 rows inserted"},
|
||
{"legacy ok", map[string]interface{}{"sql_type": "OK"}, "✓ ok"},
|
||
{"ddl default", map[string]interface{}{"sql_type": "CREATE_TABLE"}, "✓ DDL executed"},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
var b strings.Builder
|
||
renderSingleStatementPretty(&b, c.stmt)
|
||
if !strings.Contains(b.String(), c.substr) {
|
||
t.Errorf("output %q does not contain %q", b.String(), c.substr)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestRenderSelectRowsAsTable_Branches 断言 renderSelectRowsAsTable 对空串 / 空数组 / 非法 JSON 回退 / 正常 rows 各分支的输出。
|
||
func TestRenderSelectRowsAsTable_Branches(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
data string
|
||
substr string
|
||
}{
|
||
{"empty string", "", "(0 rows)"},
|
||
{"empty array", "[]", "(0 rows)"},
|
||
{"malformed fallback", "{bad", "{bad"},
|
||
{"rows", `[{"id":1}]`, "id"},
|
||
}
|
||
for _, c := range cases {
|
||
t.Run(c.name, func(t *testing.T) {
|
||
var b strings.Builder
|
||
renderSelectRowsAsTable(&b, c.data)
|
||
if !strings.Contains(b.String(), c.substr) {
|
||
t.Errorf("output %q does not contain %q", b.String(), c.substr)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestSQLStatementError_OnlineDDLForbidden 断言 online DDL 禁令走专属分支：
|
||
// validation/failed_precondition（exit 2）、指向 dev + 发布的 hint、且不带伪造的语句位置。
|
||
//
|
||
// 为什么位置后缀必须去掉：服务端前置校验整批拒绝、只回一条 ERROR 哨兵，所以 CLI 看到的
|
||
// len(stmts) 恒为 1。实测发 5 条语句、DDL 在第 4 位时默认分支会渲染成 "at statement 1 of 1"
|
||
// —— 一个编造的位置。CLI 不解析 SQL，拿不到真实语句数，只能对这类码省略位置。
|
||
func TestSQLStatementError_OnlineDDLForbidden(t *testing.T) {
|
||
// 两种 wire 形态都覆盖：codeString 会把 "k_dl_4000001" 剥成 4000001，
|
||
// 所以按数值判断对带前缀的字符串同样成立。
|
||
for _, wire := range []string{
|
||
`{"code":4000001,"message":"forbid ddl/dcl operation in online env"}`,
|
||
`{"code":"k_dl_4000001","message":"forbid ddl/dcl operation in online env"}`,
|
||
} {
|
||
stmts := []map[string]interface{}{{"sql_type": "ERROR", "data": wire}}
|
||
err := sqlStatementError(stmts, 0, stmts[0])
|
||
p, ok := errs.ProblemOf(err)
|
||
if !ok {
|
||
t.Fatalf("wire %s: not a typed error: %T", wire, err)
|
||
}
|
||
if p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeFailedPrecondition {
|
||
t.Errorf("wire %s: category/subtype = %s/%s, want validation/failed_precondition", wire, p.Category, p.Subtype)
|
||
}
|
||
if p.Code != dbOnlineDDLForbiddenCode {
|
||
t.Errorf("wire %s: code = %d, want %d", wire, p.Code, dbOnlineDDLForbiddenCode)
|
||
}
|
||
if got := output.ExitCodeOf(err); got != 2 {
|
||
t.Errorf("wire %s: exit = %d, want 2 (fix the environment, do not retry)", wire, got)
|
||
}
|
||
// 位置后缀必须消失，且 message 保留服务端原句。
|
||
if strings.Contains(p.Message, "at statement") {
|
||
t.Errorf("wire %s: message keeps a fabricated statement position: %q", wire, p.Message)
|
||
}
|
||
if p.Message != "forbid ddl/dcl operation in online env" {
|
||
t.Errorf("wire %s: message = %q, want the server wording verbatim", wire, p.Message)
|
||
}
|
||
if p.Hint != dbOnlineDDLForbiddenHint {
|
||
t.Errorf("wire %s: hint = %q, want the dev+migrate hint", wire, p.Hint)
|
||
}
|
||
if strings.Contains(p.Hint, "fix the SQL") {
|
||
t.Errorf("wire %s: hint still tells the caller to fix the SQL", wire)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 多语句时也不能出现位置后缀：DDL 在第 4 位、服务端只回一条哨兵，位置无从得知。
|
||
func TestSQLStatementError_OnlineDDLForbidden_NoPositionEvenWhenIndexNonZero(t *testing.T) {
|
||
stmts := []map[string]interface{}{
|
||
{"sql_type": "SELECT"},
|
||
{"sql_type": "INSERT"},
|
||
{"sql_type": "ERROR", "data": `{"code":4000001,"message":"forbid ddl/dcl operation in online env"}`},
|
||
}
|
||
p, _ := errs.ProblemOf(sqlStatementError(stmts, 2, stmts[2]))
|
||
if strings.Contains(p.Message, "at statement") {
|
||
t.Errorf("message keeps a statement position: %q", p.Message)
|
||
}
|
||
// 也不该沿用 errIdx>0 那支「前序已提交」的 hint —— 本码是整批拒绝，前序并未落地。
|
||
if strings.Contains(p.Hint, "Earlier statements were committed") {
|
||
t.Errorf("hint claims earlier statements committed, but this code rejects the whole batch: %q", p.Hint)
|
||
}
|
||
}
|
||
|
||
// 其它码保持原行为：分类、位置后缀、回滚推断都不变（本次改动刻意不碰它们）。
|
||
func TestSQLStatementError_OtherCodesUnchanged(t *testing.T) {
|
||
for _, tc := range []struct {
|
||
name string
|
||
wire string
|
||
}{
|
||
{"语法错误", `{"code":2,"message":"syntax error at or near \"SELCT\""}`},
|
||
{"PG 报错", `{"code":"k_dl_1300002","message":"duplicate key value violates unique constraint"}`},
|
||
} {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
stmts := []map[string]interface{}{{"sql_type": "ERROR", "data": tc.wire}}
|
||
err := sqlStatementError(stmts, 0, stmts[0])
|
||
p, _ := errs.ProblemOf(err)
|
||
if p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeServerError {
|
||
t.Errorf("category/subtype = %s/%s, want api/server_error (unchanged)", p.Category, p.Subtype)
|
||
}
|
||
if got := output.ExitCodeOf(err); got != 1 {
|
||
t.Errorf("exit = %d, want 1 (unchanged)", got)
|
||
}
|
||
if !strings.Contains(p.Message, "at statement 1 of 1") {
|
||
t.Errorf("message lost its position suffix: %q", p.Message)
|
||
}
|
||
})
|
||
}
|
||
}
|