Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

22.4 KB
Raw Blame
package mysql

import (
	"bytes"
	"context"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/x509"
	"crypto/x509/pkix"
	"database/sql"
	"encoding/json"
	"encoding/pem"
	"math/big"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"cloud.google.com/go/cloudsqlconn"
	"github.com/go-sql-driver/mysql"
	"github.com/stretchr/testify/require"

	"github.com/bytebase/bytebase/backend/common"
	"github.com/bytebase/bytebase/backend/common/testcontainer"
	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
	v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
	"github.com/bytebase/bytebase/backend/plugin/db"
	"github.com/bytebase/bytebase/backend/plugin/db/util"
)

func TestValidateMySQLExtraConnectionParameters(t *testing.T) {
	tests := []struct {
		name      string
		params    map[string]string
		wantError bool
	}{
		{
			name:      "empty parameters",
			params:    map[string]string{},
			wantError: false,
		},
		{
			name: "safe parameters",
			params: map[string]string{
				"timeout":      "10s",
				"readTimeout":  "30s",
				"writeTimeout": "30s",
			},
			wantError: false,
		},
		{
			name: "dangerous parameter - allowAllFiles",
			params: map[string]string{
				"allowAllFiles": "true",
			},
			wantError: true,
		},
		{
			name: "dangerous parameter - allowAllFiles lowercase",
			params: map[string]string{
				"allowallfiles": "true",
			},
			wantError: true,
		},
		{
			name: "dangerous parameter - allowAllFiles with mixed case",
			params: map[string]string{
				"AllowAllFiles": "true",
			},
			wantError: true,
		},
		{
			name: "mixed safe and dangerous parameters",
			params: map[string]string{
				"timeout":       "10s",
				"allowAllFiles": "true",
			},
			wantError: true,
		},
		{
			name: "parameter with whitespace",
			params: map[string]string{
				"  allowAllFiles  ": "true",
			},
			wantError: true,
		},
	}

	a := require.New(t)
	for _, tc := range tests {
		t.Run(tc.name, func(_ *testing.T) {
			err := validateMySQLExtraConnectionParameters(tc.params)
			if tc.wantError {
				a.Error(err, "expected error for test case: %s", tc.name)
			} else {
				a.NoError(err, "expected no error for test case: %s", tc.name)
			}
		})
	}
}

func TestParseVersion(t *testing.T) {
	tests := []struct {
		version  string
		want     string
		wantRest string
	}{
		{
			version:  "8.0.27",
			want:     "8.0.27",
			wantRest: "",
		},
		{
			version:  "5.7.22-log",
			want:     "5.7.22",
			wantRest: "-log",
		},
		{
			version:  "5.6.29_ddm_3.0.1.7",
			want:     "5.6.29",
			wantRest: "_ddm_3.0.1.7",
		},
		{
			version:  "10.4.7-MariaDB",
			want:     "10.4.7",
			wantRest: "-MariaDB",
		},
	}

	a := require.New(t)
	for _, tc := range tests {
		version, rest, err := parseVersion(tc.version)
		a.NoError(err)
		a.Equal(tc.want, version)
		a.Equal(tc.wantRest, rest)
	}
}

func TestBuildExecuteCommandsNormalizesDelimiter(t *testing.T) {
	statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n  SELECT 1;\nEND//\nDELIMITER ;\n"

	commands, err := buildExecuteCommands(statement)
	require.NoError(t, err)
	require.Len(t, commands, 1)
	require.NotContains(t, commands[0].Text, "DELIMITER")
	require.Contains(t, commands[0].Text, "CREATE PROCEDURE p()\nBEGIN\n  SELECT 1;\nEND")
}

func TestBuildExecuteCommandsDoesNotNormalizeDelimiterForTooManyCommands(t *testing.T) {
	var statement strings.Builder
	statement.WriteString("DELIMITER //\n")
	statement.WriteString("CREATE PROCEDURE p()\nBEGIN\n  SELECT 1;\nEND//\n")
	statement.WriteString("DELIMITER ;\n")
	statement.WriteString("/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE */;\n")
	for i := 0; i < common.MaximumCommands; i++ {
		statement.WriteString("SELECT 1;\n")
	}

	commands, err := buildExecuteCommands(statement.String())
	require.NoError(t, err)
	require.Len(t, commands, 1)
	require.Equal(t, statement.String(), commands[0].Text)
}

