MyGoNavi/internal/app/methods_db_oracle_i18n_test.go

package app

import (
	"os"
	"strings"
	"testing"

	"GoNavi-Wails/internal/connection"
	"GoNavi-Wails/shared/i18n"
)

type fakeOracleMetadataDB struct {
	rows   []map[string]interface{}
	fields []string
	err    error
}

func (db *fakeOracleMetadataDB) Connect(config connection.ConnectionConfig) error { return nil }
func (db *fakeOracleMetadataDB) Close() error                                     { return nil }
func (db *fakeOracleMetadataDB) Ping() error                                      { return nil }
func (db *fakeOracleMetadataDB) Query(query string) ([]map[string]interface{}, []string, error) {
	return db.rows, db.fields, db.err
}
func (db *fakeOracleMetadataDB) Exec(query string) (int64, error) { return 0, nil }
func (db *fakeOracleMetadataDB) GetDatabases() ([]string, error)  { return nil, nil }
func (db *fakeOracleMetadataDB) GetTables(dbName string) ([]string, error) {
	return nil, nil
}
func (db *fakeOracleMetadataDB) GetCreateStatement(dbName, tableName string) (string, error) {
	return "", nil
}
func (db *fakeOracleMetadataDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
	return nil, nil
}
func (db *fakeOracleMetadataDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
	return nil, nil
}
func (db *fakeOracleMetadataDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
	return nil, nil
}
func (db *fakeOracleMetadataDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
	return nil, nil
}
func (db *fakeOracleMetadataDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
	return nil, nil
}

func TestMethodsDBOracleMetadataMessagesUseLocalizedText(t *testing.T) {
	sourceBytes, err := os.ReadFile("methods_db.go")
	if err != nil {
		t.Fatalf("read methods_db.go: %v", err)
	}
	source := string(sourceBytes)

	checks := map[string]struct {
		rawMessages []string
		keys        []string
	}{
		"func inferOracleColumnsFromDictionary": {
			rawMessages: []string{
				`fmt.Errorf("未获取到字段定义")`,
			},
			keys: []string{
				"db.backend.error.column_definitions_missing",
			},
		},
		"func inferOracleColumnsFromEmptySelect": {
			rawMessages: []string{
				`fmt.Errorf("表名不能为空")`,
				`fmt.Errorf("未获取到字段定义")`,
			},
			keys: []string{
				"db.backend.error.table_name_required",
				"db.backend.error.column_definitions_missing",
			},
		},
	}

	for signature, check := range checks {
		functionSource := methodsDBFunctionSource(t, source, signature)
		for _, rawMessage := range check.rawMessages {
			if strings.Contains(functionSource, rawMessage) {
				t.Fatalf("%s still contains raw Oracle metadata text %q", signature, rawMessage)
			}
		}
		for _, key := range check.keys {
			if !strings.Contains(functionSource, key) {
				t.Fatalf("%s does not reference Oracle metadata i18n key %q", signature, key)
			}
		}
	}
}

func TestMethodsDBOracleMetadataCatalogKeysExist(t *testing.T) {
	catalogs, err := i18n.LoadCatalogs()
	if err != nil {
		t.Fatalf("LoadCatalogs() error = %v", err)
	}

	for _, language := range i18n.SupportedLanguages() {
		if strings.TrimSpace(catalogs[language]["db.backend.error.column_definitions_missing"]) == "" {
			t.Fatalf("%s catalog missing Oracle metadata key %q", language, "db.backend.error.column_definitions_missing")
		}
	}
}

func TestMethodsDBOracleMetadataUsesEnglishMessages(t *testing.T) {
	app := NewAppWithSecretStore(newFakeAppSecretStore())
	app.configDir = t.TempDir()
	app.SetLanguage(string(i18n.LanguageEnUS))

	t.Run("dictionary fallback missing columns", func(t *testing.T) {
		_, err := inferOracleColumnsFromDictionary(&fakeOracleMetadataDB{}, "APP", "ORDERS", app.appText)
		if err == nil {
			t.Fatal("expected inferOracleColumnsFromDictionary to fail")
		}
		if got, want := err.Error(), "No column definitions were returned"; got != want {
			t.Fatalf("expected %q, got %q", want, got)
		}
	})

	t.Run("empty select requires table name", func(t *testing.T) {
		_, err := inferOracleColumnsFromEmptySelect(&fakeOracleMetadataDB{}, "APP", " ", app.appText)
		if err == nil {
			t.Fatal("expected inferOracleColumnsFromEmptySelect to fail")
		}
		if got, want := err.Error(), "Table name is required"; got != want {
			t.Fatalf("expected %q, got %q", want, got)
		}
	})

	t.Run("empty select missing fields", func(t *testing.T) {
		_, err := inferOracleColumnsFromEmptySelect(&fakeOracleMetadataDB{}, "APP", "ORDERS", app.appText)
		if err == nil {
			t.Fatal("expected inferOracleColumnsFromEmptySelect to fail")
		}
		if got, want := err.Error(), "No column definitions were returned"; got != want {
			t.Fatalf("expected %q, got %q", want, got)
		}
	})
}