Rewrited comments and testdata to eng

examples/authors/ydb/db_test.go

@@ -23,19 +23,19 @@ func TestAuthors(t *testing.T) {
 
 	t.Run("InsertAuthors", func(t *testing.T) {
 		authorsToInsert := []CreateOrUpdateAuthorParams{
-			{P0: 1, P1: "Лев Толстой", P2: ptr("Русский писатель, автор \"Война �� мир\"")},
-			{P0: 2, P1: "Александр Пушкин", P2: ptr("Автор \"Евгения Онегина\"")},
-			{P0: 3, P1: "Александр Пушкин", P2: ptr("Русский поэт, драматург и прозаик")},
-			{P0: 4, P1: "Фёдор Достоевский", P2: ptr("Автор \"Преступление и наказание\"")},
-			{P0: 5, P1: "Николай Гоголь", P2: ptr("Автор \"Мёртвые души\"")},
-			{P0: 6, P1: "Антон Чехов", P2: nil},
-			{P0: 7, P1: "Иван Тургенев", P2: ptr("Автор \"Отцы и дети\"")},
-			{P0: 8, P1: "Михаил Лермонтов", P2: nil},
-			{P0: 9, P1: "Даниил Хармс", P2: ptr("Абсурдист, писатель и поэт")},
-			{P0: 10, P1: "Максим Горький", P2: ptr("Автор \"На дне\"")},
-			{P0: 11, P1: "Владимир Маяковский", P2: nil},
-			{P0: 12, P1: "Сергей Есенин", P2: ptr("Русский лирик")},
-			{P0: 13, P1: "Борис Пастернак", P2: ptr("Автор \"Доктор Живаго\"")},
+			{P0: 1, P1: "Leo Tolstoy", P2: ptr("Russian writer, author of \"War and Peace\"")},
+			{P0: 2, P1: "Alexander Pushkin", P2: ptr("Author of \"Eugene Onegin\"")},
+			{P0: 3, P1: "Alexander Pushkin", P2: ptr("Russian poet, playwright, and prose writer")},
+			{P0: 4, P1: "Fyodor Dostoevsky", P2: ptr("Author of \"Crime and Punishment\"")},
+			{P0: 5, P1: "Nikolai Gogol", P2: ptr("Author of \"Dead Souls\"")},
+			{P0: 6, P1: "Anton Chekhov", P2: nil},
+			{P0: 7, P1: "Ivan Turgenev", P2: ptr("Author of \"Fathers and Sons\"")},
+			{P0: 8, P1: "Mikhail Lermontov", P2: nil},
+			{P0: 9, P1: "Daniil Kharms", P2: ptr("Absurdist, writer and poet")},
+			{P0: 10, P1: "Maxim Gorky", P2: ptr("Author of \"At the Bottom\"")},
+			{P0: 11, P1: "Vladimir Mayakovsky", P2: nil},
+			{P0: 12, P1: "Sergei Yesenin", P2: ptr("Russian lyric poet")},
+			{P0: 13, P1: "Boris Pasternak", P2: ptr("Author of \"Doctor Zhivago\"")},
 		}
 
 		for _, author := range authorsToInsert {
@@ -79,7 +79,7 @@ func TestAuthors(t *testing.T) {
 		var i uint64
 		for i = 1; i <= 13; i++ {
 			if err := q.DeleteAuthor(ctx, i, query.WithIdempotent()); err != nil {
-				t.Fatalf("failed to delete authors: %v", err)
+				t.Fatalf("failed to delete author: %v", err)
 			}
 		}
 		authors, err := q.ListAuthors(ctx)

internal/engine/ydb/catalog_tests/alter_group_test.go

@@ -102,10 +102,10 @@ func TestAlterGroup(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -115,7 +115,7 @@ func TestAlterGroup(t *testing.T) {
 				cmpopts.IgnoreFields(ast.A_Const{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/alter_user_test.go

@@ -28,8 +28,8 @@ func TestAlterUser(t *testing.T) {
 						Options: &ast.List{
 							Items: []ast.Node{
 								&ast.DefElem{
-									Defname: strPtr("rename"),
-									Arg:     &ast.String{Str: "queen"},
+									Defname:   strPtr("rename"),
+									Arg:       &ast.String{Str: "queen"},
 									Defaction: ast.DefElemAction(1),
 								},
 							},
@@ -133,10 +133,10 @@ func TestAlterUser(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -146,7 +146,7 @@ func TestAlterUser(t *testing.T) {
 				cmpopts.IgnoreFields(ast.A_Const{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/create_group_test.go

@@ -90,10 +90,10 @@ func TestCreateGroup(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -103,7 +103,7 @@ func TestCreateGroup(t *testing.T) {
 				cmpopts.IgnoreFields(ast.A_Const{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/create_user_test.go

@@ -110,10 +110,10 @@ func TestCreateUser(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -122,7 +122,7 @@ func TestCreateUser(t *testing.T) {
 				cmpopts.IgnoreFields(ast.DefElem{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/delete_test.go

@@ -178,10 +178,10 @@ func TestDelete(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -193,7 +193,7 @@ func TestDelete(t *testing.T) {
 				cmpopts.IgnoreFields(ast.RangeVar{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/drop_role_test.go

@@ -69,10 +69,10 @@ func TestDropRole(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Error parsing %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Statement %q was not parsed", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],

internal/engine/ydb/catalog_tests/insert_test.go

@@ -120,10 +120,10 @@ func TestInsert(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -135,7 +135,7 @@ func TestInsert(t *testing.T) {
 				cmpopts.IgnoreFields(ast.RangeVar{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/pragma_test.go

@@ -98,10 +98,10 @@ func TestPragma(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -111,7 +111,7 @@ func TestPragma(t *testing.T) {
 				cmpopts.IgnoreFields(ast.A_Const{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/select_test.go

@@ -374,10 +374,10 @@ func TestSelect(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсин��а запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -390,7 +390,7 @@ func TestSelect(t *testing.T) {
 				cmpopts.IgnoreFields(ast.RangeVar{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}

internal/engine/ydb/catalog_tests/update_test.go

@@ -163,10 +163,10 @@ func TestUpdate(t *testing.T) {
 		t.Run(tc.stmt, func(t *testing.T) {
 			stmts, err := p.Parse(strings.NewReader(tc.stmt))
 			if err != nil {
-				t.Fatalf("Ошибка парсинга запроса %q: %v", tc.stmt, err)
+				t.Fatalf("Failed to parse query %q: %v", tc.stmt, err)
 			}
 			if len(stmts) == 0 {
-				t.Fatalf("Запрос %q не распарсен", tc.stmt)
+				t.Fatalf("Query %q was not parsed", tc.stmt)
 			}
 
 			diff := cmp.Diff(tc.expected, &stmts[0],
@@ -178,7 +178,7 @@ func TestUpdate(t *testing.T) {
 				cmpopts.IgnoreFields(ast.RangeVar{}, "Location"),
 			)
 			if diff != "" {
-				t.Errorf("Несовпадение AST (-ожидалось +получено):\n%s", diff)
+				t.Errorf("AST mismatch for %q (-expected +got):\n%s", tc.stmt, diff)
 			}
 		})
 	}