threshold/internal/db/read_writer_test.go

package db

import (
	"context"
	stderrors "errors"
	"fmt"
	"io"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/hashicorp/boundary/internal/db/db_test"
	"github.com/hashicorp/boundary/internal/db/timestamp"
	"github.com/hashicorp/boundary/internal/errors"
	"github.com/hashicorp/boundary/internal/oplog"
	"github.com/hashicorp/boundary/internal/oplog/store"
	wrapping "github.com/hashicorp/go-kms-wrapping"
	"github.com/hashicorp/go-secure-stdlib/base62"
	"github.com/hashicorp/go-uuid"
	"github.com/jinzhu/gorm"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/timestamppb"
)

func TestDb_UpdateUnsetField(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	rw := &Db{
		underlying: db,
	}
	tu := &db_test.TestUser{
		StoreTestUser: &db_test.StoreTestUser{
			PublicId: testId(t),
			Name:     "default",
		},
	}
	require.NoError(t, rw.Create(context.Background(), tu))

	updatedTu := tu.Clone().(*db_test.TestUser)
	updatedTu.Name = "updated"
	updatedTu.Email = "ignore"
	cnt, err := rw.Update(context.Background(), updatedTu, []string{"Name"}, nil)
	require.NoError(t, err)
	assert.Equal(t, 1, cnt)
	assert.Equal(t, "ignore", updatedTu.Email)
	assert.Equal(t, "updated", updatedTu.Name)
}

func TestDb_Update(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	now := &timestamp.Timestamp{Timestamp: timestamppb.Now()}
	publicId, err := NewPublicId("testuser")
	require.NoError(t, err)
	id := testId(t)

	badVersion := uint32(22)
	versionOne := uint32(1)
	versionZero := uint32(0)

	type args struct {
		i              *db_test.TestUser
		fieldMaskPaths []string
		setToNullPaths []string
		opt            []Option
	}
	tests := []struct {
		name            string
		args            args
		want            int
		wantErr         bool
		wantErrMsg      string
		wantName        string
		wantEmail       string
		wantPhoneNumber string
		wantVersion     int
	}{
		{
			name: "simple",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "simple-updated" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
			},
			want:            1,
			wantErr:         false,
			wantErrMsg:      "",
			wantName:        "simple-updated" + id,
			wantEmail:       "",
			wantPhoneNumber: "updated" + id,
		},
		{
			name: "simple-with-bad-version",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "simple-with-bad-version" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
				opt:            []Option{WithVersion(&badVersion)},
			},
			want:       0,
			wantErr:    false,
			wantErrMsg: "",
		},
		{
			name: "simple-with-zero-version",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "simple-with-bad-version" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
				opt:            []Option{WithVersion(&versionZero)},
			},
			want:       0,
			wantErr:    true,
			wantErrMsg: "db.Update: with version option is zero: parameter violation: error #100",
		},
		{
			name: "simple-with-version",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "simple-with-version" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
				opt:            []Option{WithVersion(&versionOne)},
			},
			want:            1,
			wantErr:         false,
			wantErrMsg:      "",
			wantName:        "simple-with-version" + id,
			wantEmail:       "",
			wantPhoneNumber: "updated" + id,
			wantVersion:     2,
		},
		{
			name: "simple-with-where",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "simple-with-where" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
				opt:            []Option{WithWhere("email = ? and phone_number = ?", id, id)},
			},
			want:            1,
			wantErr:         false,
			wantErrMsg:      "",
			wantName:        "simple-with-where" + id,
			wantEmail:       "",
			wantPhoneNumber: "updated" + id,
			wantVersion:     2,
		},
		{
			name: "simple-with-where-and-version",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "simple-with-where-and-version" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
				opt:            []Option{WithWhere("email = ? and phone_number = ?", id, id), WithVersion(&versionOne)},
			},
			want:            1,
			wantErr:         false,
			wantErrMsg:      "",
			wantName:        "simple-with-where-and-version" + id,
			wantEmail:       "",
			wantPhoneNumber: "updated" + id,
			wantVersion:     2,
		},
		{
			name: "bad-with-where",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "bad-with-where" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
				opt:            []Option{WithWhere("foo = ? and phone_number = ?", id, id)},
			},
			want:       0,
			wantErr:    true,
			wantErrMsg: `db.Update: column "foo" does not exist: integrity violation: error #1102`,
		},
		{
			name: "multiple-null",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "multiple-null-updated" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
					},
				},
				fieldMaskPaths: []string{"Name"},
				setToNullPaths: []string{"Email", "PhoneNumber"},
			},
			want:            1,
			wantErr:         false,
			wantErrMsg:      "",
			wantName:        "multiple-null-updated" + id,
			wantEmail:       "",
			wantPhoneNumber: "",
		},
		{
			name: "non-updatable",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "non-updatable" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
						PublicId:    publicId,
						CreateTime:  now,
						UpdateTime:  now,
					},
				},
				fieldMaskPaths: []string{"Name", "PhoneNumber", "CreateTime", "UpdateTime", "PublicId"},
				setToNullPaths: []string{"Email"},
			},
			want:            1,
			wantErr:         false,
			wantErrMsg:      "",
			wantName:        "non-updatable" + id,
			wantEmail:       "",
			wantPhoneNumber: "updated" + id,
		},
		{
			name: "primary-key",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "primary-key" + id,
						Email:       "updated" + id,
						PhoneNumber: "updated" + id,
						PublicId:    publicId,
						CreateTime:  now,
						UpdateTime:  now,
					},
				},
				fieldMaskPaths: []string{"Id"},
				setToNullPaths: []string{"Email"},
			},
			want:       0,
			wantErr:    true,
			wantErrMsg: "db.Update: not allowed on primary key field Id: parameter violation: error #103",
		},
		{
			name: "both are missing",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "both are missing-updated" + id,
						Email:       id,
						PhoneNumber: id,
					},
				},
				fieldMaskPaths: nil,
				setToNullPaths: []string{},
			},
			want:       0,
			wantErr:    true,
			wantErrMsg: "db.Update: both fieldMaskPaths and setToNullPaths are missing: parameter violation: error #100",
		},
		{
			name: "i is nil",
			args: args{
				i:              nil,
				fieldMaskPaths: []string{"Name", "PhoneNumber"},
				setToNullPaths: []string{"Email"},
			},
			want:       0,
			wantErr:    true,
			wantErrMsg: "db.Update: missing interface: parameter violation: error #100",
		},
		{
			name: "only read-only",
			args: args{
				i: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{
						Name:        "only read-only" + id,
						Email:       id,
						PhoneNumber: id,
					},
				},
				fieldMaskPaths: []string{"CreateTime"},
				setToNullPaths: []string{"UpdateTime"},
			},
			want:       0,
			wantErr:    true,
			wantErrMsg: "db.Update: after filtering non-updated fields, there are no fields left in fieldMaskPaths or setToNullPaths: parameter violation: error #100",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: db,
			}
			u := testUser(t, db, tt.name+id, id, id)

			if tt.args.i != nil {
				tt.args.i.Id = u.Id
				tt.args.i.PublicId = u.PublicId
			}
			rowsUpdated, err := rw.Update(context.Background(), tt.args.i, tt.args.fieldMaskPaths, tt.args.setToNullPaths, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				assert.Equal(tt.want, rowsUpdated)
				assert.Contains(err.Error(), tt.wantErrMsg)
				return
			}
			require.NoError(err)
			assert.Equal(tt.want, rowsUpdated)
			if tt.want == 0 {
				return
			}
			foundUser, err := db_test.NewTestUser()
			require.NoError(err)
			foundUser.PublicId = tt.args.i.PublicId
			where := "public_id = ?"
			for _, f := range tt.args.setToNullPaths {
				switch {
				case strings.EqualFold(f, "phonenumber"):
					f = "phone_number"
				}
				where = fmt.Sprintf("%s and %s is null", where, f)
			}
			err = rw.LookupWhere(context.Background(), foundUser, where, tt.args.i.PublicId)
			require.NoError(err)
			assert.Equal(tt.args.i.Id, foundUser.Id)
			assert.Equal(tt.wantName, foundUser.Name)
			assert.Equal(tt.wantEmail, foundUser.Email)
			assert.Equal(tt.wantPhoneNumber, foundUser.PhoneNumber)
			assert.NotEqual(now, foundUser.CreateTime)
			assert.NotEqual(now, foundUser.UpdateTime)
			assert.NotEqual(publicId, foundUser.PublicId)
			assert.Equal(u.Version+1, foundUser.Version)
		})
	}
	t.Run("no-version-field", func(t *testing.T) {
		assert := assert.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		assert.NoError(err)
		car := testCar(t, db, "foo-"+id, id, int32(100))

		car.Name = "friendly-" + id
		versionOne := uint32(1)
		rowsUpdated, err := w.Update(context.Background(), car, []string{"Name"}, nil, WithVersion(&versionOne))
		assert.Error(err)
		assert.Equal(0, rowsUpdated)
	})
	t.Run("valid-WithOplog", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user := testUser(t, db, "foo-"+id, id, id)

		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil,
			// write oplogs for this update
			WithOplog(
				TestWrapper(t),
				oplog.Metadata{
					"key-only":           nil,
					"deployment":         []string{"amex"},
					"project":            []string{"central-info-systems", "local-info-systems"},
					"resource-public-id": []string{user.PublicId},
					"op-type":            []string{oplog.OpType_OP_TYPE_UPDATE.String()},
				}),
		)
		require.NoError(err)
		assert.Equal(1, rowsUpdated)

		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Name, user.Name)

		err = TestVerifyOplog(t, &w, user.PublicId, WithOperation(oplog.OpType_OP_TYPE_UPDATE), WithCreateNotBefore(10*time.Second))
		require.NoError(err)
	})
	t.Run("both-WithOplog-NewOplogMsg", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		createMsg := oplog.Message{}
		err = w.Create(
			context.Background(),
			user,
			NewOplogMsg(&createMsg),
		)
		require.NoError(err)

		updateMsg := oplog.Message{}
		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(
			context.Background(),
			user,
			[]string{"Name"}, nil,
			NewOplogMsg(&updateMsg),
			WithOplog(TestWrapper(t), oplog.Metadata{"alice": []string{"bob"}}),
		)
		require.Error(err)
		assert.Equal(0, rowsUpdated)
		assert.True(errors.Match(errors.T(errors.InvalidParameter), err))
	})
	t.Run("valid-NewOplogMsg", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}

		ticket, err := w.GetTicket(&db_test.TestUser{})
		require.NoError(err)

		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		createMsg := oplog.Message{}
		err = w.Create(
			context.Background(),
			user,
			NewOplogMsg(&createMsg),
		)
		require.NoError(err)

		updateMsg := oplog.Message{}
		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil, NewOplogMsg(&updateMsg))
		require.NoError(err)
		assert.Equal(1, rowsUpdated)

		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Name, user.Name)

		metadata := oplog.Metadata{
			"resource-public-id": []string{user.PublicId},
			// "op-type":            []string{oplog.OpType_OP_TYPE_UPDATE.String()},
		}
		err = w.WriteOplogEntryWith(context.Background(), TestWrapper(t), ticket, metadata, []*oplog.Message{&createMsg, &updateMsg})
		require.NoError(err)

		err = TestVerifyOplog(t, &w, user.PublicId, WithOperation(oplog.OpType_OP_TYPE_UNSPECIFIED), WithCreateNotBefore(10*time.Second))
		assert.NoError(err)
	})
	t.Run("vet-for-write", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		assert.NoError(err)
		user := &testUserWithVet{
			PublicId:    id,
			Name:        id,
			PhoneNumber: id,
			Email:       id,
		}
		err = db.Create(user).Error
		require.NoError(err)

		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil)
		require.NoError(err)
		assert.Equal(1, rowsUpdated)

		foundUser := &testUserWithVet{PublicId: user.PublicId}
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Name, user.Name)

		user.PublicId = "not-allowed-by-vet-for-write"
		rowsUpdated, err = w.Update(context.Background(), user, []string{"PublicId"}, nil)
		require.Error(err)
		assert.Equal(0, rowsUpdated)
	})
	t.Run("nil-tx", func(t *testing.T) {
		assert := assert.New(t)
		w := Db{underlying: nil}
		id, err := uuid.GenerateUUID()
		assert.NoError(err)

		user := testUser(t, db, "foo-"+id, id, id)
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil)
		assert.Error(err)
		assert.Equal(0, rowsUpdated)
		assert.Contains(err.Error(), "db.Update: missing underlying db: parameter violation: error #100")
	})
	t.Run("no-wrapper-WithOplog", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user := testUser(t, db, "foo-"+id, id, id)

		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"},
			nil,
			WithOplog(
				nil,
				oplog.Metadata{
					"key-only":   nil,
					"deployment": []string{"amex"},
					"project":    []string{"central-info-systems", "local-info-systems"},
				}),
		)
		require.Error(err)
		assert.Equal(0, rowsUpdated)
		assert.Contains(err.Error(), "db.Update: oplog validation failed: db.validateOplogArgs: missing wrapper: parameter violation: error #100")
	})
	t.Run("no-metadata-WithOplog", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user := testUser(t, db, "foo-"+id, id, id)
		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil,
			WithOplog(
				TestWrapper(t),
				nil,
			),
		)
		require.Error(err)
		assert.Equal(0, rowsUpdated)
		assert.Contains(err.Error(), "db.Update: oplog validation failed: db.validateOplogArgs: missing metadata: parameter violation: error #100")
	})
}

