test: verify array of struct decoding using DecodeOptionProto

driver_with_mockserver_test.go

@@ -6021,3 +6021,95 @@ func filterBeginReadOnlyRequests(requests []interface{}) []*sppb.BeginTransactio
 	}
 	return res
 }
+
+func TestArrayOfStruct(t *testing.T) {
+	t.Parallel()
+
+	db, server, teardown := setupTestDBConnection(t)
+	defer teardown()
+
+	query := "SELECT ARRAY(SELECT AS STRUCT * FROM UNNEST(@entries)) AS entries"
+
+	fields := []*sppb.StructType_Field{
+		{Name: "ID", Type: &sppb.Type{Code: sppb.TypeCode_INT64}},
+		{Name: "Name", Type: &sppb.Type{Code: sppb.TypeCode_STRING}},
+	}
+	structType := &sppb.StructType{Fields: fields}
+
+	metadata := &sppb.ResultSetMetadata{
+		RowType: &sppb.StructType{
+			Fields: []*sppb.StructType_Field{
+				{
+					Name: "entries",
+					Type: &sppb.Type{
+						Code: sppb.TypeCode_ARRAY,
+						ArrayElementType: &sppb.Type{
+							Code:       sppb.TypeCode_STRUCT,
+							StructType: structType,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	struct1 := &structpb.ListValue{Values: []*structpb.Value{
+		{Kind: &structpb.Value_StringValue{StringValue: "0"}},
+		{Kind: &structpb.Value_StringValue{StringValue: "Hello"}},
+	}}
+	struct2 := &structpb.ListValue{Values: []*structpb.Value{
+		{Kind: &structpb.Value_StringValue{StringValue: "1"}},
+		{Kind: &structpb.Value_StringValue{StringValue: "World"}},
+	}}
+	arrayVal := &structpb.Value{Kind: &structpb.Value_ListValue{ListValue: &structpb.ListValue{Values: []*structpb.Value{
+		{Kind: &structpb.Value_ListValue{ListValue: struct1}},
+		{Kind: &structpb.Value_ListValue{ListValue: struct2}},
+	}}}}
+
+	resultSet := &sppb.ResultSet{
+		Metadata: metadata,
+		Rows: []*structpb.ListValue{
+			{Values: []*structpb.Value{arrayVal}},
+		},
+	}
+
+	_ = server.TestSpanner.PutStatementResult(query, &testutil.StatementResult{
+		Type:      testutil.StatementResultResultSet,
+		ResultSet: resultSet,
+	})
+
+	type Entry struct {
+		ID   int64
+		Name string
+	}
+	entries := []Entry{
+		{ID: 0, Name: "Hello"},
+		{ID: 1, Name: "World"},
+	}
+
+	ctx := context.Background()
+	rows, err := db.QueryContext(ctx, query, sql.Named("entries", entries), ExecOptions{DecodeOption: DecodeOptionProto})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+
+	if !rows.Next() {
+		t.Fatalf("expected rows.Next() to return true, got false, err: %v", rows.Err())
+	}
+	var col spanner.GenericColumnValue
+	if err := rows.Scan(&col); err != nil {
+		t.Fatalf("Scan returned error: %v", err)
+	}
+	var allEntries []*Entry
+	if err := col.Decode(&allEntries); err != nil {
+		t.Fatalf("Decode returned error: %v", err)
+	}
+	expected := []*Entry{
+		{ID: 0, Name: "Hello"},
+		{ID: 1, Name: "World"},
+	}
+	if !reflect.DeepEqual(allEntries, expected) {
+		t.Errorf("allEntries mismatch\n Got: %+v\nWant: %+v", allEntries, expected)
+	}
+}

examples/emulator_runner.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"net"
 	"os"
 	"time"
 
@@ -107,19 +108,29 @@ func startEmulator() error {
 	if err := cli.ContainerStart(ctx, containerId, container.StartOptions{}); err != nil {
 		return err
 	}
-	// Wait max 10 seconds or until the emulator is running.
-	for c := 0; c < 20; c++ {
-		// Always wait at least 500 milliseconds to ensure that the emulator is actually ready, as the
-		// state can be reported as ready, while the emulator (or network interface) is actually not ready.
-		<-time.After(500 * time.Millisecond)
+	// Wait max 10 seconds or until the emulator is running and port 9010 is open.
+	var portReady bool
+	for c := 0; c < 40; c++ {
 		resp, err := cli.ContainerInspect(ctx, containerId)
 		if err != nil {
 			return fmt.Errorf("failed to inspect container state: %v", err)
 		}
 		if resp.State.Running {
-			break
+			// Try to connect to localhost:9010
+			conn, err := net.DialTimeout("tcp", "localhost:9010", 250*time.Millisecond)
+			if err == nil {
+				_ = conn.Close()
+				portReady = true
+				break
+			}
 		}
+		<-time.After(250 * time.Millisecond)
 	}
+	if !portReady {
+		return fmt.Errorf("emulator did not start listening on port 9010 in time")
+	}
+	// Give the emulator gRPC server a moment to fully initialize after the TCP port opens.
+	<-time.After(1500 * time.Millisecond)
 
 	return nil
 }

transaction_test.go

@@ -325,9 +325,9 @@ func TestTransactionTimeout(t *testing.T) {
 	defer teardown()
 	ctx := context.Background()
 
-	server.TestSpanner.PutExecutionTime(testutil.MethodExecuteStreamingSql, testutil.SimulatedExecutionTime{MinimumExecutionTime: 50 * time.Millisecond})
+	server.TestSpanner.PutExecutionTime(testutil.MethodExecuteStreamingSql, testutil.SimulatedExecutionTime{MinimumExecutionTime: 200 * time.Millisecond})
 	tx, _ := db.BeginTx(ctx, &sql.TxOptions{})
-	if _, err := tx.ExecContext(ctx, "set local transaction_timeout=10ms"); err != nil {
+	if _, err := tx.ExecContext(ctx, "set local transaction_timeout=100ms"); err != nil {
 		t.Fatal(err)
 	}
 	_, err := tx.ExecContext(ctx, testutil.UpdateBarSetFoo)
@@ -367,14 +367,14 @@ func TestTransactionTimeoutSecondStatement(t *testing.T) {
 	ctx := context.Background()
 
 	tx, _ := db.BeginTx(ctx, &sql.TxOptions{})
-	if _, err := tx.ExecContext(ctx, "set local transaction_timeout=40ms"); err != nil {
+	if _, err := tx.ExecContext(ctx, "set local transaction_timeout=200ms"); err != nil {
 		t.Fatal(err)
 	}
 	if _, err := tx.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
 		t.Fatal(err)
 	}
 
-	server.TestSpanner.PutExecutionTime(testutil.MethodExecuteStreamingSql, testutil.SimulatedExecutionTime{MinimumExecutionTime: 60 * time.Millisecond})
+	server.TestSpanner.PutExecutionTime(testutil.MethodExecuteStreamingSql, testutil.SimulatedExecutionTime{MinimumExecutionTime: 300 * time.Millisecond})
 	rows, err := tx.QueryContext(ctx, testutil.SelectFooFromBar, ExecOptions{DirectExecuteQuery: true})
 	if rows != nil {
 		_ = rows.Close()