Skip to content

Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.

test(util): drop patch narration and fold the JSON extract cases into one file

askalf5afefa0248ba
diff --git a/runtime/krillinai/internal/service/audio2subtitle_test.go b/runtime/krillinai/internal/service/audio2subtitle_test.go
index 9d11689b..67b9a37b 100644
--- a/runtime/krillinai/internal/service/audio2subtitle_test.go
+++ b/runtime/krillinai/internal/service/audio2subtitle_test.go
@@ -436,9 +436,8 @@ func TestSplitTranslateItemReportsLongSentenceProgress(t *testing.T) {
}
}
-// TestSplitOriginLongSentenceToleratesLLMNoise 覆盖 issue #291 的两类真实响应:
+// TestSplitOriginLongSentenceToleratesLLMNoise 覆盖两类带噪声的响应:
// 结束符前的尾随逗号,以及 JSON 之前的中文对话式说明。
-// 两者在修复前都会让 json.Unmarshal 失败,三次重试耗尽后返回空结果。
func TestSplitOriginLongSentenceToleratesLLMNoise(t *testing.T) {
log.InitLogger()
tests := []struct {
@@ -478,8 +477,7 @@ func TestSplitOriginLongSentenceToleratesLLMNoise(t *testing.T) {
}
}
-// TestSplitLongSentenceToleratesConversationalPrefix 覆盖 issue #291 日志中
-// splitLongSentence 的失败响应:LLM 在对齐结果前输出中文说明。
+// TestSplitLongSentenceToleratesConversationalPrefix LLM 在对齐结果前输出中文说明时仍能拿到对齐结果。
func TestSplitLongSentenceToleratesConversationalPrefix(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{
@@ -502,10 +500,8 @@ func TestSplitLongSentenceToleratesConversationalPrefix(t *testing.T) {
}
}
-// TestSplitLongSentenceRejectsDecoyObject 覆盖说明文字里带示例 JSON 的响应:
-// 真正的对齐结果前面出现一个合法但无关的对象。按字段挑选候选之前,
-// 这个示例会被当成回答解析出来,splitLongSentence 于是返回“成功但为空”的分割结果,
-// 既不报错也不重试,长句被静默丢弃。
+// TestSplitLongSentenceRejectsDecoyObject 真正的对齐结果前面出现一个合法但无关的示例对象时,
+// 长句仍照应拆分,而不是拿到一个空的分割结果。
func TestSplitLongSentenceRejectsDecoyObject(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{
@@ -528,9 +524,8 @@ func TestSplitLongSentenceRejectsDecoyObject(t *testing.T) {
}
}
-// TestSplitOriginLongSentenceRejectsDecoyObject 覆盖同一类响应在重试型解析点上的表现:
-// 示例对象被解析成功但不含 short_sentences,循环随即 break,
-// 三次重试一次都不会发生,函数返回空切片且 err 为 nil。
+// TestSplitOriginLongSentenceRejectsDecoyObject 同一类响应在重试型解析点上也应拿到
+// 真正的短句列表,而不是空切片。
func TestSplitOriginLongSentenceRejectsDecoyObject(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{
@@ -554,8 +549,7 @@ func TestSplitOriginLongSentenceRejectsDecoyObject(t *testing.T) {
}
}
-// TestSplitLongSentenceStillFailsOnGarbage (control) 完全不含目标字段的响应仍然是解析错误。
-// 该行为在修复前后一致,用于证明按字段挑选候选没有把坏响应变成“成功但为空”。
+// TestSplitLongSentenceStillFailsOnGarbage 完全不含目标字段的响应仍然是解析错误。
func TestSplitLongSentenceStillFailsOnGarbage(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{"抱歉,我无法完成这个请求"}}
diff --git a/runtime/krillinai/internal/service/translate_test.go b/runtime/krillinai/internal/service/translate_test.go
index 04c2a1ab..f3f1992e 100644
--- a/runtime/krillinai/internal/service/translate_test.go
+++ b/runtime/krillinai/internal/service/translate_test.go
@@ -7,8 +7,8 @@ import (
"testing"
)
-// TestTranslatorSplitOriginLongSentenceToleratesLLMNoise 覆盖 Translator 上与
-// Service 同形的解析点(translate.go),确保 issue #291 的两类响应在这里同样被容忍。
+// TestTranslatorSplitOriginLongSentenceToleratesLLMNoise Translator 上与 Service 同形的
+// 解析点(translate.go)同样容忍这两类带噪声的响应。
func TestTranslatorSplitOriginLongSentenceToleratesLLMNoise(t *testing.T) {
log.InitLogger()
tests := []struct {
@@ -48,8 +48,8 @@ func TestTranslatorSplitOriginLongSentenceToleratesLLMNoise(t *testing.T) {
}
}
-// TestBatchTranslateTextsToleratesConversationalPrefix 覆盖批量翻译的解析点,
-// 该路径在解析失败时会丢掉整批译文。
+// TestBatchTranslateTextsToleratesConversationalPrefix 批量翻译的解析点在带对话式前缀的
+// 响应上仍然拿到整批译文。
func TestBatchTranslateTextsToleratesConversationalPrefix(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{
@@ -74,9 +74,8 @@ func TestBatchTranslateTextsToleratesConversationalPrefix(t *testing.T) {
}
}
-// TestTranslatorSplitOriginLongSentenceRejectsDecoyObject 覆盖 Translator 上同形的解析点:
-// 说明文字里的示例对象在按字段挑选候选之前会被当成回答,
-// 循环 break 后返回空切片且 err 为 nil,整句拆分被静默跳过。
+// TestTranslatorSplitOriginLongSentenceRejectsDecoyObject Translator 上同形的解析点也跳过
+// 说明文字里的示例对象,拿到真正的短句列表。
func TestTranslatorSplitOriginLongSentenceRejectsDecoyObject(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{
@@ -100,9 +99,8 @@ func TestTranslatorSplitOriginLongSentenceRejectsDecoyObject(t *testing.T) {
}
}
-// TestBatchTranslateTextsRejectsDecoyObject 覆盖批量翻译的解析点:
-// 示例对象被当作回答时 translations 为空,数量校验失败,
-// 该请求会白白重试三次并最终丢掉整批译文。
+// TestBatchTranslateTextsRejectsDecoyObject 批量翻译的解析点跳过输出格式示例对象,
+// 拿到整批译文。
func TestBatchTranslateTextsRejectsDecoyObject(t *testing.T) {
log.InitLogger()
completer := &scriptedCompleter{responses: []string{
diff --git a/runtime/krillinai/pkg/util/json_extract_boundary_test.go b/runtime/krillinai/pkg/util/json_extract_boundary_test.go
deleted file mode 100644
index 594d7fc0..00000000
--- a/runtime/krillinai/pkg/util/json_extract_boundary_test.go
+++ /dev/null
@@ -1,206 +0,0 @@
-package util
-
-import "testing"
-
-// TestExtractJSONObjectScannerBoundaries 覆盖扫描器本身的边界:转义处理、行尾符号、
-// BOM、Unicode 转义与更深的嵌套。这些输入在修复前都会原样带着噪声交给
-// encoding/json,因此每一条都能区分修复前后的行为。
-func TestExtractJSONObjectScannerBoundaries(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "转义反斜杠结尾的字符串后仍能识别尾随逗号",
- response: `{"a":"x\\",}`,
- key: "a",
- want: `{"a":"x\\"}`,
- },
- {
- name: "Windows 换行的尾随逗号",
- response: "{\r\n\"a\": 1,\r\n}",
- key: "a",
- want: "{\r\n\"a\": 1}",
- },
- {
- name: "BOM 前缀被丢弃",
- response: "\ufeff{\"a\":1}",
- key: "a",
- want: `{"a":1}`,
- },
- {
- name: "字符串内的 Unicode 转义不影响嵌套深度",
- response: `{"a":"\u007d","b":2,}`,
- key: "a",
- want: `{"a":"\u007d","b":2}`,
- },
- {
- name: "三层嵌套的连续尾随逗号",
- response: `{"a":{"b":{"c":[1,],},},}`,
- key: "a",
- want: `{"a":{"b":{"c":[1]}}}`,
- },
- {
- name: "嵌套数组的尾随逗号",
- response: `{"a":[[1,],],}`,
- key: "a",
- want: `{"a":[[1]]}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-// TestExtractJSONObjectSkipsDecoyValues 钉住按字段选取候选的语义:
-// 正文里出现在真正回答之前的方括号、示意性对象或空对象都不含目标字段,
-// 会被跳过,扫描继续往后找,直到命中顶层带该字段的对象。
-// 修复前取的是第一个 JSON 值,这些用例都会拿到错误的候选。
-func TestExtractJSONObjectSkipsDecoyValues(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "正文中的方括号被跳过",
- response: `See [1] below: {"short_sentences":[{"text":"a"}]}`,
- key: "short_sentences",
- want: `{"short_sentences":[{"text":"a"}]}`,
- },
- {
- name: "示意性对象被跳过",
- response: `{"note":"见下"} 结果:{"short_sentences":[{"text":"a"}]}`,
- key: "short_sentences",
- want: `{"short_sentences":[{"text":"a"}]}`,
- },
- {
- name: "示例空对象被跳过",
- response: "格式如 {}:\n{\"align\":[{\"origin_part\":\"a\",\"translated_part\":\"b\"}]}",
- key: "align",
- want: `{"align":[{"origin_part":"a","translated_part":"b"}]}`,
- },
- {
- name: "多个诱饵连续出现",
- response: `例如 [] 或 {} 或 {"text":"x"},实际结果:{"translations":[{"index":1,"text":"一"}]}`,
- key: "translations",
- want: `{"translations":[{"index":1,"text":"一"}]}`,
- },
- {
- name: "诱饵中带尾随逗号也能跳过",
- response: `{"note":"见下",} 结果:{"short_sentences":[{"text":"a"},]}`,
- key: "short_sentences",
- want: `{"short_sentences":[{"text":"a"}]}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-// TestExtractJSONObjectLeavesUnparsableInputAlone (control) 结构损坏或没有合适候选时
-// 函数不做猜测,修复前后都原样返回去除首尾空白的输入,调用方因此仍能拿到真实的解析错误。
-// 与表驱动用例中的 "[}" 互为反向:这里覆盖相反的括号顺序、字符串未闭合
-// (结尾是孤立反斜杠),以及所有候选都不含目标字段这几条不同的代码路径。
-// 其中"大小写不一致"一条固定了取候选时按字段名精确匹配:encoding/json 解码字段是
-// 不区分大小写的,这里更严格,命不中就退回原样返回,由调用方按原有逻辑报错重试。
-func TestExtractJSONObjectLeavesUnparsableInputAlone(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "结束符顺序相反",
- response: "{]",
- key: "align",
- want: "{]",
- },
- {
- name: "字符串未闭合且以孤立反斜杠结尾",
- response: `{"a":"x\`,
- key: "a",
- want: `{"a":"x\`,
- },
- {
- name: "未闭合的诱饵吞掉后文时整体原样返回",
- response: `{ 结果:{"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{ 结果:{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "没有任何候选含目标字段",
- response: `{"note":"x"} {"other":1}`,
- key: "align",
- want: `{"note":"x"} {"other":1}`,
- },
- {
- name: "同名字段只嵌套在下层时不算命中",
- response: `{"data":{"align":[{"origin_part":"a"}]}}`,
- key: "align",
- want: `{"data":{"align":[{"origin_part":"a"}]}}`,
- },
- {
- name: "字段名大小写不一致时不算命中",
- response: `{"Align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"Align":[{"origin_part":"a"}]}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-// TestExtractJSONObjectAcceptsPresentButEmptyField (control) 说明字段存在即视为命中:
-// 模型明确回答了一个空列表或 null 时不再继续往后扫描,这与“找不到字段”是两回事。
-// 这两条在修复前后都通过(输入本身就是目标对象),用于固定“存在即命中”的判定,
-// 防止日后把空值误判成没有回答而继续扫描后面的内容。
-func TestExtractJSONObjectAcceptsPresentButEmptyField(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "字段为空数组",
- response: `{"align":[]}`,
- key: "align",
- want: `{"align":[]}`,
- },
- {
- name: "字段为 null",
- response: `{"align":null}`,
- key: "align",
- want: `{"align":null}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
diff --git a/runtime/krillinai/pkg/util/json_extract_fence_test.go b/runtime/krillinai/pkg/util/json_extract_fence_test.go
deleted file mode 100644
index 3580ba8b..00000000
--- a/runtime/krillinai/pkg/util/json_extract_fence_test.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package util
-
-import "testing"
-
-// TestExtractJSONObjectFenceAndWalkOrder 固定“先去 Markdown 围栏、再按候选向后扫描”这一顺序。
-// ExtractJSONObject 先调用 CleanMarkdownCodeBlock,再在结果上逐个取候选,
-// 因此围栏内外的示例对象都会先变成普通文本、再被候选扫描跳过。
-// 已有的“Markdown 代码块”用例只有围栏、没有示例对象,
-// “示例空对象被跳过”只有示例对象、没有围栏,两者的组合此前没有用例覆盖。
-// 修复前整段响应只去围栏就交给 encoding/json,两条都拿不到单个对象,能区分修复前后。
-func TestExtractJSONObjectFenceAndWalkOrder(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "围栏内的示例对象被跳过",
- response: "```json\n{} {\"align\":[{\"origin_part\":\"a\"}]}\n```",
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "围栏之前的示例对象被跳过",
- response: "示例:{\"note\":\"x\"}\n```json\n{\"align\":[{\"origin_part\":\"a\"}]}\n```",
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "字符串里的围栏标记不影响候选边界",
- response: "{\"note\":\"```json\"} {\"align\":[{\"origin_part\":\"a\"}]}",
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-// TestExtractJSONObjectNonASCIITrailingComma 固定 trimTrailingComma 的字符集边界。
-// 它只去掉 ASCII 逗号(cutset 为 " \t\r\n,"),中文全角逗号不在其中,
-// 因此带全角逗号的候选仍然是非法 JSON、会被 hasTopLevelKey 判为不命中并继续向后扫描,
-// 而不是被“修好”后当成回答。这保证容错只覆盖已知的尾随逗号形态,不会猜测其他写法。
-// 修复前整段响应直接交给 encoding/json,拿不到后面那个对象,能区分修复前后。
-func TestExtractJSONObjectNonASCIITrailingComma(t *testing.T) {
- const response = `{"align":[1],} {"align":[{"origin_part":"a"}]}`
- const want = `{"align":[{"origin_part":"a"}]}`
-
- if got := ExtractJSONObject(response, "align"); got != want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, want)
- }
-}
-
-// TestExtractJSONObjectDuplicateTopLevelKey 固定顶层字段重复时仍算命中。
-// encoding/json 解到 map 时后出现的同名字段会覆盖前一个,但字段依然存在,
-// 因此这类响应属于“模型的真正回答”,应当就地返回,而不是跳过后落到原样返回。
-// 前面放一个不含目标字段的示例对象,使“接受该候选”和“跳到最后原样返回”的结果不同。
-func TestExtractJSONObjectDuplicateTopLevelKey(t *testing.T) {
- const response = `{"note":"见下"} {"align":[1],"align":[2]}`
- const want = `{"align":[1],"align":[2]}`
-
- if got := ExtractJSONObject(response, "align"); got != want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, want)
- }
-}
diff --git a/runtime/krillinai/pkg/util/json_extract_verify_test.go b/runtime/krillinai/pkg/util/json_extract_verify_test.go
deleted file mode 100644
index 90e71b15..00000000
--- a/runtime/krillinai/pkg/util/json_extract_verify_test.go
+++ /dev/null
@@ -1,115 +0,0 @@
-package util
-
-import "testing"
-
-// TestExtractJSONObjectCandidateWalkBoundaries 补齐候选扫描在“诱饵本身不是合法 JSON”
-// 以及“同名字段出现在不同层级”这两类输入上的判定。修复前取的是第一个 JSON 值,
-// 这些响应都会把诱饵当成回答,因此每一条都能区分修复前后的行为。
-func TestExtractJSONObjectCandidateWalkBoundaries(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- // 诱饵字符串里的 { 只有在扫描器正确跳过字符串字面量时才不会打乱深度,
- // 深度算错就会把诱饵和真正的回答连成一个值。
- name: "诱饵字符串内的括号不会吞掉后面的回答",
- response: `{"note":"{"} 结果:{"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- // 括号闭合但内容不是合法 JSON:hasTopLevelKey 解析失败即跳过,扫描继续。
- name: "括号闭合但无法解析的诱饵被跳过",
- response: `{"a":} 结果:{"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "只有逗号的诱饵被跳过",
- response: `{,} 结果:{"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- // 顶层数组即使内部含有目标字段也不是候选,扫描会继续到后面的顶层对象。
- name: "顶层数组内含同名字段时继续向后扫描",
- response: `[{"align":[9]}] 结果:{"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- // 与“同名字段只嵌套在下层时不算命中”互补:下层同名字段之后还有真正的顶层对象,
- // 说明跳过嵌套命中之后扫描不会就此停下。
- name: "先出现嵌套同名字段再出现顶层对象时取顶层的",
- response: `{"data":{"align":[9]}} {"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "首个大括号前的逗号被丢弃",
- response: `,{"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "空字符串值后的尾随逗号被去掉",
- response: `{"align":"",}`,
- key: "align",
- want: `{"align":""}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-// TestExtractJSONObjectStopsAtFirstCarrier 固定“命中即返回”的顺序语义:
-// 有多个顶层候选都带目标字段时取最靠前的一个,回答之后的示例对象不参与选取。
-// 修复前整段响应会被原样交给 encoding/json,因此两条都能区分修复前后的行为;
-// 同时它们排除了“取最后一个候选”这种同样能修好 issue #291 的替代实现。
-func TestExtractJSONObjectStopsAtFirstCarrier(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "多个候选都含目标字段时取最前面的",
- response: `{"align":[{"origin_part":"a"}]} {"align":[{"origin_part":"b"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- {
- name: "回答之后的示例对象不影响结果",
- response: `{"align":[{"origin_part":"a"}]} 仅供参考:{}`,
- key: "align",
- want: `{"align":[{"origin_part":"a"}]}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-// TestExtractJSONObjectWhitespaceOnlyInput (control) 只有空白的响应在修复前后都返回空字符串:
-// CleanMarkdownCodeBlock 先把输入清成空串,候选循环的 0 < 0 直接不进入。
-// 用于固定入口处的这条边界,防止日后在空输入上返回别的东西或越界。
-func TestExtractJSONObjectWhitespaceOnlyInput(t *testing.T) {
- if got := ExtractJSONObject(" \n\t ", "align"); got != "" {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, "")
- }
-}
diff --git a/runtime/krillinai/pkg/util/json_selection_test.go b/runtime/krillinai/pkg/util/json_selection_test.go
deleted file mode 100644
index 0f4698ad..00000000
--- a/runtime/krillinai/pkg/util/json_selection_test.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package util
-
-import "testing"
-
-// TestExtractJSONObjectSelectionAmongCarriers 在“候选之后还有另一个候选”的输入上固定选取语义。
-// TestExtractJSONObjectAcceptsPresentButEmptyField 和
-// TestExtractJSONObjectLeavesUnparsableInputAlone/字段名大小写不一致时不算命中
-// 的响应本身就是期望结果,接受该候选与一路跳到最后原样返回会得到相同的字符串,
-// 因此它们看不出选取规则的变化;这里在后面再放一个含目标字段的对象,
-// 让“接受”和“跳过”给出不同的结果:
-// - 字段值为空数组或 null 时仍然接受,不会改取后面的对象;
-// - 字段名大小写不一致时不接受,会继续扫描到精确匹配的对象。
-//
-// 修复前整段响应原样交给 encoding/json,三条都拿不到单个对象,因此都能区分修复前后的行为。
-func TestExtractJSONObjectSelectionAmongCarriers(t *testing.T) {
- tests := []struct {
- name string
- response string
- key string
- want string
- }{
- {
- name: "字段为空数组的候选仍然优先于后面的候选",
- response: `{"align":[]} {"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":[]}`,
- },
- {
- name: "字段为 null 的候选仍然优先于后面的候选",
- response: `{"align":null} {"align":[{"origin_part":"a"}]}`,
- key: "align",
- want: `{"align":null}`,
- },
- {
- name: "大小写不一致的候选被跳过后取精确匹配的",
- response: `{"Align":[{"origin_part":"a"}]} {"align":[{"origin_part":"b"}]}`,
- key: "align",
- want: `{"align":[{"origin_part":"b"}]}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
- t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
- }
- })
- }
-}
diff --git a/runtime/krillinai/pkg/util/json_test.go b/runtime/krillinai/pkg/util/json_test.go
index b18a5e98..5ca00db0 100644
--- a/runtime/krillinai/pkg/util/json_test.go
+++ b/runtime/krillinai/pkg/util/json_test.go
@@ -96,6 +96,12 @@ func TestExtractJSONObject(t *testing.T) {
key: "short_sentences",
want: "",
},
+ {
+ name: "只有空白",
+ response: " \n\t ",
+ key: "align",
+ want: "",
+ },
{
name: "结构不完整时原样返回",
response: `{"short_sentences":[{"text":"a"}`,
@@ -143,8 +149,363 @@ func TestExtractJSONObject(t *testing.T) {
}
}
-// TestExtractJSONObjectOutputIsParsable 保证提取结果确实能被 encoding/json 解析,
-// 这正是 issue #291 中失败的两类响应。
+// TestExtractJSONObjectScannerBoundaries 覆盖扫描器的边界:转义处理、行尾符号、
+// BOM、Unicode 转义与更深的嵌套。
+func TestExtractJSONObjectScannerBoundaries(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "转义反斜杠结尾的字符串后仍能识别尾随逗号",
+ response: `{"a":"x\\",}`,
+ key: "a",
+ want: `{"a":"x\\"}`,
+ },
+ {
+ name: "Windows 换行的尾随逗号",
+ response: "{\r\n\"a\": 1,\r\n}",
+ key: "a",
+ want: "{\r\n\"a\": 1}",
+ },
+ {
+ name: "BOM 前缀被丢弃",
+ response: "\ufeff{\"a\":1}",
+ key: "a",
+ want: `{"a":1}`,
+ },
+ {
+ name: "字符串内的 Unicode 转义不影响嵌套深度",
+ response: `{"a":"\u007d","b":2,}`,
+ key: "a",
+ want: `{"a":"\u007d","b":2}`,
+ },
+ {
+ name: "三层嵌套的连续尾随逗号",
+ response: `{"a":{"b":{"c":[1,],},},}`,
+ key: "a",
+ want: `{"a":{"b":{"c":[1]}}}`,
+ },
+ {
+ name: "嵌套数组的尾随逗号",
+ response: `{"a":[[1,],],}`,
+ key: "a",
+ want: `{"a":[[1]]}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectSkipsDecoyValues 说明文字里的方括号、示意性对象或空对象都不含
+// 目标字段,扫描继续往后找,直到命中顶层带该字段的对象。
+func TestExtractJSONObjectSkipsDecoyValues(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "正文中的方括号被跳过",
+ response: `See [1] below: {"short_sentences":[{"text":"a"}]}`,
+ key: "short_sentences",
+ want: `{"short_sentences":[{"text":"a"}]}`,
+ },
+ {
+ name: "示意性对象被跳过",
+ response: `{"note":"见下"} 结果:{"short_sentences":[{"text":"a"}]}`,
+ key: "short_sentences",
+ want: `{"short_sentences":[{"text":"a"}]}`,
+ },
+ {
+ name: "示例空对象被跳过",
+ response: "格式如 {}:\n{\"align\":[{\"origin_part\":\"a\",\"translated_part\":\"b\"}]}",
+ key: "align",
+ want: `{"align":[{"origin_part":"a","translated_part":"b"}]}`,
+ },
+ {
+ name: "多个诱饵连续出现",
+ response: `例如 [] 或 {} 或 {"text":"x"},实际结果:{"translations":[{"index":1,"text":"一"}]}`,
+ key: "translations",
+ want: `{"translations":[{"index":1,"text":"一"}]}`,
+ },
+ {
+ name: "诱饵中带尾随逗号也能跳过",
+ response: `{"note":"见下",} 结果:{"short_sentences":[{"text":"a"},]}`,
+ key: "short_sentences",
+ want: `{"short_sentences":[{"text":"a"}]}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectLeavesUnparsableInputAlone 结构损坏或没有合适候选时不做猜测,
+// 原样返回去除首尾空白的输入,调用方因此仍能拿到真实的解析错误。
+// 取候选时按字段名精确匹配,大小写不一致也算不命中。
+func TestExtractJSONObjectLeavesUnparsableInputAlone(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "结束符顺序相反",
+ response: "{]",
+ key: "align",
+ want: "{]",
+ },
+ {
+ name: "字符串未闭合且以孤立反斜杠结尾",
+ response: `{"a":"x\`,
+ key: "a",
+ want: `{"a":"x\`,
+ },
+ {
+ name: "未闭合的诱饵吞掉后文时整体原样返回",
+ response: `{ 结果:{"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{ 结果:{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "没有任何候选含目标字段",
+ response: `{"note":"x"} {"other":1}`,
+ key: "align",
+ want: `{"note":"x"} {"other":1}`,
+ },
+ {
+ name: "同名字段只嵌套在下层时不算命中",
+ response: `{"data":{"align":[{"origin_part":"a"}]}}`,
+ key: "align",
+ want: `{"data":{"align":[{"origin_part":"a"}]}}`,
+ },
+ {
+ name: "字段名大小写不一致时不算命中",
+ response: `{"Align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"Align":[{"origin_part":"a"}]}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectCandidateWalkBoundaries 覆盖“诱饵本身不是合法 JSON”以及
+// “同名字段出现在不同层级”这两类输入上的判定。
+func TestExtractJSONObjectCandidateWalkBoundaries(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "诱饵字符串内的括号不会吞掉后面的回答",
+ response: `{"note":"{"} 结果:{"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "括号闭合但无法解析的诱饵被跳过",
+ response: `{"a":} 结果:{"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "只有逗号的诱饵被跳过",
+ response: `{,} 结果:{"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "顶层数组内含同名字段时继续向后扫描",
+ response: `[{"align":[9]}] 结果:{"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "先出现嵌套同名字段再出现顶层对象时取顶层的",
+ response: `{"data":{"align":[9]}} {"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "首个大括号前的逗号被丢弃",
+ response: `,{"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "空字符串值后的尾随逗号被去掉",
+ response: `{"align":"",}`,
+ key: "align",
+ want: `{"align":""}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectStopsAtFirstCarrier 有多个顶层候选都带目标字段时取最靠前的一个,
+// 回答之后的示例对象不参与选取。
+func TestExtractJSONObjectStopsAtFirstCarrier(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "多个候选都含目标字段时取最前面的",
+ response: `{"align":[{"origin_part":"a"}]} {"align":[{"origin_part":"b"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "回答之后的示例对象不影响结果",
+ response: `{"align":[{"origin_part":"a"}]} 仅供参考:{}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectSelectionAmongCarriers 在“候选之后还有另一个候选”的输入上固定选取语义:
+// 字段值为空数组或 null 时仍然接受,不会改取后面的对象;字段名大小写不一致时不接受,
+// 会继续扫描到精确匹配的对象。
+func TestExtractJSONObjectSelectionAmongCarriers(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "字段为空数组的候选仍然优先于后面的候选",
+ response: `{"align":[]} {"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":[]}`,
+ },
+ {
+ name: "字段为 null 的候选仍然优先于后面的候选",
+ response: `{"align":null} {"align":[{"origin_part":"a"}]}`,
+ key: "align",
+ want: `{"align":null}`,
+ },
+ {
+ name: "大小写不一致的候选被跳过后取精确匹配的",
+ response: `{"Align":[{"origin_part":"a"}]} {"align":[{"origin_part":"b"}]}`,
+ key: "align",
+ want: `{"align":[{"origin_part":"b"}]}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectFenceAndWalkOrder 先去 Markdown 围栏、再按候选向后扫描,
+// 因此围栏内外的示例对象都会先变成普通文本、再被候选扫描跳过。
+func TestExtractJSONObjectFenceAndWalkOrder(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ key string
+ want string
+ }{
+ {
+ name: "围栏内的示例对象被跳过",
+ response: "```json\n{} {\"align\":[{\"origin_part\":\"a\"}]}\n```",
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "围栏之前的示例对象被跳过",
+ response: "示例:{\"note\":\"x\"}\n```json\n{\"align\":[{\"origin_part\":\"a\"}]}\n```",
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ {
+ name: "字符串里的围栏标记不影响候选边界",
+ response: "{\"note\":\"```json\"} {\"align\":[{\"origin_part\":\"a\"}]}",
+ key: "align",
+ want: `{"align":[{"origin_part":"a"}]}`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := ExtractJSONObject(tt.response, tt.key); got != tt.want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, tt.want)
+ }
+ })
+ }
+}
+
+// TestExtractJSONObjectNonASCIITrailingComma 容错只覆盖 ASCII 逗号(cutset 为 " \t\r\n,"),
+// 中文全角逗号不在其中,带全角逗号的候选仍是非法 JSON、算不命中并继续向后扫描。
+func TestExtractJSONObjectNonASCIITrailingComma(t *testing.T) {
+ const response = `{"align":[1],} {"align":[{"origin_part":"a"}]}`
+ const want = `{"align":[{"origin_part":"a"}]}`
+
+ if got := ExtractJSONObject(response, "align"); got != want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, want)
+ }
+}
+
+// TestExtractJSONObjectDuplicateTopLevelKey 顶层字段重复时仍算命中:encoding/json 解到 map
+// 时后出现的同名字段会覆盖前一个,但字段依然存在,因此应当就地返回该候选。
+func TestExtractJSONObjectDuplicateTopLevelKey(t *testing.T) {
+ const response = `{"note":"见下"} {"align":[1],"align":[2]}`
+ const want = `{"align":[1],"align":[2]}`
+
+ if got := ExtractJSONObject(response, "align"); got != want {
+ t.Errorf("ExtractJSONObject() = %q, want %q", got, want)
+ }
+}
+
+// TestExtractJSONObjectOutputIsParsable 提取结果必须能被 encoding/json 解析,且带有目标字段。
func TestExtractJSONObjectOutputIsParsable(t *testing.T) {
responses := []struct {
name string
@@ -175,12 +536,3 @@ func TestExtractJSONObjectOutputIsParsable(t *testing.T) {
})
}
}
-
-// TestCleanMarkdownCodeBlockStillStripsFences 固定 ExtractJSONObject 所依赖的代码块清理行为。
-// (control) 该行为在修复前后一致,用于证明本次改动没有影响已有的去围栏逻辑。
-func TestCleanMarkdownCodeBlockStillStripsFences(t *testing.T) {
- got := CleanMarkdownCodeBlock("```json\n{\"a\":1}\n```")
- if got != `{"a":1}` {
- t.Errorf("CleanMarkdownCodeBlock() = %q, want %q", got, `{"a":1}`)
- }
-}