mirror of
https://github.com/Syngnat/GoNavi.git
synced 2026-07-14 00:42:17 +08:00
276 lines
10 KiB
Go
276 lines
10 KiB
Go
package app
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestValidateLocalDriverPackagePathRejectsJdbcJar(t *testing.T) {
|
|
err := validateLocalDriverPackagePath(filepath.Join("tmp", "kingbase8.JAR"))
|
|
if err == nil {
|
|
t.Fatal("expected JDBC jar path to be rejected")
|
|
}
|
|
if !strings.Contains(err.Error(), "JDBC Jar") {
|
|
t.Fatalf("expected JDBC jar hint, got %q", err.Error())
|
|
}
|
|
if err := validateLocalDriverPackagePath(filepath.Join("tmp", "kingbase-driver-agent.zip")); err != nil {
|
|
t.Fatalf("expected zip package to stay supported, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestInstallLocalDriverPackageRejectsJdbcJarBeforeBuildChecks(t *testing.T) {
|
|
jarPath := filepath.Join(t.TempDir(), "kingbase8.jar")
|
|
if err := os.WriteFile(jarPath, []byte("fake-jar"), 0o644); err != nil {
|
|
t.Fatalf("write temp jar: %v", err)
|
|
}
|
|
|
|
app := &App{}
|
|
result := app.InstallLocalDriverPackage("kingbase", jarPath, t.TempDir(), "")
|
|
if result.Success {
|
|
t.Fatal("expected local jar import to fail")
|
|
}
|
|
if !strings.Contains(result.Message, "JDBC Jar") {
|
|
t.Fatalf("expected JDBC jar guidance, got %q", result.Message)
|
|
}
|
|
}
|
|
|
|
func TestInstallLocalDriverPackageUsesCurrentLanguageForJdbcJarWrapper(t *testing.T) {
|
|
jarPath := filepath.Join(t.TempDir(), "kingbase8.jar")
|
|
if err := os.WriteFile(jarPath, []byte("fake-jar"), 0o644); err != nil {
|
|
t.Fatalf("write temp jar: %v", err)
|
|
}
|
|
|
|
app := NewApp()
|
|
app.SetLanguage("en-US")
|
|
|
|
result := app.InstallLocalDriverPackage("kingbase", jarPath, t.TempDir(), "")
|
|
if result.Success {
|
|
t.Fatal("expected local jar import to fail")
|
|
}
|
|
if !strings.Contains(result.Message, "Importing JDBC Jar files directly is not supported.") {
|
|
t.Fatalf("expected English JDBC jar guidance, got %q", result.Message)
|
|
}
|
|
if strings.Contains(result.Message, "当前驱动管理不支持直接导入 JDBC Jar") {
|
|
t.Fatalf("expected localized wrapper instead of fixed Chinese, got %q", result.Message)
|
|
}
|
|
}
|
|
|
|
func TestInstallLocalDriverPackageUsesCurrentLanguageForEmptyLocalPath(t *testing.T) {
|
|
app := NewApp()
|
|
app.SetLanguage("en-US")
|
|
|
|
result := app.InstallLocalDriverPackage("kingbase", "", t.TempDir(), "")
|
|
if result.Success {
|
|
t.Fatal("expected empty local package path to fail")
|
|
}
|
|
if !strings.Contains(result.Message, "Local driver package path is empty") {
|
|
t.Fatalf("expected English local package path message, got %q", result.Message)
|
|
}
|
|
if strings.Contains(result.Message, "本地驱动包路径为空") {
|
|
t.Fatalf("expected localized wrapper instead of fixed Chinese, got %q", result.Message)
|
|
}
|
|
}
|
|
|
|
func TestLocalDriverImportErrorsUseI18nWrappers(t *testing.T) {
|
|
source := methodsDriverSource(t)
|
|
|
|
functionNames := []string{
|
|
"(*App) InstallLocalDriverPackage",
|
|
"installOptionalDriverAgentFromLocalPath",
|
|
"resolveLocalDriverAgentFromLocalDirectory",
|
|
"installOptionalDriverAgentFromLocalZip",
|
|
"writeInstalledDriverPackage",
|
|
"hashFileSHA256",
|
|
"extractZipFileToPath",
|
|
"copyOptionalDriverSupportFilesFromDirectory",
|
|
"extractOptionalDriverSupportFilesFromZip",
|
|
}
|
|
functionSource := ""
|
|
for _, name := range functionNames {
|
|
prefix := "func " + name
|
|
if strings.HasPrefix(name, "(*App) ") {
|
|
prefix = "func (a *App) " + strings.TrimPrefix(name, "(*App) ")
|
|
}
|
|
start := strings.Index(source, prefix)
|
|
if start < 0 {
|
|
t.Fatalf("methods_driver.go missing %s", name)
|
|
}
|
|
rest := source[start+len(prefix):]
|
|
end := strings.Index(rest, "\nfunc ")
|
|
if end < 0 {
|
|
t.Fatalf("%s function boundary not found", name)
|
|
}
|
|
functionSource += rest[:end]
|
|
}
|
|
|
|
rawWrappers := []string{
|
|
`fmt.Errorf("本地驱动包路径为空")`,
|
|
`fmt.Errorf("读取本地驱动包失败：%w"`,
|
|
`fmt.Errorf("创建 %s 驱动目录失败：%w"`,
|
|
`fmt.Errorf("导入本地驱动代理失败：%w"`,
|
|
`fmt.Errorf("导入本地驱动代理运行时依赖失败：%w"`,
|
|
`fmt.Errorf("本地驱动目录路径为空")`,
|
|
`fmt.Errorf("读取本地驱动目录失败：%w"`,
|
|
`fmt.Errorf("本地驱动目录路径不是目录：%s"`,
|
|
`fmt.Errorf("本地驱动目录条目过多`,
|
|
`fmt.Errorf("扫描本地驱动目录失败：%w"`,
|
|
`"目录中未找到 %s 代理文件`,
|
|
`fmt.Errorf("打开本地驱动包失败：%w"`,
|
|
`fmt.Errorf("本地驱动包内未找到 %s 代理文件`,
|
|
`fmt.Errorf("读取本地驱动包条目失败：%w"`,
|
|
`fmt.Errorf("创建驱动代理临时文件失败：%w"`,
|
|
`fmt.Errorf("写入驱动代理失败：%w"`,
|
|
`fmt.Errorf("落盘驱动代理失败：%w"`,
|
|
`fmt.Errorf("关闭驱动代理文件失败：%w"`,
|
|
`fmt.Errorf("设置驱动代理权限失败：%w"`,
|
|
`fmt.Errorf("替换驱动代理失败：%w"`,
|
|
`fmt.Errorf("计算 %s 驱动代理摘要失败：%w"`,
|
|
`fmt.Errorf("创建驱动目录失败：%w"`,
|
|
`fmt.Errorf("写入驱动元数据失败：%w"`,
|
|
`fmt.Errorf("文件路径为空")`,
|
|
`fmt.Errorf("zip 条目为空")`,
|
|
`fmt.Errorf("运行时依赖目录为空")`,
|
|
`fmt.Errorf("复制 %s 失败：%w"`,
|
|
`fmt.Errorf("运行时依赖目标目录为空")`,
|
|
`fmt.Errorf("驱动包缺少运行时依赖：%s"`,
|
|
`fmt.Errorf("解压运行时依赖 %s 失败：%w"`,
|
|
}
|
|
for _, rawWrapper := range rawWrappers {
|
|
if strings.Contains(functionSource, rawWrapper) {
|
|
t.Fatalf("local driver import flow still contains raw error wrapper %s", rawWrapper)
|
|
}
|
|
}
|
|
|
|
requiredKeys := []string{
|
|
"driver_manager.backend.error.local_package_path_empty",
|
|
"driver_manager.backend.error.read_local_package_failed",
|
|
"driver_manager.backend.error.local_directory_path_empty",
|
|
"driver_manager.backend.error.read_local_directory_failed",
|
|
"driver_manager.backend.error.local_directory_not_directory",
|
|
"driver_manager.backend.error.local_directory_scan_limit",
|
|
"driver_manager.backend.error.scan_local_directory_failed",
|
|
"driver_manager.backend.error.local_directory_entry_missing",
|
|
"driver_manager.backend.error.open_local_package_failed",
|
|
"driver_manager.backend.error.local_package_entry_missing",
|
|
"driver_manager.backend.error.read_local_package_entry_failed",
|
|
"driver_manager.backend.error.create_agent_temp_file_failed",
|
|
"driver_manager.backend.error.write_agent_failed",
|
|
"driver_manager.backend.error.sync_agent_failed",
|
|
"driver_manager.backend.error.close_agent_file_failed",
|
|
"driver_manager.backend.error.chmod_agent_failed",
|
|
"driver_manager.backend.error.replace_agent_failed",
|
|
"driver_manager.backend.error.named_agent_hash_failed",
|
|
"driver_manager.backend.error.create_directory_failed",
|
|
"driver_manager.backend.error.metadata_payload_encode_failed",
|
|
"driver_manager.backend.error.metadata_file_write_failed",
|
|
"driver_manager.backend.error.file_path_empty",
|
|
"driver_manager.backend.error.zip_entry_empty",
|
|
"driver_manager.backend.error.runtime_dependency_directory_empty",
|
|
"driver_manager.backend.error.copy_runtime_dependency_entry_failed",
|
|
"driver_manager.backend.error.runtime_dependency_target_directory_empty",
|
|
"driver_manager.backend.error.runtime_dependency_entry_missing",
|
|
"driver_manager.backend.error.extract_runtime_dependency_failed",
|
|
}
|
|
for _, key := range requiredKeys {
|
|
if !strings.Contains(functionSource, key) {
|
|
t.Fatalf("local driver import flow does not reference i18n key %q", key)
|
|
}
|
|
}
|
|
if strings.Contains(functionSource, "normalizeErrorMessage(installErr)") {
|
|
t.Fatal("local driver import error progress should use the current App language instead of normalizeErrorMessage")
|
|
}
|
|
if strings.Contains(functionSource, "normalizeErrorMessage(err)") {
|
|
t.Fatal("local driver metadata write progress should use the current App language instead of normalizeErrorMessage")
|
|
}
|
|
if !strings.Contains(functionSource, "localizedDriverBackendErrorMessage(a, installErr)") {
|
|
t.Fatal("local driver import error progress does not localize installErr with the current App language")
|
|
}
|
|
if !strings.Contains(functionSource, "localizedDriverBackendErrorMessage(a, err)") {
|
|
t.Fatal("local driver metadata write progress does not localize err with the current App language")
|
|
}
|
|
}
|
|
|
|
func TestDriverOperationFailureDetailUsesCurrentLanguageForLogHint(t *testing.T) {
|
|
app := NewApp()
|
|
app.SetLanguage("en-US")
|
|
|
|
text := app.driverOperationErrorMessage(errors.New("boom"), "test driver error")
|
|
if !strings.Contains(text, "boom") {
|
|
t.Fatalf("expected raw detail in localized message, got %q", text)
|
|
}
|
|
if !strings.Contains(text, "detail log:") {
|
|
t.Fatalf("expected English log hint, got %q", text)
|
|
}
|
|
if strings.Contains(text, "详细日志") {
|
|
t.Fatalf("expected no Chinese log hint in en-US message, got %q", text)
|
|
}
|
|
}
|
|
|
|
func TestDriverOperationFailureDetailUsesCurrentLanguageForRuntimeDependencyWrapper(t *testing.T) {
|
|
driverType := "duckdb"
|
|
if len(optionalDriverSupportFileNames(driverType)) == 0 {
|
|
t.Skip("current platform does not require optional driver runtime dependencies")
|
|
}
|
|
|
|
app := NewApp()
|
|
app.SetLanguage("en-US")
|
|
|
|
cause := copyOptionalDriverSupportFilesFromDirectory(driverType, "", t.TempDir())
|
|
if cause == nil {
|
|
t.Fatal("expected runtime dependency copy helper to fail")
|
|
}
|
|
|
|
text := app.driverOperationErrorMessage(
|
|
newLocalizedDriverBackendError("driver_manager.backend.error.import_local_agent_runtime_failed", nil, cause),
|
|
"test local runtime dependency wrapper",
|
|
)
|
|
if !strings.Contains(text, "Failed to import local driver agent runtime dependencies:") {
|
|
t.Fatalf("expected English runtime dependency wrapper, got %q", text)
|
|
}
|
|
if !strings.Contains(text, "Runtime dependency directory is empty") {
|
|
t.Fatalf("expected English runtime dependency detail, got %q", text)
|
|
}
|
|
if strings.Contains(text, "运行时依赖目录为空") {
|
|
t.Fatalf("expected no Chinese runtime dependency detail in en-US message, got %q", text)
|
|
}
|
|
}
|
|
|
|
func TestInstallLocalDriverPackageProgressUsesLocalizedText(t *testing.T) {
|
|
source := methodsDriverSource(t)
|
|
start := strings.Index(source, "func (a *App) InstallLocalDriverPackage")
|
|
if start < 0 {
|
|
t.Fatal("methods_driver.go missing InstallLocalDriverPackage")
|
|
}
|
|
rest := source[start:]
|
|
end := strings.Index(rest, "\nfunc ")
|
|
if end < 0 {
|
|
t.Fatal("InstallLocalDriverPackage function boundary not found")
|
|
}
|
|
functionSource := rest[:end]
|
|
|
|
rawMessages := []string{
|
|
`"开始安装本地驱动包"`,
|
|
`"写入驱动元数据"`,
|
|
`"本地驱动包导入完成"`,
|
|
}
|
|
for _, rawMessage := range rawMessages {
|
|
if strings.Contains(functionSource, rawMessage) {
|
|
t.Fatalf("InstallLocalDriverPackage still contains raw progress message %s", rawMessage)
|
|
}
|
|
}
|
|
|
|
keys := []string{
|
|
"driver_manager.progress.local_package_start",
|
|
"driver_manager.progress.metadata_write",
|
|
"driver_manager.progress.local_package_done",
|
|
}
|
|
for _, key := range keys {
|
|
if !strings.Contains(functionSource, key) {
|
|
t.Fatalf("InstallLocalDriverPackage does not reference progress i18n key %q", key)
|
|
}
|
|
}
|
|
}
|