func TestBuildExecuteCommandsDoesNotNormalizeDelimiterForLargeSheet(t *testing.T) {
	statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n  SELECT 1;\nEND//\nDELIMITER ;\n" +
		strings.Repeat(" ", common.MaxSheetCheckSize)

	commands, err := buildExecuteCommands(statement)
	require.NoError(t, err)
	require.Len(t, commands, 1)
	require.Equal(t, statement, commands[0].Text)
}

// selfSignedCAPEM builds a throwaway CA so the tests can assert that a supplied
// ssl_ca is parsed and that a served bundle is cached, without shipping a
// certificate that eventually expires.
func selfSignedCAPEM(t *testing.T) string {
	t.Helper()
	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	require.NoError(t, err)
	template := &x509.Certificate{
		SerialNumber:          big.NewInt(1),
		Subject:               pkix.Name{CommonName: "bytebase-test-ca"},
		NotBefore:             time.Now().Add(-time.Hour),
		NotAfter:              time.Now().Add(time.Hour),
		IsCA:                  true,
		BasicConstraintsValid: true,
		KeyUsage:              x509.KeyUsageCertSign,
	}
	der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
	require.NoError(t, err)
	return string(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}))
}

// serveRDSCertBundle points rdsCertBundleURL at a local server and returns the
// request counter, so a test can assert that no download happened at all.
func serveRDSCertBundle(t *testing.T, handler http.HandlerFunc) *atomic.Int32 {
	t.Helper()
	var requests atomic.Int32
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		requests.Add(1)
		handler(w, r)
	}))
	t.Cleanup(server.Close)

	previousURL := rdsCertBundleURL
	rdsCertBundleURL = server.URL
	rdsCertPool.Store(nil)
	t.Cleanup(func() {
		rdsCertBundleURL = previousURL
		rdsCertPool.Store(nil)
	})
	return &requests
}

func TestRDSTLSConfigSkipsDownloadWhenVerificationDisabled(t *testing.T) {
	ca := selfSignedCAPEM(t)
	requests := serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		_, _ = w.Write([]byte(ca))
	})

	cfg, err := rdsTLSConfig(context.Background(), &storepb.DataSource{
		Host:                 "db.example.com",
		VerifyTlsCertificate: false,
	})
	require.NoError(t, err)
	require.True(t, cfg.InsecureSkipVerify)
	require.Nil(t, cfg.RootCAs)
	require.Nil(t, cfg.VerifyPeerCertificate)
	require.Equal(t, int32(0), requests.Load())
}

func TestRDSTLSConfigSkipsDownloadWhenSslCaConfigured(t *testing.T) {
	ca := selfSignedCAPEM(t)
	requests := serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		_, _ = w.Write([]byte(ca))
	})

	cfg, err := rdsTLSConfig(context.Background(), &storepb.DataSource{
		Host:                 "db.example.com",
		VerifyTlsCertificate: true,
		SslCa:                ca,
	})
	require.NoError(t, err)
	require.NotNil(t, cfg.RootCAs)
	require.NotNil(t, cfg.VerifyPeerCertificate)
	require.Equal(t, int32(0), requests.Load())
}

func TestRDSTLSConfigDownloadsBundleOnlyOnce(t *testing.T) {
	ca := selfSignedCAPEM(t)
	requests := serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		_, _ = w.Write([]byte(ca))
	})

	dataSource := &storepb.DataSource{Host: "db.example.com", VerifyTlsCertificate: true}
	for range 5 {
		cfg, err := rdsTLSConfig(context.Background(), dataSource)
		require.NoError(t, err)
		require.NotNil(t, cfg.RootCAs)
	}
	require.Equal(t, int32(1), requests.Load())
}

func TestRDSCertPoolDoesNotCacheFailures(t *testing.T) {
	ca := selfSignedCAPEM(t)
	var fail atomic.Bool
	fail.Store(true)
	requests := serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		if fail.Load() {
			w.WriteHeader(http.StatusServiceUnavailable)
			return
		}
		_, _ = w.Write([]byte(ca))
	})

	_, err := cachedRDSCertPool(context.Background())
	require.Error(t, err)

	fail.Store(false)
	pool, err := cachedRDSCertPool(context.Background())
	require.NoError(t, err)
	require.NotNil(t, pool)
	require.Equal(t, int32(2), requests.Load())
}

