Allow multiple matches and regexps in pqtest.ErrorContains()

This makes it a bit easier to test against different servers that return
different messages.

Author: arp242

connector_test.go

@@ -115,20 +115,17 @@ func TestNewConnector(t *testing.T) {
 	})
 
 	t.Run("database=", func(t *testing.T) {
-		want1, want2 := `pq: database "err" does not exist (3D000)`,
-			`pq: database "two" does not exist (3D000)`
-		if pqtest.Pgbouncer() {
-			want1, want2 = `pq: no such database: err (08P01)`, `pq: no such database: two (08P01)`
-		}
+		want1, want2 := `or:pq: database "err" does not exist (3D000)|pq: no such database: err (08P01)`,
+			`or:pq: database "two" does not exist (3D000)|pq: no such database: two (08P01)`
 
 		// Make sure database= consistently take precedence over dbname=
 		for i := 0; i < 10; i++ {
 			_, err := pqtest.DB(t, "database=err")
-			if err == nil || err.Error() != want1 {
+			if !pqtest.ErrorContains(err, want1) {
 				t.Errorf("wrong error:\nhave: %s\nwant: %s", err, want1)
 			}
 			_, err = pqtest.DB(t, "dbname=one database=two")
-			if err == nil || err.Error() != want2 {
+			if !pqtest.ErrorContains(err, want2) {
 				t.Errorf("wrong error:\nhave: %s\nwant: %s", err, want2)
 			}
 		}
@@ -198,7 +195,7 @@ func TestRuntimeParameters(t *testing.T) {
 		wantErr       string
 		skipPgbouncer bool
 	}{
-		{"DOESNOTEXIST=foo", "", "", "unrecognized configuration parameter", false},
+		{"DOESNOTEXIST=foo", "", "", `or:unrecognized configuration parameter|unsupported startup parameter`, false},
 
 		// we can only work with a specific value for these two
 		{"client_encoding=SQL_ASCII", "", "", `unsupported client_encoding "SQL_ASCII": must be absent or "UTF8"`, false},
@@ -233,9 +230,6 @@ func TestRuntimeParameters(t *testing.T) {
 			if tt.skipPgbouncer {
 				pqtest.SkipPgbouncer(t)
 			}
-			if pqtest.Pgbouncer() && tt.wantErr == "unrecognized configuration parameter" {
-				tt.wantErr = `unsupported startup parameter`
-			}
 
 			db, err := pqtest.DB(t, tt.conninfo)
 			if !pqtest.ErrorContains(err, tt.wantErr) {

internal/pqtest/ztest.go

@@ -3,9 +3,11 @@
 package pqtest
 
 import (
+	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"testing"
 )
@@ -15,13 +17,35 @@ import (
 //
 // This is safe when have is nil. Use an empty string for want if you want to
 // test that err is nil.
+//
+// Uses a regexp match if want starts with "re:".
+//
+// Matches several strings if wants starts with "or:". For example
+// "or:one|two|three" matches any error which contains "one", "two", or "three".
+// This is similar to "re:(one|two|three)" except that it's not required to
+// escape regexp meta characters. It's not possible to escape | with or:
 func ErrorContains(have error, want string) bool {
 	if have == nil {
 		return want == ""
 	}
 	if want == "" {
 		return false
 	}
+	if strings.HasPrefix(want, "re:") {
+		m, err := regexp.MatchString(want[3:], have.Error())
+		if err != nil {
+			panic(fmt.Errorf("pqtest.ErrorContains: %w", err))
+		}
+		return m
+	}
+	if strings.HasPrefix(want, "or:") {
+		for _, w := range strings.Split(want[3:], "|") {
+			if strings.Contains(have.Error(), w) {
+				return true
+			}
+		}
+		return false
+	}
 	return strings.Contains(have.Error(), want)
 }
 

notify_test.go

@@ -5,7 +5,6 @@ import (
 	"database/sql"
 	"database/sql/driver"
 	"fmt"
-	"io"
 	"math/big"
 	"net"
 	"runtime"
@@ -360,23 +359,15 @@ func TestListenerReconnect(t *testing.T) {
 	wantNotification(t, l.Notify, n, "")
 
 	// Kill the connection and make sure it comes back up.
-	ok, err := l.cn.ExecSimpleQuery("SELECT pg_terminate_backend(pg_backend_pid())")
+	ok, err := l.cn.ExecSimpleQuery("select pg_terminate_backend(pg_backend_pid())")
 	if ok {
 		t.Fatalf("could not kill the connection: %v", err)
 	}
-	if pqtest.Pgbouncer() {
-		if !pqtest.ErrorContains(err, "server conn crashed") {
-			t.Fatalf("unexpected error %T: %[1]s", err)
-		}
-	} else if pqtest.Pgpool() {
-		if !pqtest.ErrorContains(err, "unable to forward message to frontend") {
-			t.Fatalf("unexpected error %T: %[1]s", err)
-		}
-	} else {
-		if err != io.EOF {
-			t.Fatalf("unexpected error %T: %[1]s", err)
-		}
+	// PostgreSQL, pgbouncer, and pgpool all use different errors.
+	if !pqtest.ErrorContains(err, `or:EOF|pq: server conn crashed? (08P01)|pq: unable to forward message to frontend (XX000)`) {
+		t.Fatalf("unexpected error %T: %[1]s", err)
 	}
+
 	wantEvent(t, ch, ListenerEventDisconnected)
 	wantEvent(t, ch, ListenerEventReconnected)
 

ssl_test.go

@@ -20,16 +20,9 @@ import (
 
 // Environment sanity check: should fail without SSL.
 func startSSLTest(t *testing.T, user string) {
-	wantErr := `invalid_authorization_specification`
-	if pqtest.Pgbouncer() {
-		wantErr = "protocol_violation"
-	} else if pqtest.Pgpool() {
-		wantErr = "internal_error"
-	}
 	_, err := pqtest.DB(t, "sslmode=disable user="+user)
-	pqErr := mustAs(t, err)
-	if pqErr.Code.Name() != wantErr {
-		t.Fatalf("wrong error code %q", pqErr.Code.Name())
+	if !pqtest.ErrorContains(err, `or:no encryption (28000)|login rejected (08P01)`) {
+		t.Fatalf("wrong error: %q", err)
 	}
 }
 
@@ -94,7 +87,8 @@ func TestSSLMode(t *testing.T) {
 		{"sslmode=allow " + f.DSN(), ""},   // Idem
 
 		// sslmode=disable
-		{"sslmode=disable user=pqgossl", "no encryption"},
+		// pgbouncer uses "login rejected (08P01)", so allow that too.
+		{"sslmode=disable user=pqgossl", "or:no encryption|login rejected (08P01)"},
 
 		// sslnegotiation=direct should fail if ssl isn't required, like libpq:
 		// psql: error: weak sslmode "allow" may not be used with sslnegotiation=direct (use "require", "verify-ca", or "verify-full")
@@ -108,15 +102,6 @@ func TestSSLMode(t *testing.T) {
 		t.Run("", func(t *testing.T) {
 			t.Parallel()
 
-			if tt.wantErr == "no encryption" && pqtest.Pgbouncer() {
-				// PostgreSQL repsonds with:
-				//   pq: pg_hba.conf rejects connection for host "172.18.0.1", user "pqgossl", database "pqgo", no encryption (28000)
-				//
-				// But pgbouncer has a different message and code:
-				//   pq: login rejected (08P01)
-				tt.wantErr = "login rejected"
-			}
-
 			_, err := pqtest.DB(t, tt.connect)
 			switch {
 			case tt.wantErr == "" && err != nil: