feat(glossary): 实现 Rust Glossary V1

2026-09-18 10:00:40 +08:00 · 2026-09-07 22:38:53 +08:00
parent 8fc93b8f39
commit 94483ff14d
42 changed files with 4543 additions and 92 deletions
@@ -637,6 +637,11 @@ type controlBackend struct {
 	translationMemorySummaryParams []backendrpc.TranslationMemorySummaryParams
 	translationMemoryQueryParams   []backendrpc.TranslationMemoryQueryParams
 	translationMemoryConfirmParams []backendrpc.TranslationMemoryConfirmParams
+	glossarySummaryParams          []backendrpc.GlossarySummaryParams
+	glossaryQueryParams            []backendrpc.GlossaryQueryParams
+	glossaryDiagnoseParams         []backendrpc.GlossaryDiagnoseParams
+	glossaryMutationParams         []backendrpc.GlossaryTermMutationParams
+	glossaryReviewParams           []backendrpc.GlossaryReviewParams
 	localizedPublishParams         []backendrpc.LocalizedPublishParams
 	localizedRollbackParams        []backendrpc.LocalizedRollbackParams
 }
@@ -825,6 +830,81 @@ func (b *controlBackend) TranslationMemoryConfirm(ctx context.Context, params ba
 	}, nil
 }

+func (b *controlBackend) GlossarySummary(ctx context.Context, params backendrpc.GlossarySummaryParams) (*backendrpc.GlossarySummaryReport, error) {
+	b.calls = append(b.calls, "translation.glossary.summary")
+	b.glossarySummaryParams = append(b.glossarySummaryParams, params)
+	schemaVersion := uint64(1)
+	return &backendrpc.GlossarySummaryReport{
+		Available:     true,
+		Path:          params.GlossaryPath,
+		SchemaVersion: &schemaVersion,
+		Summary: &backendrpc.GlossarySummary{
+			SchemaVersion: schemaVersion,
+			TermCount:     2,
+			ApprovedCount: 1,
+			DraftCount:    1,
+		},
+	}, nil
+}
+
+func (b *controlBackend) GlossaryQuery(ctx context.Context, params backendrpc.GlossaryQueryParams) (*backendrpc.GlossaryQueryReport, error) {
+	b.calls = append(b.calls, "translation.glossary.query")
+	b.glossaryQueryParams = append(b.glossaryQueryParams, params)
+	return &backendrpc.GlossaryQueryReport{
+		Available: true,
+		Path:      params.GlossaryPath,
+		Terms: []backendrpc.GlossaryTerm{{
+			TermID: "term-sensei",
+			GlossaryTermSnapshot: backendrpc.GlossaryTermSnapshot{
+				SourceTerm:             "Sensei",
+				RecommendedTranslation: "老师",
+				Priority:               10,
+			},
+			ReviewStatus: backendrpc.GlossaryStatusApproved,
+			Source: backendrpc.GlossarySourceRecord{
+				SourceKind:          "manual",
+				ObservedUnixSeconds: 100,
+			},
+		}},
+	}, nil
+}
+
+func (b *controlBackend) GlossaryDiagnose(ctx context.Context, params backendrpc.GlossaryDiagnoseParams) (*backendrpc.GlossaryDiagnoseReport, error) {
+	b.calls = append(b.calls, "translation.glossary.diagnose")
+	b.glossaryDiagnoseParams = append(b.glossaryDiagnoseParams, params)
+	return &backendrpc.GlossaryDiagnoseReport{
+		Available:  true,
+		Path:       params.GlossaryPath,
+		SourceText: params.SourceText,
+		Context:    params.Context,
+		Evaluation: json.RawMessage(`{"constraints":[],"diagnostics":[],"blocked":false}`),
+	}, nil
+}
+
+func (b *controlBackend) GlossaryAdd(ctx context.Context, params backendrpc.GlossaryTermMutationParams) (*backendrpc.GlossaryMutationReport, error) {
+	b.calls = append(b.calls, "translation.glossary.add")
+	b.glossaryMutationParams = append(b.glossaryMutationParams, params)
+	return &backendrpc.GlossaryMutationReport{Available: true, Path: params.GlossaryPath}, nil
+}
+
+func (b *controlBackend) GlossaryUpdate(ctx context.Context, params backendrpc.GlossaryTermMutationParams) (*backendrpc.GlossaryMutationReport, error) {
+	b.calls = append(b.calls, "translation.glossary.update")
+	b.glossaryMutationParams = append(b.glossaryMutationParams, params)
+	return &backendrpc.GlossaryMutationReport{Available: true, Path: params.GlossaryPath}, nil
+}
+
+func (b *controlBackend) GlossaryApprove(ctx context.Context, params backendrpc.GlossaryReviewParams) (*backendrpc.GlossaryMutationReport, error) {
+	b.calls = append(b.calls, "translation.glossary.approve")
+	b.glossaryReviewParams = append(b.glossaryReviewParams, params)
+	return &backendrpc.GlossaryMutationReport{Available: true, Path: params.GlossaryPath}, nil
+}
+
+func (b *controlBackend) GlossaryDeprecate(ctx context.Context, params backendrpc.GlossaryReviewParams) (*backendrpc.GlossaryMutationReport, error) {
+	b.calls = append(b.calls, "translation.glossary.deprecate")
+	b.glossaryReviewParams = append(b.glossaryReviewParams, params)
+	return &backendrpc.GlossaryMutationReport{Available: true, Path: params.GlossaryPath}, nil
+}
+
 func (b *controlBackend) LocalizedStatus(ctx context.Context) (json.RawMessage, error) {
 	b.calls = append(b.calls, "localized.status")
 	return json.RawMessage(`{"localized_release_status":"localized","status_code":"localized.published"}`), nil
@@ -1044,6 +1124,48 @@ func TestAdminTranslationQueryEndpointsProxyAuthenticatedRequests(t *testing.T)
 		t.Fatalf("missing TM query source status=%d body=%s", recorder.Code, recorder.Body.String())
 	}