func TestRDSCertPoolReportsHTTPStatus(t *testing.T) {
	serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusForbidden)
		_, _ = w.Write([]byte("<Error>AccessDenied</Error>"))
	})

	_, err := getRDSCertPool(context.Background())
	require.ErrorContains(t, err, "403")
}

func TestRDSRootCAsRejectsUnparseableSslCa(t *testing.T) {
	_, err := rdsRootCAs(context.Background(), &storepb.DataSource{SslCa: "not a certificate"})
	require.ErrorContains(t, err, "ssl_ca")
}

func TestRDSCertPoolRejectsOversizedResponse(t *testing.T) {
	serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		_, _ = w.Write(bytes.Repeat([]byte("x"), int(maxRDSCertBundleSize)+1024))
	})
	_, err := getRDSCertPool(context.Background())
	require.Error(t, err)
	require.Contains(t, err.Error(), "exceeds")
}

func TestCreateCertificateVerifierValidatesChainAndHostname(t *testing.T) {
	rootKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	require.NoError(t, err)
	rootTemplate := &x509.Certificate{
		SerialNumber:          big.NewInt(1),
		Subject:               pkix.Name{CommonName: "bytebase-test-root"},
		NotBefore:             time.Now().Add(-time.Hour),
		NotAfter:              time.Now().Add(time.Hour),
		IsCA:                  true,
		BasicConstraintsValid: true,
		KeyUsage:              x509.KeyUsageCertSign,
	}
	rootDER, err := x509.CreateCertificate(rand.Reader, rootTemplate, rootTemplate, &rootKey.PublicKey, rootKey)
	require.NoError(t, err)
	rootCert, err := x509.ParseCertificate(rootDER)
	require.NoError(t, err)
	rootPool := x509.NewCertPool()
	rootPool.AddCert(rootCert)

	foreignKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	require.NoError(t, err)
	foreignTemplate := &x509.Certificate{
		SerialNumber:          big.NewInt(2),
		Subject:               pkix.Name{CommonName: "bytebase-test-foreign-root"},
		NotBefore:             time.Now().Add(-time.Hour),
		NotAfter:              time.Now().Add(time.Hour),
		IsCA:                  true,
		BasicConstraintsValid: true,
		KeyUsage:              x509.KeyUsageCertSign,
	}
	foreignDER, err := x509.CreateCertificate(rand.Reader, foreignTemplate, foreignTemplate, &foreignKey.PublicKey, foreignKey)
	require.NoError(t, err)
	foreignCert, err := x509.ParseCertificate(foreignDER)
	require.NoError(t, err)

	// leafFor returns a DER-encoded leaf signed by parent, valid for dnsName.
	leafFor := func(parent *x509.Certificate, parentKey *ecdsa.PrivateKey, dnsName string) []byte {
		leafKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
		require.NoError(t, err)
		leaf := &x509.Certificate{
			SerialNumber: big.NewInt(100),
			Subject:      pkix.Name{CommonName: dnsName},
			NotBefore:    time.Now().Add(-time.Hour),
			NotAfter:     time.Now().Add(time.Hour),
			KeyUsage:     x509.KeyUsageDigitalSignature,
			ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
			DNSNames:     []string{dnsName},
		}
		der, err := x509.CreateCertificate(rand.Reader, leaf, parent, &leafKey.PublicKey, parentKey)
		require.NoError(t, err)
		return der
	}

	const host = "db.example.com"
	verifier := util.CreateCertificateVerifier(rootPool, host)

	require.NoError(t, verifier([][]byte{leafFor(rootCert, rootKey, host)}, nil))
	require.Error(t, verifier([][]byte{leafFor(rootCert, rootKey, "other.example.com")}, nil))
	require.Error(t, verifier([][]byte{leafFor(foreignCert, foreignKey, host)}, nil))
}