// testUserWithVet gives us a model that implements VetForWrite() without any
// cyclic dependencies.
type testUserWithVet struct {
	Id          uint32 `gorm:"primary_key"`
	PublicId    string
	Name        string `gorm:"default:null"`
	PhoneNumber string `gorm:"default:null"`
	Email       string `gorm:"default:null"`
}

func (u *testUserWithVet) GetPublicId() string {
	return u.PublicId
}

func (u *testUserWithVet) TableName() string {
	return "db_test_user"
}

func (u *testUserWithVet) VetForWrite(ctx context.Context, r Reader, opType OpType, opt ...Option) error {
	if u.PublicId == "" {
		return stderrors.New("public id is empty string for user write")
	}
	if opType == UpdateOp {
		dbOptions := GetOpts(opt...)
		for _, path := range dbOptions.WithFieldMaskPaths {
			switch path {
			case "PublicId":
				return stderrors.New("you cannot change the public id")
			}
		}
	}
	if opType == CreateOp {
		if u.Id != 0 {
			return stderrors.New("id is a db sequence")
		}
	}
	return nil
}

func TestDb_Create(t *testing.T) {
	// intentionally not run with t.Parallel so we don't need to use DoTx for the Create tests
	db, _ := TestSetup(t, "postgres")
	t.Run("simple", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		ts := &timestamp.Timestamp{Timestamp: timestamppb.Now()}
		user.CreateTime = ts
		user.UpdateTime = ts
		user.Name = "foo-" + id
		err = w.Create(context.Background(), user)
		require.NoError(err)
		assert.NotEmpty(user.Id)
		// make sure the database controlled the timestamp values
		assert.NotEqual(ts, user.GetCreateTime())
		assert.NotEqual(ts, user.GetUpdateTime())

		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Id, user.Id)
	})
	t.Run("valid-WithOplog", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(
			context.Background(),
			user,
			WithOplog(
				TestWrapper(t),
				oplog.Metadata{
					"key-only":   nil,
					"deployment": []string{"amex"},
					"project":    []string{"central-info-systems", "local-info-systems"},
				},
			),
		)
		require.NoError(err)
		require.NotEmpty(user.Id)

		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Id, user.Id)
	})
	t.Run("both-Oplog-NewOplogMsg", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		createMsg := oplog.Message{}
		err = w.Create(
			context.Background(),
			user,
			NewOplogMsg(&createMsg),
			WithOplog(TestWrapper(t), oplog.Metadata{"alice": []string{"bob"}}),
		)
		require.Error(err)
		assert.True(errors.Match(errors.T(errors.InvalidParameter), err))
	})
	t.Run("valid-NewOplogMsg", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}

		ticket, err := w.GetTicket(&db_test.TestUser{})
		require.NoError(err)

		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		createMsg := oplog.Message{}
		err = w.Create(
			context.Background(),
			user,
			NewOplogMsg(&createMsg),
		)
		require.NoError(err)

		updateMsg := oplog.Message{}
		user.Name = "friendly-" + id
		rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil, NewOplogMsg(&updateMsg))
		require.NoError(err)
		assert.Equal(1, rowsUpdated)

		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Name, user.Name)

		metadata := oplog.Metadata{
			"resource-public-id": []string{user.PublicId},
			// "op-type":            []string{oplog.OpType_OP_TYPE_UPDATE.String()},
		}
		err = w.WriteOplogEntryWith(context.Background(), TestWrapper(t), ticket, metadata, []*oplog.Message{&createMsg, &updateMsg})
		require.NoError(err)

		err = TestVerifyOplog(t, &w, user.PublicId, WithOperation(oplog.OpType_OP_TYPE_UNSPECIFIED), WithCreateNotBefore(10*time.Second))
		require.NoError(err)
	})
	t.Run("no-wrapper-WithOplog", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(
			context.Background(),
			user,
			WithOplog(
				nil,
				oplog.Metadata{
					"key-only":   nil,
					"deployment": []string{"amex"},
					"project":    []string{"central-info-systems", "local-info-systems"},
				},
			),
		)
		require.Error(err)
		assert.Contains(err.Error(), "db.Create: oplog validation failed: db.validateOplogArgs: missing wrapper: parameter violation: error #100")
	})
	t.Run("no-metadata-WithOplog", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(
			context.Background(),
			user,
			WithOplog(
				TestWrapper(t),
				nil,
			),
		)
		require.Error(err)
		assert.Contains(err.Error(), "db.Create: oplog validation failed: db.validateOplogArgs: missing metadata: parameter violation: error #100")
	})
	t.Run("nil-tx", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: nil}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(context.Background(), user)
		require.Error(err)
		assert.Contains(err.Error(), "db.Create: missing underlying db: parameter violation: error #100")
	})
}