+	request = httptest.NewRequest(http.MethodGet, "/admin/translation/glossary/summary?glossary_path=%2Fvar%2Flib%2Fbat%2Fglossary.sqlite", nil)
+	request.Header.Set("Authorization", "Bearer translation-token")
+	recorder = httptest.NewRecorder()
+	s.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusOK ||
+		!strings.Contains(recorder.Body.String(), `"approved_count":1`) ||
+		len(backend.glossarySummaryParams) != 1 ||
+		backend.glossarySummaryParams[0].GlossaryPath != "/var/lib/bat/glossary.sqlite" {
+		t.Fatalf("Glossary summary status=%d body=%s params=%#v", recorder.Code, recorder.Body.String(), backend.glossarySummaryParams)
+	}
+
+	request = httptest.NewRequest(http.MethodGet, "/admin/translation/glossary/query?source_text=Sensei&limit=20", nil)
+	request.Header.Set("Authorization", "Bearer translation-token")
+	recorder = httptest.NewRecorder()
+	s.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusOK ||
+		len(backend.glossaryQueryParams) != 1 ||
+		backend.glossaryQueryParams[0].SourceText != "Sensei" ||
+		backend.glossaryQueryParams[0].Limit == nil ||
+		*backend.glossaryQueryParams[0].Limit != 20 {
+		t.Fatalf("Glossary query status=%d body=%s params=%#v", recorder.Code, recorder.Body.String(), backend.glossaryQueryParams)
+	}
+
+	request = httptest.NewRequest(http.MethodGet, "/admin/translation/glossary/diagnose?source_text=Sensei&context=%7B%22destination%22%3A%22Bundle%2Fdialogue.bundle%22%7D", nil)
+	request.Header.Set("Authorization", "Bearer translation-token")
+	recorder = httptest.NewRecorder()
+	s.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusOK ||
+		len(backend.glossaryDiagnoseParams) != 1 ||
+		backend.glossaryDiagnoseParams[0].SourceText != "Sensei" ||
+		backend.glossaryDiagnoseParams[0].Context["destination"] != "Bundle/dialogue.bundle" {
+		t.Fatalf("Glossary diagnose status=%d body=%s params=%#v", recorder.Code, recorder.Body.String(), backend.glossaryDiagnoseParams)
+	}
+
+	request = httptest.NewRequest(http.MethodGet, "/admin/translation/glossary/diagnose", nil)
+	request.Header.Set("Authorization", "Bearer translation-token")
+	recorder = httptest.NewRecorder()
+	s.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusBadRequest {
+		t.Fatalf("missing Glossary diagnose source status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+
 	request = httptest.NewRequest(http.MethodGet, "/admin/translation/tasks?limit=0", nil)
 	request.Header.Set("Authorization", "Bearer translation-token")
 	recorder = httptest.NewRecorder()
@@ -1818,6 +1940,10 @@ func TestAdminControlForwardsAllowlistedActions(t *testing.T) {
 		{name: "translation worker run", action: "translation-worker-run", body: `{"provider":"mock","concurrency":8,"max_tasks":2,"retry_backoff_seconds":0,"worker_id":"dashboard-worker"}`, rpcMethod: "translation.worker.run", call: "translation.worker.run"},
 		{name: "translation proofread", action: "translation-proofread", rpcMethod: "translation.proofread", call: "translation.proofread"},
 		{name: "translation memory confirm", action: "translation-memory-confirm", body: `{"record_id":"tm-record-1","reviewer":"reviewer","reason":"reviewed"}`, rpcMethod: "translation.memory.confirm", call: "translation.memory.confirm"},
+		{name: "translation glossary add", action: "translation-glossary-add", body: `{"term_id":"term-sensei","source_term":"Sensei","recommended_translation":"老师","review_status":"draft","source":{"source_kind":"manual","observed_unix_seconds":100}}`, rpcMethod: "translation.glossary.add", call: "translation.glossary.add"},
+		{name: "translation glossary update", action: "translation-glossary-update", body: `{"term_id":"term-sensei","source_term":"Sensei","recommended_translation":"老师","review_status":"draft","reviewer":"reviewer","source":{"source_kind":"manual","observed_unix_seconds":100}}`, rpcMethod: "translation.glossary.update", call: "translation.glossary.update"},
+		{name: "translation glossary approve", action: "translation-glossary-approve", body: `{"term_id":"term-sensei","reviewer":"reviewer","reason":"approved"}`, rpcMethod: "translation.glossary.approve", call: "translation.glossary.approve"},
+		{name: "translation glossary deprecate", action: "translation-glossary-deprecate", body: `{"term_id":"term-sensei","reviewer":"reviewer","reason":"retired"}`, rpcMethod: "translation.glossary.deprecate", call: "translation.glossary.deprecate"},
 		{name: "localized publish", action: "localized-publish", body: `{"from_worker":true,"localized_release_id":"localized-1","force":true}`, rpcMethod: "localized.publish", call: "localized.publish"},
 		{name: "localized rollback", action: "localized-rollback", body: `{"localized_release_id":"localized-1"}`, rpcMethod: "localized.rollback", call: "localized.rollback"},
 	}
@@ -1854,6 +1980,13 @@ func TestAdminControlForwardsAllowlistedActions(t *testing.T) {
 		backend.translationMemoryConfirmParams[0].Reviewer != "reviewer" {
 		t.Fatalf("TM confirm params=%#v", backend.translationMemoryConfirmParams)
 	}
+	if len(backend.glossaryMutationParams) != 2 ||
+		backend.glossaryMutationParams[0].TermID != "term-sensei" ||
+		backend.glossaryMutationParams[1].Reviewer != "reviewer" ||
+		len(backend.glossaryReviewParams) != 2 ||
+		backend.glossaryReviewParams[0].TermID != "term-sensei" {
+		t.Fatalf("Glossary params mutation=%#v review=%#v", backend.glossaryMutationParams, backend.glossaryReviewParams)
+	}

 	request := httptest.NewRequest(http.MethodPost, "/admin/control/translation-task-update", strings.NewReader(`{"task_id":""}`))
 	request.Header.Set("Authorization", "Bearer control-token")