func TestRDSCertPoolCollapsesConcurrentDownloads(t *testing.T) {
	const callers = 32
	ca := selfSignedCAPEM(t)
	// release blocks the first response until every caller is inside the fetch,
	// so a per-caller download cannot pass by finishing before the others start.
	release := make(chan struct{})
	requests := serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		<-release
		_, _ = w.Write([]byte(ca))
	})

	dataSource := &storepb.DataSource{Host: "db.example.com", VerifyTlsCertificate: true}
	var ready, done sync.WaitGroup
	ready.Add(callers)
	done.Add(callers)
	pools := make([]*x509.CertPool, callers)
	errs := make([]error, callers)
	for i := range callers {
		go func() {
			defer done.Done()
			ready.Done()
			cfg, err := rdsTLSConfig(context.Background(), dataSource)
			errs[i] = err
			if err == nil {
				pools[i] = cfg.RootCAs
			}
		}()
	}
	ready.Wait()
	close(release)
	done.Wait()

	for i := range callers {
		require.NoError(t, errs[i])
		require.NotNil(t, pools[i])
		require.Same(t, pools[0], pools[i])
	}
	require.Equal(t, int32(1), requests.Load())
}

func TestRDSCertPoolWaiterObservesItsOwnCancellation(t *testing.T) {
	ca := selfSignedCAPEM(t)
	release := make(chan struct{})
	inFlight := make(chan struct{}, 1)
	var leader sync.WaitGroup
	// Registered before serveRDSCertBundle, so it runs last: the leader must finish
	// before the helper resets rdsCertPool, or it re-stores this test's pool
	// afterwards and a later cache test never contacts its own server.
	t.Cleanup(leader.Wait)
	serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		inFlight <- struct{}{}
		<-release
		_, _ = w.Write([]byte(ca))
	})
	// Registered after serveRDSCertBundle so this runs before its server.Close,
	// which would otherwise wait forever on the blocked handler.
	t.Cleanup(func() { close(release) })

	dataSource := &storepb.DataSource{Host: "db.example.com", VerifyTlsCertificate: true}
	// Leader occupies the flight and stays blocked in the handler.
	leader.Add(1)
	go func() {
		defer leader.Done()
		_, _ = cachedRDSCertPool(context.Background())
	}()
	<-inFlight

	// The waiter joins the in-flight download, then gives up on its own context.
	ctx, cancel := context.WithCancel(context.Background())
	waiterDone := make(chan error, 1)
	leader.Add(1)
	go func() {
		defer leader.Done()
		_, err := rdsTLSConfig(ctx, dataSource)
		waiterDone <- err
	}()
	cancel()

	select {
	case err := <-waiterDone:
		require.ErrorIs(t, err, context.Canceled)
	case <-time.After(5 * time.Second):
		require.Fail(t, "canceled waiter blocked on the shared download")
	}
}

func TestRDSCertPoolLeaderCancellationDoesNotFailWaiter(t *testing.T) {
	ca := selfSignedCAPEM(t)
	release := make(chan struct{})
	inFlight := make(chan struct{}, 1)
	var leader sync.WaitGroup
	// See the note in TestRDSCertPoolWaiterObservesItsOwnCancellation: this runs
	// last, so no background store lands after the cache reset.
	t.Cleanup(leader.Wait)
	serveRDSCertBundle(t, func(w http.ResponseWriter, _ *http.Request) {
		inFlight <- struct{}{}
		<-release
		_, _ = w.Write([]byte(ca))
	})

	leaderCtx, cancelLeader := context.WithCancel(context.Background())
	leader.Add(1)
	go func() {
		defer leader.Done()
		_, _ = cachedRDSCertPool(leaderCtx)
	}()
	<-inFlight

	// A second caller with a live context is waiting on the same flight.
	waiterDone := make(chan error, 1)
	leader.Add(1)
	go func() {
		defer leader.Done()
		_, err := cachedRDSCertPool(context.Background())
		waiterDone <- err
	}()

	// The leader walks away; the shared fetch must still complete for the waiter.
	cancelLeader()
	close(release)

	select {
	case err := <-waiterDone:
		require.NoError(t, err)
	case <-time.After(5 * time.Second):
		require.Fail(t, "waiter never completed after leader cancellation")
	}
}

// TestQueryConnExplainJSON pins the structured plan the query-plan viewer draws,
// on the oldest MariaDB release Bytebase supports as well as the newest, since
// FORMAT=JSON is the one plan format they share and a plan the viewer cannot
// read loses the picture silently rather than failing.
func TestQueryConnExplainJSON(t *testing.T) {
	t.Parallel()
	for _, tc := range []struct {
		version     string
		newDatabase func(testing.TB) (*testcontainer.Container, string)
	}{
		{version: "11.8", newDatabase: testcontainer.NewMariaDBDatabase},
		{version: "10.7", newDatabase: testcontainer.NewMariaDB107Database},
	} {
		t.Run(tc.version, func(t *testing.T) {
			t.Parallel()
			ctx := context.Background()
			container, database := tc.newDatabase(t)
			driver := openTestDriver(ctx, t, storepb.Engine_MARIADB, container, container.GetUsername(), container.GetPassword(), database)
			_, err := driver.db.ExecContext(ctx, "CREATE TABLE plan_target (id INT PRIMARY KEY, note VARCHAR(64))")
			require.NoError(t, err)

			conn, err := driver.GetDB().Conn(ctx)
			require.NoError(t, err)
			defer conn.Close()

			const statement = "SELECT note FROM plan_target WHERE id > 100"
			explain := func(s string, option *v1pb.QueryOption, asExplain bool) *v1pb.QueryResult {
				results, err := driver.QueryConn(ctx, conn, s, db.QueryContext{
					Explain:              asExplain,
					Limit:                5000,
					MaximumSQLResultSize: 1 << 30,
					Option:               option,
				})
				require.NoError(t, err)
				require.Len(t, results, 1)
				require.Empty(t, results[0].GetError())
				return results[0]
			}

			jsonOption := &v1pb.QueryOption{ExplainFormat: v1pb.QueryOption_JSON}
			plan := explain(statement, jsonOption, true)
			require.Equal(t, "EXPLAIN FORMAT=JSON "+statement, plan.GetStatement())
			require.Equal(t, "query_block", planRoot(t, plan))

			// The default plan stays the table MariaDB has always returned.
			text := explain(statement, nil, true)
			require.Equal(t, "EXPLAIN "+statement, text.GetStatement())
			require.Greater(t, len(text.GetColumnNames()), 1)

			// A caller's own EXPLAIN is replanned in the format asked for rather
			// than wrapped in a second one, which would not parse.
			typed := explain("EXPLAIN FORMAT=JSON "+statement, jsonOption, true)
			require.Equal(t, "EXPLAIN FORMAT=JSON "+statement, typed.GetStatement())
			require.Equal(t, "query_block", planRoot(t, typed))

			// Run on that same statement reports the plan it returned, so the
			// viewer draws it without explaining a second time.
			ran := explain("EXPLAIN FORMAT=JSON "+statement, nil, false)
			require.Equal(t, v1pb.QueryOption_JSON, ran.GetQueryPlan().GetFormat())
			require.False(t, ran.GetQueryPlan().GetExecuted())
			require.Equal(t, "query_block", planRoot(t, ran))

			// A plain EXPLAIN says nothing about its format: from MySQL 8.0.32 an
			// omitted FORMAT follows the session's explain_format.
			ranText := explain("EXPLAIN "+statement, nil, false)
			require.Equal(t, v1pb.QueryOption_EXPLAIN_FORMAT_UNSPECIFIED, ranText.GetQueryPlan().GetFormat())
			require.NotNil(t, ranText.GetQueryPlan())
		})
	}
}

// planRoot returns the one key at the top of a one-column JSON plan.
func planRoot(t *testing.T, result *v1pb.QueryResult) string {
	t.Helper()
	require.Len(t, result.GetColumnNames(), 1)
	require.Len(t, result.GetRows(), 1)
	require.Len(t, result.GetRows()[0].GetValues(), 1)
	var plan map[string]json.RawMessage
	require.NoError(t, json.Unmarshal([]byte(result.GetRows()[0].GetValues()[0].GetStringValue()), &plan))
	require.Len(t, plan, 1)
	for key := range plan {
		return key
	}
	return ""
}

// cloudSQLIAMConnectionConfig returns a Google Cloud SQL IAM data source that
// cloudsqlconn accepts offline. The credential is an authorized_user document so
// that building the connector needs neither a key nor a network round trip; it
// is never good enough to dial with.
const cloudSQLTestInstance = "example-project:us-central1:example-instance"