func TestDb_LookupByPublicId(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	t.Run("simple", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(context.Background(), user)
		require.NoError(err)
		assert.NotEmpty(user.PublicId)

		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = user.PublicId
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Id, user.Id)
	})
	t.Run("tx-nil,", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{}
		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.Error(err)
		assert.Contains(err.Error(), "db.LookupById: missing underlying db: parameter violation: error #100")
	})
	t.Run("no-public-id-set", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		foundUser, err := db_test.NewTestUser()
		foundUser.PublicId = ""
		require.NoError(err)
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.Error(err)
		assert.Contains(err.Error(), "db.LookupById: db.primaryKeyWhere: missing primary key: parameter violation: error #100")
	})
	t.Run("not-found", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		foundUser, err := db_test.NewTestUser()
		require.NoError(err)
		foundUser.PublicId = id
		err = w.LookupByPublicId(context.Background(), foundUser)
		require.Error(err)
		assert.True(errors.Match(errors.T(errors.RecordNotFound), err))
	})
}

func TestDb_LookupWhere(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	t.Run("simple", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(context.Background(), user)
		require.NoError(err)
		assert.NotEmpty(user.PublicId)

		var foundUser db_test.TestUser
		err = w.LookupWhere(context.Background(), &foundUser, "public_id = ?", user.PublicId)
		require.NoError(err)
		assert.Equal(foundUser.Id, user.Id)
	})
	t.Run("tx-nil,", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{}
		var foundUser db_test.TestUser
		err := w.LookupWhere(context.Background(), &foundUser, "public_id = ?", 1)
		require.Error(err)
		assert.Equal("db.LookupWhere: missing underlying db: parameter violation: error #100", err.Error())
	})
	t.Run("not-found", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)

		var foundUser db_test.TestUser
		err = w.LookupWhere(context.Background(), &foundUser, "public_id = ?", id)
		require.Error(err)
		assert.True(errors.Match(errors.T(errors.RecordNotFound), err))
	})
	t.Run("bad-where", func(t *testing.T) {
		require := require.New(t)
		w := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)

		var foundUser db_test.TestUser
		err = w.LookupWhere(context.Background(), &foundUser, "? = ?", id)
		require.Error(err)
	})
}

func TestDb_SearchWhere(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	knownUser := testUser(t, db, "zedUser", "", "")

	type args struct {
		where string
		arg   []interface{}
		opt   []Option
	}
	tests := []struct {
		name          string
		db            Db
		createCnt     int
		args          args
		wantCnt       int
		wantErr       bool
		wantNameOrder bool
	}{
		{
			name:      "no-limit",
			db:        Db{underlying: db},
			createCnt: 10,
			args: args{
				where: "1=1",
				opt:   []Option{WithLimit(-1), WithOrder("name asc")},
			},
			wantCnt:       11, // there's an additional knownUser
			wantErr:       false,
			wantNameOrder: true,
		},
		{
			name:      "no-where",
			db:        Db{underlying: db},
			createCnt: 10,
			args: args{
				opt: []Option{WithLimit(10)},
			},
			wantCnt: 10,
			wantErr: false,
		},
		{
			name:      "custom-limit",
			db:        Db{underlying: db},
			createCnt: 10,
			args: args{
				where: "1=1",
				opt:   []Option{WithLimit(3)},
			},
			wantCnt: 3,
			wantErr: false,
		},
		{
			name:      "simple",
			db:        Db{underlying: db},
			createCnt: 1,
			args: args{
				where: "public_id = ?",
				arg:   []interface{}{knownUser.PublicId},
				opt:   []Option{WithLimit(3)},
			},
			wantCnt: 1,
			wantErr: false,
		},
		{
			name:      "no args",
			db:        Db{underlying: db},
			createCnt: 1,
			args: args{
				where: fmt.Sprintf("public_id = '%v'", knownUser.PublicId),
				opt:   []Option{WithLimit(3)},
			},
			wantCnt: 1,
			wantErr: false,
		},
		{
			name:      "no where, but with args",
			db:        Db{underlying: db},
			createCnt: 1,
			args: args{
				arg: []interface{}{knownUser.PublicId},
				opt: []Option{WithLimit(3)},
			},
			wantErr: true,
		},
		{
			name:      "not-found",
			db:        Db{underlying: db},
			createCnt: 1,
			args: args{
				where: "public_id = ?",
				arg:   []interface{}{"bad-id"},
				opt:   []Option{WithLimit(3)},
			},
			wantCnt: 0,
			wantErr: false,
		},
		{
			name:      "bad-where",
			db:        Db{underlying: db},
			createCnt: 1,
			args: args{
				where: "bad_column_name = ?",
				arg:   []interface{}{knownUser.PublicId},
				opt:   []Option{WithLimit(3)},
			},
			wantCnt: 0,
			wantErr: true,
		},
		{
			name:      "nil-underlying",
			db:        Db{},
			createCnt: 1,
			args: args{
				where: "public_id = ?",
				arg:   []interface{}{knownUser.PublicId},
				opt:   []Option{WithLimit(3)},
			},
			wantCnt: 0,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			testUsers := []*db_test.TestUser{}
			for i := 0; i < tt.createCnt; i++ {
				testUsers = append(testUsers, testUser(t, db, tt.name+strconv.Itoa(i), "", ""))
			}
			assert.Equal(tt.createCnt, len(testUsers))

			var foundUsers []db_test.TestUser
			err := tt.db.SearchWhere(context.Background(), &foundUsers, tt.args.where, tt.args.arg, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				return
			}
			require.NoError(err)
			assert.Equal(tt.wantCnt, len(foundUsers))
			if tt.wantNameOrder {
				assert.Equal(tt.name+strconv.Itoa(0), foundUsers[0].Name)
				for i, u := range foundUsers {
					if u.Name != "zedUser" {
						assert.Equal(tt.name+strconv.Itoa(i), u.Name)
					}
				}
			}
		})
	}
}

func TestDb_Exec(t *testing.T) {
	t.Parallel()
	t.Run("update", func(t *testing.T) {
		db, _ := TestSetup(t, "postgres")
		require := require.New(t)
		w := Db{underlying: db}
		id := testId(t)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = w.Create(context.Background(), user)
		require.NoError(err)
		require.NotEmpty(user.Id)
		rowsAffected, err := w.Exec(context.Background(), "update db_test_user set name = ? where public_id = ?", []interface{}{"updated-" + id, user.PublicId})
		require.NoError(err)
		require.Equal(1, rowsAffected)
	})
}

