Port postgres to Go and install the extensions a consumer asks for

letta crash-loops on 'type "vector" does not exist': pgvector is not a
trusted extension, so only the provider's superuser can create it, and
the provisioner never did. A contribution may now name extensions; the
provider creates each (IF NOT EXISTS, available ones only) in the
consumer's database on every pass. Go per the standing rule for a
TypeScript module that changes. letta asks for vector.

modules/postgres/cmd/postgres-provider/fake_test.go

@@ -0,0 +1,123 @@
+package main
+
+// A fake server: every session records who it connected as and what it was sent, and answers by the
+// first rule whose pattern matches the statement. That the server keeps data, refuses a reader's
+// write or installs an extension is proven against a real server (live_test.go), not here; this
+// holds the module to asking for the right things.
+
+import (
+	"context"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+)
+
+type call struct {
+	Login
+	SQL string
+}
+
+type rule struct {
+	match  *regexp.Regexp
+	fields []string
+	rows   [][]string
+	err    error
+}
+
+type fakeServer struct {
+	mu      sync.Mutex
+	calls   []call
+	rules   []rule
+	dialErr func(Login) error
+}
+
+func (f *fakeServer) answer(pattern string, fields []string, rows ...[]string) {
+	f.rules = append(f.rules, rule{match: regexp.MustCompile(pattern), fields: fields, rows: rows})
+}
+
+func (f *fakeServer) fail(pattern string, err error) {
+	f.rules = append(f.rules, rule{match: regexp.MustCompile(pattern), err: err})
+}
+
+type fakeSession struct {
+	f *fakeServer
+	l Login
+}
+
+func (s fakeSession) Run(_ context.Context, sql string) ([]Result, error) {
+	s.f.mu.Lock()
+	defer s.f.mu.Unlock()
+	s.f.calls = append(s.f.calls, call{Login: s.l, SQL: sql})
+	for _, r := range s.f.rules {
+		if r.match.MatchString(sql) {
+			if r.err != nil {
+				return nil, r.err
+			}
+			res := Result{Command: strings.Fields(sql)[0], Fields: r.fields}
+			for _, row := range r.rows {
+				cells := make([]*string, len(row))
+				for i := range row {
+					v := row[i]
+					cells[i] = &v
+				}
+				res.Rows = append(res.Rows, cells)
+			}
+			return []Result{res}, nil
+		}
+	}
+	return []Result{{Command: strings.Fields(sql)[0]}}, nil
+}
+
+func (s fakeSession) Close() {}
+
+func (f *fakeServer) dial(_ context.Context, l Login) (Session, error) {
+	if f.dialErr != nil {
+		if err := f.dialErr(l); err != nil {
+			return nil, err
+		}
+	}
+	return fakeSession{f: f, l: l}, nil
+}
+
+func (f *fakeServer) statements() []string {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	out := make([]string, len(f.calls))
+	for i, c := range f.calls {
+		out[i] = c.SQL
+	}
+	return out
+}
+
+func (f *fakeServer) reset() {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls = nil
+}
+
+var admin = Conn{Host: "127.0.0.1", Port: 5432, User: "postgres", Password: "admin-secret"}
+
+func newFake(conn Conn) (*fakeServer, *Client) {
+	f := &fakeServer{}
+	return f, NewClient(conn, f.dial)
+}
+
+func noDrop(t *testing.T, sql []string) {
+	t.Helper()
+	for _, s := range sql {
+		if regexp.MustCompile(`(?i)\bDROP\b`).MatchString(s) {
+			t.Fatalf("something was dropped:\n%s", strings.Join(sql, "\n"))
+		}
+	}
+}
+
+func has(sql []string, pattern string) bool {
+	re := regexp.MustCompile(pattern)
+	for _, s := range sql {
+		if re.MatchString(s) {
+			return true
+		}
+	}
+	return false
+}