func cloudSQLIAMConnectionConfig(instance string) db.ConnectionConfig {
	return db.ConnectionConfig{
		DataSource: &storepb.DataSource{
			Type:               storepb.DataSourceType_ADMIN,
			Host:               instance,
			Username:           "[email protected]",
			AuthenticationType: storepb.DataSource_GOOGLE_CLOUD_SQL_IAM,
			IamExtension: &storepb.DataSource_GcpCredential{
				GcpCredential: &storepb.DataSource_GCPCredential{
					Content: `{"type":"authorized_user","client_id":"not-a-real-client","client_secret":"not-a-real-secret","refresh_token":"not-a-real-token"}`,
				},
			},
		},
		ConnectionContext: db.ConnectionContext{DatabaseName: "example"},
	}
}

func TestCloudSQLIAMDialerClosesWithDriver(t *testing.T) {
	ctx := context.Background()

	driver := &Driver{}
	opened, err := driver.Open(ctx, storepb.Engine_MYSQL, cloudSQLIAMConnectionConfig(cloudSQLTestInstance))
	require.NoError(t, err)
	require.Same(t, driver, opened)
	require.NotNil(t, driver.cloudSQLDialer)
	require.NotEmpty(t, driver.cloudSQLProtocol)

	dialer := driver.cloudSQLDialer
	require.NoError(t, driver.Close(ctx))

	// The connector keeps refreshing its ephemeral certificate until it is
	// closed, so a driver that leaves it open leaks it for the life of the
	// process, once per connection opened.
	_, err = dialer.Dial(ctx, cloudSQLTestInstance)
	require.ErrorIs(t, err, cloudsqlconn.ErrDialerClosed)
}

func TestCloudSQLIAMDialerClosesWhenOpenFails(t *testing.T) {
	ctx := context.Background()

	config := cloudSQLIAMConnectionConfig(cloudSQLTestInstance)
	// A database name that does not survive the DSN fails Open after the
	// connector has been built.
	config.ConnectionContext.DatabaseName = "example/db"

	driver := &Driver{}
	_, err := driver.Open(ctx, storepb.Engine_MYSQL, config)
	require.Error(t, err)

	// A driver whose Open fails is discarded without a Close, so Open has to have
	// closed the connector itself.
	require.NotNil(t, driver.cloudSQLDialer)
	_, err = driver.cloudSQLDialer.Dial(ctx, cloudSQLTestInstance)
	require.ErrorIs(t, err, cloudsqlconn.ErrDialerClosed)
}

func TestCloudSQLIAMNetworkNameIsPerDriver(t *testing.T) {
	ctx := context.Background()

	first := &Driver{}
	firstDSN, err := first.getCloudSQLConnection(ctx, cloudSQLIAMConnectionConfig("example-project:us-central1:first"))
	require.NoError(t, err)
	defer func() { require.NoError(t, first.closeCloudSQL()) }()

	second := &Driver{}
	secondDSN, err := second.getCloudSQLConnection(ctx, cloudSQLIAMConnectionConfig("example-project:us-central1:second"))
	require.NoError(t, err)
	defer func() { require.NoError(t, second.closeCloudSQL()) }()

	// The network name keys a process-wide registry. Sharing one name let the
	// second driver take over the first driver's pool and dial its own instance.
	require.NotEqual(t, first.cloudSQLProtocol, second.cloudSQLProtocol)

	firstConfig, err := mysql.ParseDSN(firstDSN)
	require.NoError(t, err)
	require.Equal(t, first.cloudSQLProtocol, firstConfig.Net)

	secondConfig, err := mysql.ParseDSN(secondDSN)
	require.NoError(t, err)
	require.Equal(t, second.cloudSQLProtocol, secondConfig.Net)
}

func TestCloudSQLIAMNetworkNameDeregisteredOnClose(t *testing.T) {
	ctx := context.Background()

	driver := &Driver{}
	dsn, err := driver.getCloudSQLConnection(ctx, cloudSQLIAMConnectionConfig(cloudSQLTestInstance))
	require.NoError(t, err)
	require.NoError(t, driver.closeCloudSQL())

	// The registration would otherwise pin the closed connector in the MySQL
	// driver's process-wide map, one entry per driver ever opened.
	pool, err := sql.Open("mysql", dsn)
	require.NoError(t, err)
	defer pool.Close()
	err = pool.PingContext(ctx)
	require.Error(t, err)
	require.NotErrorIs(t, err, cloudsqlconn.ErrDialerClosed)
}