func TestDb_DoTx(t *testing.T) {
	t.Parallel()
	ctx := context.TODO()
	db, _ := TestSetup(t, "postgres")
	t.Run("valid-with-10-retries", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		attempts := 0
		got, err := w.DoTx(context.Background(), 10, ExpBackoff{},
			func(Reader, Writer) error {
				attempts += 1
				if attempts < 9 {
					return errors.E(ctx, errors.WithCode(errors.TicketAlreadyRedeemed))
				}
				return nil
			})
		require.NoError(err)
		assert.Equal(8, got.Retries)
		assert.Equal(9, attempts) // attempted 1 + 8 retries
	})
	t.Run("valid-with-1-retries", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		attempts := 0
		got, err := w.DoTx(context.Background(), 1, ExpBackoff{},
			func(Reader, Writer) error {
				attempts += 1
				if attempts < 2 {
					return errors.E(ctx, errors.WithCode(errors.TicketAlreadyRedeemed))
				}
				return nil
			})
		require.NoError(err)
		assert.Equal(1, got.Retries)
		assert.Equal(2, attempts) // attempted 1 + 8 retries
	})
	t.Run("valid-with-2-retries", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		attempts := 0
		got, err := w.DoTx(context.Background(), 3, ExpBackoff{},
			func(Reader, Writer) error {
				attempts += 1
				if attempts < 3 {
					return errors.E(ctx, errors.WithCode(errors.TicketAlreadyRedeemed))
				}
				return nil
			})
		require.NoError(err)
		assert.Equal(2, got.Retries)
		assert.Equal(3, attempts) // attempted 1 + 8 retries
	})
	t.Run("valid-with-4-retries", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		attempts := 0
		got, err := w.DoTx(context.Background(), 4, ExpBackoff{},
			func(Reader, Writer) error {
				attempts += 1
				if attempts < 4 {
					return errors.E(ctx, errors.WithCode(errors.TicketAlreadyRedeemed))
				}
				return nil
			})
		require.NoError(err)
		assert.Equal(3, got.Retries)
		assert.Equal(4, attempts) // attempted 1 + 8 retries
	})
	t.Run("zero-retries", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		attempts := 0
		got, err := w.DoTx(context.Background(), 0, ExpBackoff{}, func(Reader, Writer) error { attempts += 1; return nil })
		require.NoError(err)
		assert.Equal(RetryInfo{}, got)
		assert.Equal(1, attempts)
	})
	t.Run("nil-tx", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{nil}
		attempts := 0
		got, err := w.DoTx(context.Background(), 1, ExpBackoff{}, func(Reader, Writer) error { attempts += 1; return nil })
		require.Error(err)
		assert.Equal(RetryInfo{}, got)
		assert.Equal("db.DoTx: missing underlying db: parameter violation: error #100", err.Error())
	})
	t.Run("not-a-retry-err", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		got, err := w.DoTx(context.Background(), 1, ExpBackoff{}, func(Reader, Writer) error { return stderrors.New("not a retry error") })
		require.Error(err)
		assert.Equal(RetryInfo{}, got)
		assert.False(errors.Match(errors.T(errors.TicketAlreadyRedeemed), err))
	})
	t.Run("too-many-retries", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := &Db{underlying: db}
		attempts := 0
		got, err := w.DoTx(context.Background(), 2, ExpBackoff{}, func(Reader, Writer) error {
			attempts += 1
			return errors.E(ctx, errors.WithCode(errors.TicketAlreadyRedeemed))
		})
		require.Error(err)
		assert.Equal(3, got.Retries)
		assert.Equal("db.DoTx: Too many retries: 3 of 3: db transaction issue: error #1103", err.Error())
	})
	t.Run("updating-good-bad-good", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		rw := Db{underlying: db}
		id, err := uuid.GenerateUUID()
		require.NoError(err)
		user, err := db_test.NewTestUser()
		require.NoError(err)
		user.Name = "foo-" + id
		err = rw.Create(context.Background(), user)
		require.NoError(err)
		require.NotZero(user.Id)

		_, err = rw.DoTx(context.Background(), 10, ExpBackoff{}, func(r Reader, w Writer) error {
			user.Name = "friendly-" + id
			rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil)
			if err != nil {
				return err
			}
			if rowsUpdated != 1 {
				return fmt.Errorf("error in number of rows updated %d", rowsUpdated)
			}
			return nil
		})
		require.NoError(err)

		foundUser, err := db_test.NewTestUser()
		assert.NoError(err)
		foundUser.PublicId = user.PublicId
		err = rw.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Name, user.Name)

		user2, err := db_test.NewTestUser()
		require.NoError(err)
		_, err = rw.DoTx(context.Background(), 10, ExpBackoff{}, func(_ Reader, w Writer) error {
			user2.Name = "friendly2-" + id
			rowsUpdated, err := w.Update(context.Background(), user2, []string{"Name"}, nil)
			if err != nil {
				return err
			}
			if rowsUpdated != 1 {
				return fmt.Errorf("error in number of rows updated %d", rowsUpdated)
			}
			return nil
		})
		require.Error(err)
		err = rw.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.NotEqual(foundUser.Name, user2.Name)

		_, err = rw.DoTx(context.Background(), 10, ExpBackoff{}, func(r Reader, w Writer) error {
			user.Name = "friendly2-" + id
			rowsUpdated, err := w.Update(context.Background(), user, []string{"Name"}, nil)
			if err != nil {
				return err
			}
			if rowsUpdated != 1 {
				return fmt.Errorf("error in number of rows updated %d", rowsUpdated)
			}
			return nil
		})
		require.NoError(err)
		err = rw.LookupByPublicId(context.Background(), foundUser)
		require.NoError(err)
		assert.Equal(foundUser.Name, user.Name)
	})
}

func TestDb_Delete(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	newUser := func() *db_test.TestUser {
		w := &Db{
			underlying: db,
		}
		u, err := db_test.NewTestUser()
		require.NoError(t, err)
		err = w.Create(context.Background(), u)
		require.NoError(t, err)
		return u
	}
	notFoundUser := func() *db_test.TestUser {
		u, err := db_test.NewTestUser()
		require.NoError(t, err)
		u.Id = 1111111
		return u
	}

	newMetadata := func(publicId string) oplog.Metadata {
		return oplog.Metadata{
			"op-type":            []string{oplog.OpType_OP_TYPE_DELETE.String()},
			"resource-public-id": []string{publicId},
		}
	}
	type args struct {
		i        *db_test.TestUser
		opt      []Option
		metadata func(publicId string) oplog.Metadata
	}
	tests := []struct {
		name       string
		underlying *gorm.DB
		wrapper    wrapping.Wrapper
		args       args
		want       int
		wantOplog  bool
		wantErr    bool
		wantErrIs  errors.Code
	}{
		{
			name:       "simple-no-oplog",
			underlying: db,
			wrapper:    TestWrapper(t),
			args: args{
				i: newUser(),
			},
			want:    1,
			wantErr: false,
		},
		{
			name:       "valid-with-oplog",
			underlying: db,
			wrapper:    TestWrapper(t),
			args: args{
				i:        newUser(),
				metadata: newMetadata,
			},
			wantOplog: true,
			want:      1,
			wantErr:   false,
		},
		{
			name:       "nil-wrapper",
			underlying: db,
			wrapper:    nil,
			args: args{
				i:        newUser(),
				metadata: newMetadata,
			},
			wantOplog: true,
			want:      0,
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil-metadata",
			underlying: db,
			wrapper:    nil,
			args: args{
				i:        newUser(),
				metadata: func(string) oplog.Metadata { return nil },
			},
			wantOplog: true,
			want:      0,
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil-underlying",
			underlying: nil,
			wrapper:    TestWrapper(t),
			args: args{
				i: newUser(),
			},
			want:      0,
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "not-found",
			underlying: db,
			wrapper:    TestWrapper(t),
			args: args{
				i: notFoundUser(),
			},
			want:    0,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			require := require.New(t)
			assert := assert.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			if tt.wantOplog {
				metadata := tt.args.metadata(tt.args.i.PublicId)
				opLog := WithOplog(tt.wrapper, metadata)
				tt.args.opt = append(tt.args.opt, opLog)
			}
			got, err := rw.Delete(context.Background(), tt.args.i, tt.args.opt...)
			assert.Equal(tt.want, got)
			if tt.wantErr {
				require.Error(err)
				assert.Truef(errors.Match(errors.T(tt.wantErrIs), err), "received unexpected error: %v", err)
				err := TestVerifyOplog(t, rw, tt.args.i.GetPublicId(), WithOperation(oplog.OpType_OP_TYPE_DELETE), WithCreateNotBefore(5*time.Second))
				assert.Error(err)
				return
			}
			require.NoError(err)
			assert.Equal(tt.want, got)

			foundUser := tt.args.i.Clone().(*db_test.TestUser)
			foundUser.PublicId = tt.args.i.PublicId
			err = rw.LookupByPublicId(context.Background(), foundUser)
			assert.Error(err)
			assert.True(errors.Match(errors.T(errors.RecordNotFound), err))

			err = TestVerifyOplog(t, rw, tt.args.i.GetPublicId(), WithOperation(oplog.OpType_OP_TYPE_DELETE), WithCreateNotBefore(5*time.Second))
			switch {
			case tt.wantOplog:
				assert.NoError(err)
			default:
				assert.Error(err)
			}
		})
		t.Run("both-WithOplog-NewOplogMsg", func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			w := Db{underlying: db}
			id, err := uuid.GenerateUUID()
			require.NoError(err)
			user, err := db_test.NewTestUser()
			require.NoError(err)
			user.Name = "foo-" + id
			createMsg := oplog.Message{}
			err = w.Create(
				context.Background(),
				user,
				NewOplogMsg(&createMsg),
			)
			require.NoError(err)

			deleteMsg := oplog.Message{}
			rowsDeleted, err := w.Delete(context.Background(), user, NewOplogMsg(&deleteMsg), WithOplog(TestWrapper(t), oplog.Metadata{"alice": []string{"bob"}}))
			require.Error(err)
			assert.Equal(0, rowsDeleted)
			assert.True(errors.Match(errors.T(errors.InvalidParameter), err))
		})
		t.Run("valid-NewOplogMsg", func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			w := Db{underlying: db}

			ticket, err := w.GetTicket(&db_test.TestUser{})
			require.NoError(err)

			id, err := uuid.GenerateUUID()
			require.NoError(err)
			user, err := db_test.NewTestUser()
			require.NoError(err)
			user.Name = "foo-" + id
			createMsg := oplog.Message{}
			err = w.Create(
				context.Background(),
				user,
				NewOplogMsg(&createMsg),
			)
			require.NoError(err)

			deleteMsg := oplog.Message{}
			rowsDeleted, err := w.Delete(context.Background(), user, NewOplogMsg(&deleteMsg))
			require.NoError(err)
			assert.Equal(1, rowsDeleted)

			foundUser, err := db_test.NewTestUser()
			require.NoError(err)
			foundUser.PublicId = user.PublicId
			err = w.LookupByPublicId(context.Background(), foundUser)
			require.Error(err)
			assert.True(errors.Match(errors.T(errors.RecordNotFound), err))

			metadata := oplog.Metadata{
				"resource-public-id": []string{user.PublicId},
			}
			err = w.WriteOplogEntryWith(context.Background(), TestWrapper(t), ticket, metadata, []*oplog.Message{&createMsg, &deleteMsg})
			require.NoError(err)

			err = TestVerifyOplog(t, &w, user.PublicId, WithOperation(oplog.OpType_OP_TYPE_UNSPECIFIED), WithCreateNotBefore(10*time.Second))
			require.NoError(err)
		})
	}
}

func TestDb_ScanRows(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	t.Run("valid", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		w := Db{underlying: db}
		user, err := db_test.NewTestUser()
		require.NoError(err)
		err = w.Create(context.Background(), user)
		require.NoError(err)
		assert.NotEmpty(user.Id)
		where := "select * from db_test_user where name in ($1, $2)"
		rows, err := w.Query(context.Background(), where, []interface{}{"alice", "bob"})
		require.NoError(err)
		defer func() { err := rows.Close(); assert.NoError(err) }()
		for rows.Next() {
			u, err := db_test.NewTestUser()
			require.NoError(err)

			// scan the row into your Gorm struct
			err = w.ScanRows(rows, &u)
			require.NoError(err)
			assert.Equal(user.PublicId, u.PublicId)
		}
	})
}

func TestDb_Query(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	t.Run("valid", func(t *testing.T) {
		assert, require := assert.New(t), require.New(t)
		rw := Db{underlying: db}
		user, err := db_test.NewTestUser()
		user.Name = "alice"
		require.NoError(err)
		err = rw.Create(context.Background(), user)
		require.NoError(err)
		assert.NotEmpty(user.Id)
		assert.Equal("alice", user.Name)

		where := "select * from db_test_user where name in ($1, $2)"
		rows, err := rw.Query(context.Background(), where, []interface{}{"alice", "bob"})
		require.NoError(err)
		defer func() { err := rows.Close(); assert.NoError(err) }()
		for rows.Next() {
			u, err := db_test.NewTestUser()
			require.NoError(err)
			// scan the row into your Gorm struct
			err = rw.ScanRows(rows, &u)
			require.NoError(err)
			assert.Equal(user.PublicId, u.PublicId)
		}
	})
}

func TestDb_CreateItems(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	testOplogResourceId := testId(t)

	createFn := func() []interface{} {
		results := []interface{}{}
		for i := 0; i < 10; i++ {
			u, err := db_test.NewTestUser()
			require.NoError(t, err)
			results = append(results, u)
		}
		return results
	}
	createMixedFn := func() []interface{} {
		u, err := db_test.NewTestUser()
		require.NoError(t, err)
		c, err := db_test.NewTestCar()
		require.NoError(t, err)
		return []interface{}{
			u,
			c,
		}
	}

	returnedMsgs := []*oplog.Message{}

	type args struct {
		createItems []interface{}
		opt         []Option
	}
	tests := []struct {
		name          string
		underlying    *gorm.DB
		args          args
		wantOplogId   string
		wantOplogMsgs bool
		wantErr       bool
		wantErrIs     errors.Code
	}{
		{
			name:       "simple",
			underlying: db,
			args: args{
				createItems: createFn(),
			},
			wantErr: false,
		},
		{
			name:       "withOplog",
			underlying: db,
			args: args{
				createItems: createFn(),
				opt: []Option{
					WithOplog(
						TestWrapper(t),
						oplog.Metadata{
							"resource-public-id": []string{testOplogResourceId},
							"op-type":            []string{oplog.OpType_OP_TYPE_CREATE.String()},
						},
					),
				},
			},
			wantOplogId: testOplogResourceId,
			wantErr:     false,
		},
		{
			name:       "NewOplogMsgs",
			underlying: db,
			args: args{
				createItems: createFn(),
				opt: []Option{
					NewOplogMsgs(&returnedMsgs),
				},
			},
			wantOplogMsgs: true,
			wantErr:       false,
		},
		{
			name:       "withOplog and NewOplogMsgs",
			underlying: db,
			args: args{
				createItems: createFn(),
				opt: []Option{
					NewOplogMsgs(&[]*oplog.Message{}),
					WithOplog(
						TestWrapper(t),
						oplog.Metadata{
							"resource-public-id": []string{testOplogResourceId},
							"op-type":            []string{oplog.OpType_OP_TYPE_CREATE.String()},
						},
					),
				},
			},
			wantErrIs: errors.InvalidParameter,
			wantErr:   true,
		},
		{
			name:       "mixed items",
			underlying: db,
			args: args{
				createItems: createMixedFn(),
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "bad oplog opt: nil metadata",
			underlying: nil,
			args: args{
				createItems: createFn(),
				opt: []Option{
					WithOplog(
						TestWrapper(t),
						nil,
					),
				},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "bad oplog opt: nil wrapper",
			underlying: nil,
			args: args{
				createItems: createFn(),
				opt: []Option{
					WithOplog(
						nil,
						oplog.Metadata{
							"resource-public-id": []string{"doesn't matter since wrapper is nil"},
							"op-type":            []string{oplog.OpType_OP_TYPE_CREATE.String()},
						},
					),
				},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "bad opt: WithLookup",
			underlying: nil,
			args: args{
				createItems: createFn(),
				opt:         []Option{WithLookup(true)},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil underlying",
			underlying: nil,
			args: args{
				createItems: createFn(),
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "empty items",
			underlying: db,
			args: args{
				createItems: []interface{}{},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil items",
			underlying: db,
			args: args{
				createItems: nil,
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			err := rw.CreateItems(context.Background(), tt.args.createItems, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				assert.Truef(errors.Match(errors.T(tt.wantErrIs), err), "unexpected error: %s", err.Error())
				return
			}
			require.NoError(err)
			for _, item := range tt.args.createItems {
				u := db_test.AllocTestUser()
				u.PublicId = item.(*db_test.TestUser).PublicId
				err := rw.LookupByPublicId(context.Background(), &u)
				assert.NoError(err)
				if _, ok := item.(*db_test.TestUser); ok {
					assert.Truef(proto.Equal(item.(*db_test.TestUser).StoreTestUser, u.StoreTestUser), "%s and %s should be equal", item, u)
				}
			}
			if tt.wantOplogId != "" {
				err = TestVerifyOplog(t, rw, tt.wantOplogId, WithOperation(oplog.OpType_OP_TYPE_CREATE), WithCreateNotBefore(10*time.Second))
				assert.NoError(err)
			}
			if tt.wantOplogMsgs {
				assert.Equal(len(tt.args.createItems), len(returnedMsgs))
				for _, m := range returnedMsgs {
					assert.Equal(m.OpType, oplog.OpType_OP_TYPE_CREATE)
				}
			}
		})
	}
}

func TestDb_DeleteItems(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	testOplogResourceId := testId(t)

	createFn := func() []interface{} {
		results := []interface{}{}
		for i := 0; i < 10; i++ {
			u := testUser(t, db, "", "", "")
			results = append(results, u)
		}
		return results
	}

	returnedMsgs := []*oplog.Message{}

	type args struct {
		deleteItems []interface{}
		opt         []Option
	}
	tests := []struct {
		name            string
		underlying      *gorm.DB
		args            args
		wantRowsDeleted int
		wantOplogId     string
		wantOplogMsgs   bool
		wantErr         bool
		wantErrIs       errors.Code
	}{
		{
			name:       "simple",
			underlying: db,
			args: args{
				deleteItems: createFn(),
			},
			wantRowsDeleted: 10,
			wantErr:         false,
		},
		{
			name:       "NewOplogMsgs",
			underlying: db,
			args: args{
				deleteItems: createFn(),
				opt: []Option{
					NewOplogMsgs(&returnedMsgs),
				},
			},
			wantRowsDeleted: 10,
			wantErr:         false,
		},
		{
			name:       "withOplog and NewOplogMsgs",
			underlying: db,
			args: args{
				deleteItems: createFn(),
				opt: []Option{
					NewOplogMsgs(&[]*oplog.Message{}),
					WithOplog(
						TestWrapper(t),
						oplog.Metadata{
							"resource-public-id": []string{testOplogResourceId},
							"op-type":            []string{oplog.OpType_OP_TYPE_DELETE.String()},
						},
					),
				},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "withOplog",
			underlying: db,
			args: args{
				deleteItems: createFn(),
				opt: []Option{
					WithOplog(
						TestWrapper(t),
						oplog.Metadata{
							"resource-public-id": []string{testOplogResourceId},
							"op-type":            []string{oplog.OpType_OP_TYPE_DELETE.String()},
						},
					),
				},
			},
			wantRowsDeleted: 10,
			wantOplogId:     testOplogResourceId,
			wantErr:         false,
		},
		{
			name:       "bad oplog opt: nil metadata",
			underlying: nil,
			args: args{
				deleteItems: createFn(),
				opt: []Option{
					WithOplog(
						TestWrapper(t),
						nil,
					),
				},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "bad oplog opt: nil wrapper",
			underlying: nil,
			args: args{
				deleteItems: createFn(),
				opt: []Option{
					WithOplog(
						nil,
						oplog.Metadata{
							"resource-public-id": []string{"doesn't matter since wrapper is nil"},
							"op-type":            []string{oplog.OpType_OP_TYPE_CREATE.String()},
						},
					),
				},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "bad opt: WithLookup",
			underlying: nil,
			args: args{
				deleteItems: createFn(),
				opt:         []Option{WithLookup(true)},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil underlying",
			underlying: nil,
			args: args{
				deleteItems: createFn(),
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "empty items",
			underlying: db,
			args: args{
				deleteItems: []interface{}{},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil items",
			underlying: db,
			args: args{
				deleteItems: nil,
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			rowsDeleted, err := rw.DeleteItems(context.Background(), tt.args.deleteItems, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				assert.Truef(errors.Match(errors.T(tt.wantErrIs), err), "unexpected error: %s", err.Error())
				return
			}
			require.NoError(err)
			assert.Equal(tt.wantRowsDeleted, rowsDeleted)
			for _, item := range tt.args.deleteItems {
				u := db_test.AllocTestUser()
				u.PublicId = item.(*db_test.TestUser).PublicId
				err := rw.LookupByPublicId(context.Background(), &u)
				require.Error(err)
				require.Truef(errors.Match(errors.T(errors.RecordNotFound), err), "found item %s that should be deleted", u.PublicId)
			}
			if tt.wantOplogId != "" {
				err = TestVerifyOplog(t, rw, tt.wantOplogId, WithOperation(oplog.OpType_OP_TYPE_DELETE), WithCreateNotBefore(10*time.Second))
				assert.NoError(err)
			}
			if tt.wantOplogMsgs {
				assert.Equal(len(tt.args.deleteItems), len(returnedMsgs))
				for _, m := range returnedMsgs {
					assert.Equal(m.OpType, oplog.OpType_OP_TYPE_DELETE)
				}
			}
		})
	}
}

func testUser(t *testing.T, conn *gorm.DB, name, email, phoneNumber string) *db_test.TestUser {
	t.Helper()
	require := require.New(t)

	publicId, err := base62.Random(20)
	require.NoError(err)
	u := &db_test.TestUser{
		StoreTestUser: &db_test.StoreTestUser{
			PublicId:    publicId,
			Name:        name,
			Email:       email,
			PhoneNumber: phoneNumber,
		},
	}
	if conn != nil {
		err = conn.Create(u).Error
		require.NoError(err)
	}
	return u
}

func testCar(t *testing.T, conn *gorm.DB, name, model string, mpg int32) *db_test.TestCar {
	t.Helper()
	require := require.New(t)

	publicId, err := base62.Random(20)
	require.NoError(err)
	c := &db_test.TestCar{
		StoreTestCar: &db_test.StoreTestCar{
			PublicId: publicId,
			Name:     name,
			Model:    model,
			Mpg:      mpg,
		},
	}
	if conn != nil {
		err = conn.Create(c).Error
		require.NoError(err)
	}
	return c
}

func testId(t *testing.T) string {
	t.Helper()
	require := require.New(t)
	id, err := uuid.GenerateUUID()
	require.NoError(err)
	return id
}

func testScooter(t *testing.T, conn *gorm.DB, model string, mpg int32) *db_test.TestScooter {
	t.Helper()
	require := require.New(t)

	privateId, err := base62.Random(20)
	require.NoError(err)
	u := &db_test.TestScooter{
		StoreTestScooter: &db_test.StoreTestScooter{
			PrivateId: privateId,
			Model:     model,
			Mpg:       mpg,
		},
	}
	if conn != nil {
		err = conn.Create(u).Error
		require.NoError(err)
	}
	return u
}

func TestDb_LookupById(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	scooter := testScooter(t, db, "", 0)
	user := testUser(t, db, "", "", "")
	type args struct {
		resourceWithIder interface{}
		opt              []Option
	}
	tests := []struct {
		name       string
		underlying *gorm.DB
		args       args
		wantErr    bool
		want       proto.Message
		wantIsErr  errors.Code
	}{
		{
			name:       "simple-private-id",
			underlying: db,
			args: args{
				resourceWithIder: scooter,
			},
			wantErr: false,
			want:    scooter,
		},
		{
			name:       "simple-public-id",
			underlying: db,
			args: args{
				resourceWithIder: user,
			},
			wantErr: false,
			want:    user,
		},
		{
			name:       "missing-public-id",
			underlying: db,
			args: args{
				resourceWithIder: &db_test.TestUser{
					StoreTestUser: &db_test.StoreTestUser{},
				},
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
		{
			name:       "missing-private-id",
			underlying: db,
			args: args{
				resourceWithIder: &db_test.TestScooter{
					StoreTestScooter: &db_test.StoreTestScooter{},
				},
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
		{
			name:       "not-an-ider",
			underlying: db,
			args: args{
				resourceWithIder: &db_test.NotIder{},
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
		{
			name:       "missing-underlying-db",
			underlying: nil,
			args: args{
				resourceWithIder: user,
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			cloner, ok := tt.args.resourceWithIder.(db_test.Cloner)
			require.True(ok)
			cp := cloner.Clone()
			err := rw.LookupById(context.Background(), cp, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				require.True(errors.Match(errors.T(tt.wantIsErr), err))
				return
			}
			require.NoError(err)
			assert.True(proto.Equal(tt.want, cp.(proto.Message)))
		})
	}
	t.Run("not-ptr", func(t *testing.T) {
		u := testUser(t, db, "", "", "")
		rw := &Db{
			underlying: db,
		}
		err := rw.LookupById(context.Background(), *u)
		require.Error(t, err)
		assert.True(t, errors.Match(errors.T(errors.InvalidParameter), err))
	})
}

func TestDb_GetTicket(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	type notReplayable struct{}
	tests := []struct {
		name          string
		underlying    *gorm.DB
		aggregateType interface{}
		wantErr       bool
		wantErrIs     errors.Code
	}{
		{
			name:          "simple",
			underlying:    db,
			aggregateType: &db_test.TestUser{},
			wantErr:       false,
		},
		{
			name:          "not-replayable",
			underlying:    db,
			aggregateType: &notReplayable{},
			wantErr:       true,
			wantErrIs:     errors.InvalidParameter,
		},
		{
			name:          "nil-aggregate-type",
			underlying:    db,
			aggregateType: nil,
			wantErr:       true,
			wantErrIs:     errors.InvalidParameter,
		},
		{
			name:          "no-underlying",
			underlying:    nil,
			aggregateType: &db_test.TestUser{},
			wantErr:       true,
			wantErrIs:     errors.InvalidParameter,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			got, err := rw.GetTicket(tt.aggregateType)
			if tt.wantErr {
				require.Error(err)
				assert.Truef(errors.Match(errors.T(tt.wantErrIs), err), "unexpected error type: %s", err.Error())
				return
			}
			require.NoError(err)
			assert.NotEmpty(got.Name)
			assert.NotEmpty(got.Version)
			assert.NotEmpty(got.CreateTime)
			assert.NotEmpty(got.UpdateTime)
		})
	}
}

func TestDb_WriteOplogEntryWith(t *testing.T) {
	db, _ := TestSetup(t, "postgres")
	w := Db{underlying: db}

	ticket, err := w.GetTicket(&db_test.TestUser{})
	require.NoError(t, err)

	id, err := uuid.GenerateUUID()
	assert.NoError(t, err)
	user, err := db_test.NewTestUser()
	assert.NoError(t, err)
	user.Name = "foo-" + id
	createMsg := oplog.Message{}
	err = w.Create(
		context.Background(),
		user,
		NewOplogMsg(&createMsg),
	)
	require.NoError(t, err)
	metadata := oplog.Metadata{
		"resource-public-id": []string{user.PublicId},
	}

	type args struct {
		wrapper  wrapping.Wrapper
		ticket   *store.Ticket
		metadata oplog.Metadata
		msgs     []*oplog.Message
		opt      []Option
	}
	tests := []struct {
		name            string
		underlying      *gorm.DB
		args            args
		wantErr         bool
		wantErrIs       errors.Code
		wantErrContains string
	}{
		{
			name:       "valid",
			underlying: db,
			args: args{
				wrapper:  TestWrapper(t),
				ticket:   ticket,
				metadata: metadata,
				msgs:     []*oplog.Message{&createMsg},
			},
			wantErr: false,
		},
		{
			name:       "valid-multiple",
			underlying: db,
			args: args{
				wrapper:  TestWrapper(t),
				ticket:   ticket,
				metadata: metadata,
				msgs:     []*oplog.Message{&createMsg, &createMsg},
			},
			wantErr: false,
		},
		{
			name:       "missing-ticket",
			underlying: db,
			args: args{
				wrapper:  TestWrapper(t),
				ticket:   nil,
				metadata: metadata,
				msgs:     []*oplog.Message{&createMsg},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "missing-db",
			underlying: nil,
			args: args{
				wrapper:  TestWrapper(t),
				ticket:   ticket,
				metadata: metadata,
				msgs:     []*oplog.Message{&createMsg},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "missing-wrapper",
			underlying: db,
			args: args{
				wrapper:  nil,
				ticket:   ticket,
				metadata: metadata,
				msgs:     []*oplog.Message{&createMsg},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "nil-metadata",
			underlying: db,
			args: args{
				wrapper:  TestWrapper(t),
				ticket:   ticket,
				metadata: nil,
				msgs:     []*oplog.Message{&createMsg},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
		{
			name:       "empty-metadata",
			underlying: db,
			args: args{
				wrapper:  TestWrapper(t),
				ticket:   ticket,
				metadata: oplog.Metadata{},
				msgs:     []*oplog.Message{&createMsg},
			},
			wantErr:   true,
			wantErrIs: errors.InvalidParameter,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			err := rw.WriteOplogEntryWith(context.Background(), tt.args.wrapper, tt.args.ticket, tt.args.metadata, tt.args.msgs, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				assert.Truef(errors.Match(errors.T(tt.wantErrIs), err), "unexpected error %s", err.Error())
				if tt.wantErrContains != "" {
					assert.Contains(err.Error(), tt.wantErrContains)
				}
				return
			}
			require.NoError(err)
		})
	}
}

func TestClear_InputTypes(t *testing.T) {
	type Z struct {
		F string
	}

	var nilZ *Z
	s := "test-string"

	type args struct {
		v interface{}
		f []string
		d int
	}

	tests := []struct {
		name string
		args args
		want interface{}
		err  errors.Code
	}{
		{
			name: "nil",
			args: args{
				v: nil,
				f: []string{"field"},
				d: 1,
			},
			err: errors.InvalidParameter,
		},
		{
			name: "string",
			args: args{
				v: "blank",
				f: []string{"field"},
				d: 1,
			},
			err: errors.InvalidParameter,
		},
		{
			name: "pointer-to-nil-struct",
			args: args{
				v: nilZ,
				f: []string{"field"},
				d: 1,
			},
			err: errors.InvalidParameter,
		},
		{
			name: "pointer-to-string",
			args: args{
				v: &s,
				f: []string{"field"},
				d: 1,
			},
			err: errors.InvalidParameter,
		},
		{
			name: "not-pointer",
			args: args{
				v: Z{
					F: "foo",
				},
				f: []string{"field"},
				d: 1,
			},
			err: errors.InvalidParameter,
		},
		{
			name: "map",
			args: args{
				v: map[string]int{
					"A": 31,
					"B": 34,
				},
				f: []string{"field"},
				d: 1,
			},
			err: errors.InvalidParameter,
		},
		{
			name: "pointer-to-struct",
			args: args{
				v: &Z{
					F: "foo",
				},
				f: []string{"field"},
				d: 1,
			},
			want: &Z{
				F: "foo",
			},
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			input := tt.args.v
			err := Clear(input, tt.args.f, tt.args.d)
			if tt.err != 0 {
				assert.True(errors.Match(errors.T(tt.err), err))
				return
			}
			require.NoError(err)
			assert.Equal(tt.want, input)
		})
	}
}

func TestClear_Structs(t *testing.T) {
	s := "test-string"

	type A struct{ F string }
	type B struct{ F *string }

	type AB struct {
		A A
		B *B
		F string

		IN io.Reader
		MP map[int]int
		SL []string
		AR [1]int
		CH chan int
		FN func()
	}

	type AFB struct {
		F A
		B *B
	}

	type ABF struct {
		A A
		F *B
	}

	type C struct {
		F  string
		NF string
	}

	type EA struct {
		A
		M  string
		NF string
	}

	type EAP struct {
		*A
		M  string
		NF string
	}

	type DEA struct {
		EA
		F string
	}

	type DEAP struct {
		*EAP
		F string
	}

	type args struct {
		v interface{}
		f []string
		d int
	}
	tests := []struct {
		name string
		args args
		want interface{}
	}{
		{
			name: "blank-A",
			args: args{
				v: &A{},
				f: []string{"F"},
				d: 1,
			},
			want: &A{},
		},
		{
			name: "clear-A",
			args: args{
				v: &A{"clear"},
				f: []string{"F"},
				d: 1,
			},
			want: &A{},
		},
		{
			name: "clear-B",
			args: args{
				v: &B{&s},
				f: []string{"F"},
				d: 1,
			},
			want: &B{},
		},
		{
			name: "clear-C",
			args: args{
				v: &C{"clear", "notclear"},
				f: []string{"F"},
				d: 1,
			},
			want: &C{"", "notclear"},
		},
		{
			name: "shallow-clear-AB",
			args: args{
				v: &AB{
					A: A{"notclear"},
					B: &B{&s},
					F: "clear",
				},
				f: []string{"F"},
				d: 1,
			},
			want: &AB{
				A: A{"notclear"},
				B: &B{&s},
				F: "",
			},
		},
		{
			name: "deep-clear-AB",
			args: args{
				v: &AB{
					A: A{"clear"},
					B: &B{&s},
					F: "clear",
				},
				f: []string{"F"},
				d: 2,
			},
			want: &AB{
				A: A{""},
				B: &B{},
				F: "",
			},
		},
		{
			name: "clear-AFB",
			args: args{
				v: &AFB{
					F: A{"clear"},
					B: &B{&s},
				},
				f: []string{"F"},
				d: 2,
			},
			want: &AFB{
				F: A{""},
				B: &B{},
			},
		},
		{
			name: "clear-ABF",
			args: args{
				v: &ABF{
					A: A{"clear"},
					F: &B{&s},
				},
				f: []string{"F"},
				d: 2,
			},
			want: &ABF{
				A: A{""},
				F: nil,
			},
		},
		{
			name: "embedded-struct",
			args: args{
				v: &EA{
					A:  A{"clear"},
					M:  "clear",
					NF: "notclear",
				},
				f: []string{"F", "M"},
				d: 2,
			},
			want: &EA{
				A:  A{""},
				M:  "",
				NF: "notclear",
			},
		},
		{
			name: "embedded-struct-pointer",
			args: args{
				v: &EAP{
					A:  &A{"clear"},
					M:  "clear",
					NF: "notclear",
				},
				f: []string{"F", "M"},
				d: 2,
			},
			want: &EAP{
				A:  &A{""},
				M:  "",
				NF: "notclear",
			},
		},
		{
			name: "embedded-struct-pointer-extra-depth",
			args: args{
				v: &EAP{
					A:  &A{"clear"},
					M:  "clear",
					NF: "notclear",
				},
				f: []string{"F", "M"},
				d: 12,
			},
			want: &EAP{
				A:  &A{""},
				M:  "",
				NF: "notclear",
			},
		},
		{
			name: "deep-embedded-struct",
			args: args{
				v: &DEA{
					EA: EA{
						A:  A{"clear"},
						M:  "clear",
						NF: "notclear",
					},
					F: "clear",
				},
				f: []string{"F", "M"},
				d: 3,
			},
			want: &DEA{
				EA: EA{
					A:  A{""},
					M:  "",
					NF: "notclear",
				},
				F: "",
			},
		},
		{
			name: "deep-embedded-struct-pointer",
			args: args{
				v: &DEAP{
					EAP: &EAP{
						A:  &A{"clear"},
						M:  "clear",
						NF: "notclear",
					},
					F: "clear",
				},
				f: []string{"F", "M"},
				d: 3,
			},
			want: &DEAP{
				EAP: &EAP{
					A:  &A{""},
					M:  "",
					NF: "notclear",
				},
				F: "",
			},
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			input := tt.args.v
			err := Clear(input, tt.args.f, tt.args.d)
			assert.NotEmpty(s)
			require.NoError(err)
			assert.Equal(tt.want, input)
		})
	}
}

func TestClear_SetFieldsToNil(t *testing.T) {
	type P struct{ F *string }
	type A struct{ F string }

	type EA struct {
		A
		M  string
		NF string
	}

	type EAP struct {
		*A
		M  string
		NF string
	}

	type DEA struct {
		EA
		F string
	}

	type DEAP struct {
		*EAP
		F string
	}

	type args struct {
		v interface{}
		f []string
	}
	tests := []struct {
		name string
		args args
		want interface{}
	}{
		{
			name: "dont-panic",
			args: args{
				v: P{},
				f: []string{"F"},
			},
			want: P{},
		},
		{
			name: "deep-embedded-struct",
			args: args{
				v: &DEA{
					EA: EA{
						A:  A{"notclear"},
						M:  "clear",
						NF: "notclear",
					},
					F: "clear",
				},
				f: []string{"F", "M"},
			},
			want: &DEA{
				EA: EA{
					A:  A{"notclear"},
					M:  "",
					NF: "notclear",
				},
				F: "",
			},
		},
		{
			name: "deep-embedded-struct-pointer",
			args: args{
				v: &DEAP{
					EAP: &EAP{
						A:  &A{"notclear"},
						M:  "clear",
						NF: "notclear",
					},
					F: "clear",
				},
				f: []string{"F", "M"},
			},
			want: &DEAP{
				EAP: &EAP{
					A:  &A{"notclear"},
					M:  "",
					NF: "notclear",
				},
				F: "",
			},
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			input := tt.args.v
			require.NotPanics(func() {
				setFieldsToNil(input, tt.args.f)
			})
			assert.Equal(tt.want, input)
		})
	}
}

func TestDb_oplogMsgsForItems(t *testing.T) {
	t.Parallel()

	// underlying isn't used at this point, so it can just be nil
	rw := Db{underlying: nil}
	var users []interface{}
	var wantUsrMsgs []*oplog.Message
	for i := 0; i < 5; i++ {
		publicId, err := base62.Random(20)
		require.NoError(t, err)
		u := &db_test.TestUser{StoreTestUser: &db_test.StoreTestUser{PublicId: publicId}}
		users = append(users, u)
		wantUsrMsgs = append(
			wantUsrMsgs,
			&oplog.Message{
				Message:  users[i].(proto.Message),
				TypeName: u.TableName(),
				OpType:   oplog.OpType_OP_TYPE_CREATE,
			},
		)
	}

	publicId, err := base62.Random(20)
	require.NoError(t, err)
	mixed := []interface{}{
		&db_test.TestUser{StoreTestUser: &db_test.StoreTestUser{PublicId: publicId}},
		&db_test.TestCar{StoreTestCar: &db_test.StoreTestCar{PublicId: publicId}},
	}

	type args struct {
		opType OpType
		opts   Options
		items  []interface{}
	}
	tests := []struct {
		name      string
		args      args
		want      []*oplog.Message
		wantErr   bool
		wantIsErr errors.Code
	}{
		{
			name: "valid",
			args: args{
				opType: CreateOp,
				items:  users,
			},
			wantErr: false,
			want:    wantUsrMsgs,
		},
		{
			name: "nil items",
			args: args{
				opType: CreateOp,
				items:  nil,
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
		{
			name: "zero items",
			args: args{
				opType: CreateOp,
				items:  []interface{}{},
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
		{
			name: "mixed items",
			args: args{
				opType: CreateOp,
				items:  mixed,
			},
			wantErr:   true,
			wantIsErr: errors.InvalidParameter,
		},
		{
			name: "bad op",
			args: args{
				opType: UnknownOp,
				items:  users,
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			got, err := rw.oplogMsgsForItems(context.Background(), tt.args.opType, tt.args.opts, tt.args.items)
			if tt.wantErr {
				require.Error(err)
				assert.Truef(errors.Match(errors.T(tt.wantIsErr), err), "unexpected error %s", err.Error())
				return
			}
			require.NoError(err)
			assert.Equal(tt.want, got)
		})
	}
}

func TestDb_lookupAfterWrite(t *testing.T) {
	t.Parallel()
	db, _ := TestSetup(t, "postgres")
	scooter := testScooter(t, db, "", 0)
	user := testUser(t, db, "", "", "")
	type args struct {
		resourceWithIder interface{}
		opt              []Option
	}
	tests := []struct {
		name       string
		underlying *gorm.DB
		args       args
		wantErr    bool
		want       proto.Message
		wantIsErr  error
	}{
		{
			name:       "simple-private-id",
			underlying: db,
			args: args{
				resourceWithIder: scooter,
				opt:              []Option{WithLookup(true)},
			},
			wantErr: false,
			want:    scooter,
		},
		{
			name:       "simple-public-id",
			underlying: db,
			args: args{
				resourceWithIder: user,
				opt:              []Option{WithLookup(true)},
			},
			wantErr: false,
			want:    user,
		},
		{
			name:       "no-lookup-private-id",
			underlying: db,
			args: args{
				resourceWithIder: scooter,
				opt:              []Option{WithLookup(false)},
			},
			wantErr: false,
			want:    nil,
		},
		{
			name:       "no-lookup-public-id",
			underlying: db,
			args: args{
				resourceWithIder: user,
				opt:              []Option{WithLookup(false)},
			},
			wantErr: false,
			want:    nil,
		},
		{
			name:       "not-an-ider",
			underlying: db,
			args: args{
				resourceWithIder: &db_test.NotIder{},
				opt:              []Option{WithLookup(true)},
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert, require := assert.New(t), require.New(t)
			rw := &Db{
				underlying: tt.underlying,
			}
			cloner, ok := tt.args.resourceWithIder.(db_test.Cloner)
			require.True(ok)
			cp := cloner.Clone()
			err := rw.lookupAfterWrite(context.Background(), cp, tt.args.opt...)
			if tt.wantErr {
				require.Error(err)
				return
			}
			require.NoError(err)
			if tt.want != nil {
				assert.True(proto.Equal(tt.want, cp.(proto.Message)))
			}
		})
	}
}