23 files changed, 571 insertions(+), 490 deletions(-)

M internal/c/c_mock.go
M internal/c/c_test.go
M internal/c/content/content.go
M internal/c/content/content_mock.go
M internal/c/content/content_test.go
M internal/c/contenttype/contenttype.go
M internal/c/contenttype/contenttype_mock.go
M internal/c/contenttype/contenttype_test.go
M internal/c/doc/doc.go
R internal/c/doc/{mock.go => doc_mock.go}
M internal/c/doc/doc_test.go
R internal/c/file/{mock.go => file_mock.go}
M internal/c/file/file_test.go
M internal/c/hook/hook_mock.go
M internal/c/hook/hook_test.go
R internal/c/redirect/{mock.go => redirect_mock.go}
M internal/c/redirect/redirect_test.go
M internal/c/space/space.go
M internal/c/space/space_mock.go
M internal/c/space/space_test.go
A internal/c/stripe/stripe_mock.go
M internal/c/user/user_mock.go
M internal/c/user/user_test.go

@@ 5,6 5,7 @@
 package c
 
 import (
+	context "context"
 	user "git.sr.ht/~evanj/cms/internal/m/user"
 	gomock "github.com/golang/mock/gomock"
 	reflect "reflect"


@@ 34,31 35,31 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }

@@ 21,6 21,7 @@ import (
 
 var (
 	tmpl = template.Must(template.New("c_test").Parse("sup earth"))
+	ctx  = gomock.Any()
 )
 
 type server struct{ *c.Controller }


@@ 210,7 211,7 @@ func TestUserFromBasicAuth(t *testing.T) {
 		u     = userT.NewMock(uname, upass)
 	)
 
-	db.EXPECT().UserGet(uname, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, uname, upass).Return(u, nil).AnyTimes()
 
 	req, _ := http.NewRequest("GET", ts.URL, nil)
 	req.SetBasicAuth(uname, upass)


@@ 235,7 236,7 @@ func TestUserFromFromCookie(t *testing.T) {
 		u      = userT.NewMock(uname, upass)
 	)
 
-	db.EXPECT().UserGetFromToken(cookie).Return(u, nil).AnyTimes()
+	db.EXPECT().UserGetFromToken(ctx, cookie).Return(u, nil).AnyTimes()
 
 	req, _ := http.NewRequest("GET", ts.URL, nil)
 	req.AddCookie(&http.Cookie{


@@ 262,7 263,7 @@ func TestUserFromFromCookieFail(t *testing.T) {
 		cookie = uuid.New().String()
 	)
 
-	db.EXPECT().UserGetFromToken(cookie).Return(nil, errors.New("no user")).AnyTimes()
+	db.EXPECT().UserGetFromToken(ctx, cookie).Return(nil, errors.New("no user")).AnyTimes()
 
 	req, _ := http.NewRequest("GET", ts.URL, nil)
 	res, _ := http.DefaultClient.Do(req)

@@ 47,8 47,8 @@ type dber interface {
 	ContentTypeGet(ctx context.Context, u user.User, space space.Space, contenttypeID string) (contenttype.ContentType, error)
 	ContentNew(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, params []db.ContentNewParam) (content.Content, error)
 	ContentGet(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, contentID string) (content.Content, error)
-	ContentUpdate(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, content content.Content, newParams []db.ContentNewParam, updateParams []db.ContentUpdateParam) (content.Content, error)
-	ContentDelete(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, content content.Content) error
+	ContentUpdate(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, c content.Content, newParams []db.ContentNewParam, updateParams []db.ContentUpdateParam) (content.Content, error)
+	ContentDelete(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, c content.Content) error
 	ContentSearch(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, name, query string, before int) (content.ContentList, error)
 }
 

@@ 6,9 6,6 @@ package content
 
 import (
 	context "context"
-	io "io"
-	reflect "reflect"
-
 	content "git.sr.ht/~evanj/cms/internal/m/content"
 	contenttype "git.sr.ht/~evanj/cms/internal/m/contenttype"
 	space "git.sr.ht/~evanj/cms/internal/m/space"


@@ 16,163 13,165 @@ import (
 	db "git.sr.ht/~evanj/cms/internal/s/db"
 	hook "git.sr.ht/~evanj/cms/internal/s/hook"
 	gomock "github.com/golang/mock/gomock"
+	io "io"
+	reflect "reflect"
 )
 
-// MockDBer is a mock of DBer interface
-type MockDBer struct {
+// Mockdber is a mock of dber interface
+type Mockdber struct {
 	ctrl     *gomock.Controller
-	recorder *MockDBerMockRecorder
+	recorder *MockdberMockRecorder
 }
 
-// MockDBerMockRecorder is the mock recorder for MockDBer
-type MockDBerMockRecorder struct {
-	mock *MockDBer
+// MockdberMockRecorder is the mock recorder for Mockdber
+type MockdberMockRecorder struct {
+	mock *Mockdber
 }
 
-// NewMockDBer creates a new mock instance
-func NewMockDBer(ctrl *gomock.Controller) *MockDBer {
-	mock := &MockDBer{ctrl: ctrl}
-	mock.recorder = &MockDBerMockRecorder{mock}
+// NewMockdber creates a new mock instance
+func NewMockdber(ctrl *gomock.Controller) *Mockdber {
+	mock := &Mockdber{ctrl: ctrl}
+	mock.recorder = &MockdberMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockDBer) EXPECT() *MockDBerMockRecorder {
+func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 	return m.recorder
 }
 
 // UserGet mocks base method
-func (m *MockDBer) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockDBerMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*MockDBer)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *MockDBer) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockDBerMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*MockDBer)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }
 
 // SpaceGet mocks base method
-func (m *MockDBer) SpaceGet(user user.User, spaceID string) (space.Space, error) {
+func (m *Mockdber) SpaceGet(ctx context.Context, user user.User, spaceID string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceGet", user, spaceID)
+	ret := m.ctrl.Call(m, "SpaceGet", ctx, user, spaceID)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceGet indicates an expected call of SpaceGet
-func (mr *MockDBerMockRecorder) SpaceGet(user, spaceID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceGet(ctx, user, spaceID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*MockDBer)(nil).SpaceGet), user, spaceID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), ctx, user, spaceID)
 }
 
 // ContentTypeGet mocks base method
-func (m *MockDBer) ContentTypeGet(u user.User, space space.Space, contenttypeID string) (contenttype.ContentType, error) {
+func (m *Mockdber) ContentTypeGet(ctx context.Context, u user.User, space space.Space, contenttypeID string) (contenttype.ContentType, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypeGet", u, space, contenttypeID)
+	ret := m.ctrl.Call(m, "ContentTypeGet", ctx, u, space, contenttypeID)
 	ret0, _ := ret[0].(contenttype.ContentType)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentTypeGet indicates an expected call of ContentTypeGet
-func (mr *MockDBerMockRecorder) ContentTypeGet(u, space, contenttypeID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypeGet(ctx, u, space, contenttypeID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeGet", reflect.TypeOf((*MockDBer)(nil).ContentTypeGet), u, space, contenttypeID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeGet", reflect.TypeOf((*Mockdber)(nil).ContentTypeGet), ctx, u, space, contenttypeID)
 }
 
 // ContentNew mocks base method
-func (m *MockDBer) ContentNew(u user.User, space space.Space, ct contenttype.ContentType, params []db.ContentNewParam) (content.Content, error) {
+func (m *Mockdber) ContentNew(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, params []db.ContentNewParam) (content.Content, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentNew", u, space, ct, params)
+	ret := m.ctrl.Call(m, "ContentNew", ctx, u, space, ct, params)
 	ret0, _ := ret[0].(content.Content)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentNew indicates an expected call of ContentNew
-func (mr *MockDBerMockRecorder) ContentNew(u, space, ct, params interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentNew(ctx, u, space, ct, params interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentNew", reflect.TypeOf((*MockDBer)(nil).ContentNew), u, space, ct, params)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentNew", reflect.TypeOf((*Mockdber)(nil).ContentNew), ctx, u, space, ct, params)
 }
 
 // ContentGet mocks base method
-func (m *MockDBer) ContentGet(u user.User, space space.Space, ct contenttype.ContentType, contentID string) (content.Content, error) {
+func (m *Mockdber) ContentGet(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, contentID string) (content.Content, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentGet", u, space, ct, contentID)
+	ret := m.ctrl.Call(m, "ContentGet", ctx, u, space, ct, contentID)
 	ret0, _ := ret[0].(content.Content)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentGet indicates an expected call of ContentGet
-func (mr *MockDBerMockRecorder) ContentGet(u, space, ct, contentID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentGet(ctx, u, space, ct, contentID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentGet", reflect.TypeOf((*MockDBer)(nil).ContentGet), u, space, ct, contentID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentGet", reflect.TypeOf((*Mockdber)(nil).ContentGet), ctx, u, space, ct, contentID)
 }
 
 // ContentUpdate mocks base method
-func (m *MockDBer) ContentUpdate(u user.User, space space.Space, ct contenttype.ContentType, c content.Content, newParams []db.ContentNewParam, updateParams []db.ContentUpdateParam) (content.Content, error) {
+func (m *Mockdber) ContentUpdate(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, c content.Content, newParams []db.ContentNewParam, updateParams []db.ContentUpdateParam) (content.Content, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentUpdate", u, space, ct, c, newParams, updateParams)
+	ret := m.ctrl.Call(m, "ContentUpdate", ctx, u, space, ct, c, newParams, updateParams)
 	ret0, _ := ret[0].(content.Content)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentUpdate indicates an expected call of ContentUpdate
-func (mr *MockDBerMockRecorder) ContentUpdate(u, space, ct, content, newParams, updateParams interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentUpdate(ctx, u, space, ct, c, newParams, updateParams interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentUpdate", reflect.TypeOf((*MockDBer)(nil).ContentUpdate), u, space, ct, content, newParams, updateParams)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentUpdate", reflect.TypeOf((*Mockdber)(nil).ContentUpdate), ctx, u, space, ct, c, newParams, updateParams)
 }
 
 // ContentDelete mocks base method
-func (m *MockDBer) ContentDelete(u user.User, space space.Space, ct contenttype.ContentType, content content.Content) error {
+func (m *Mockdber) ContentDelete(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, c content.Content) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentDelete", u, space, ct, content)
+	ret := m.ctrl.Call(m, "ContentDelete", ctx, u, space, ct, c)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // ContentDelete indicates an expected call of ContentDelete
-func (mr *MockDBerMockRecorder) ContentDelete(u, space, ct, content interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentDelete(ctx, u, space, ct, c interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentDelete", reflect.TypeOf((*MockDBer)(nil).ContentDelete), u, space, ct, content)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentDelete", reflect.TypeOf((*Mockdber)(nil).ContentDelete), ctx, u, space, ct, c)
 }
 
 // ContentSearch mocks base method
-func (m *MockDBer) ContentSearch(u user.User, space space.Space, ct contenttype.ContentType, name, query string, before int) (content.ContentList, error) {
+func (m *Mockdber) ContentSearch(ctx context.Context, u user.User, space space.Space, ct contenttype.ContentType, name, query string, before int) (content.ContentList, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentSearch", u, space, ct, name, query, before)
+	ret := m.ctrl.Call(m, "ContentSearch", ctx, u, space, ct, name, query, before)
 	ret0, _ := ret[0].(content.ContentList)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentSearch indicates an expected call of ContentSearch
-func (mr *MockDBerMockRecorder) ContentSearch(u, space, ct, name, query, before interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentSearch(ctx, u, space, ct, name, query, before interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentSearch", reflect.TypeOf((*MockDBer)(nil).ContentSearch), u, space, ct, name, query, before)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentSearch", reflect.TypeOf((*Mockdber)(nil).ContentSearch), ctx, u, space, ct, name, query, before)
 }
 
 // MockE3er is a mock of E3er interface


@@ 237,13 236,13 @@ func (m *MockHooker) EXPECT() *MockHookerMockRecorder {
 }
 
 // Do mocks base method
-func (m *MockHooker) Do(user user.User, space space.Space, content content.Content, ht hook.HookType) {
+func (m *MockHooker) Do(ctx context.Context, user user.User, space space.Space, content content.Content, ht hook.HookType) {
 	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Do", user, space, content, ht)
+	m.ctrl.Call(m, "Do", ctx, user, space, content, ht)
 }
 
 // Do indicates an expected call of Do
-func (mr *MockHookerMockRecorder) Do(user, space, content, ht interface{}) *gomock.Call {
+func (mr *MockHookerMockRecorder) Do(ctx, user, space, content, ht interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockHooker)(nil).Do), user, space, content, ht)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockHooker)(nil).Do), ctx, user, space, content, ht)
 }

@@ 28,7 28,10 @@ import (
 	"github.com/google/uuid"
 )
 
-var file, _ = os.Open("testfiles/zoidberg.png")
+var (
+	file, _ = os.Open("testfiles/zoidberg.png")
+	ctx     = gomock.Any()
+)
 
 func bodyWithFile(name string, form url.Values) (io.Reader, string) {
 	var requestBody bytes.Buffer


@@ 159,7 162,7 @@ func TestCreateGood(t *testing.T) {
 		}
 
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 179,12 182,12 @@ func TestCreateGood(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentNew(u, s, ct, nmatcher{newParams}).Return(c, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentNew(ctx, u, s, ct, nmatcher{newParams}).Return(c, nil).AnyTimes()
 	e3.EXPECT().Upload(gomock.Any(), false, gomock.Any(), gomock.Any()).Return(fileURL, nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookNew).Return().AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookNew).Return().AnyTimes()
 
 	bod, headerCT := bodyWithFile("File-image", form)
 	req, _ := http.NewRequest("POST", ts.URL, bod)


@@ 213,7 216,7 @@ func TestUpdateGood(t *testing.T) {
 		}
 
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 236,13 239,13 @@ func TestUpdateGood(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentGet(u, s, ct, c.ID()).Return(c, nil).AnyTimes()
-	db.EXPECT().ContentUpdate(u, s, ct, c, nmatcher{newParams}, umatcher{updateParams}).Return(c, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentGet(ctx, u, s, ct, c.ID()).Return(c, nil).AnyTimes()
+	db.EXPECT().ContentUpdate(ctx, u, s, ct, c, nmatcher{newParams}, umatcher{updateParams}).Return(c, nil).AnyTimes()
 	e3.EXPECT().Upload(gomock.Any(), false, gomock.Any(), gomock.Any()).Return(fileURL, nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookUpdate).Return().AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookUpdate).Return().AnyTimes()
 
 	bod, headerCT := bodyWithFile("File-image", form)
 	req, _ := http.NewRequest("POST", ts.URL, bod)


@@ 271,7 274,7 @@ func TestUpdateGood2(t *testing.T) {
 		}
 
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 294,13 297,13 @@ func TestUpdateGood2(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentGet(u, s, ct, c.ID()).Return(c, nil).AnyTimes()
-	db.EXPECT().ContentUpdate(u, s, ct, c, nmatcher{newParams}, umatcher{updateParams}).Return(c, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentGet(ctx, u, s, ct, c.ID()).Return(c, nil).AnyTimes()
+	db.EXPECT().ContentUpdate(ctx, u, s, ct, c, nmatcher{newParams}, umatcher{updateParams}).Return(c, nil).AnyTimes()
 	e3.EXPECT().Upload(gomock.Any(), false, gomock.Any(), gomock.Any()).Return(fileURL, nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookUpdate).Return().AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookUpdate).Return().AnyTimes()
 
 	bod, headerCT := bodyWithFile("value_update_File-4-image", form)
 	req, _ := http.NewRequest("POST", ts.URL, bod)


@@ 316,7 319,7 @@ func TestServeGood(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 335,11 338,11 @@ func TestServeGood(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentGet(u, s, ct, c.ID()).Return(c, nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookNew).Return().AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentGet(ctx, u, s, ct, c.ID()).Return(c, nil).AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookNew).Return().AnyTimes()
 
 	req, _ := http.NewRequest("POST", ts.URL,
 		strings.NewReader(form.Encode()))


@@ 355,7 358,7 @@ func TestServeGood2(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 373,11 376,11 @@ func TestServeGood2(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentGet(u, s, ct, c.ID()).Return(c, nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookNew).Return().AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentGet(ctx, u, s, ct, c.ID()).Return(c, nil).AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookNew).Return().AnyTimes()
 
 	req, _ := http.NewRequest("GET", ts.URL+"?"+form.Encode(), nil)
 	req.SetBasicAuth(u.Name(), u.Pass())


@@ 390,7 393,7 @@ func TestServeGood3(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 402,11 405,11 @@ func TestServeGood3(t *testing.T) {
 		c  = fakecontent{uuid.New().String(), ct.ID(), nil}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentGet(u, s, ct, c.ID()).Return(c, nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookNew).Return().AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentGet(ctx, u, s, ct, c.ID()).Return(c, nil).AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookNew).Return().AnyTimes()
 
 	req, _ := http.NewRequest("GET", fmt.Sprintf("%s/content/%s/%s/%s", ts.URL, s.ID(), ct.ID(), c.ID()), nil)
 	req.SetBasicAuth(u.Name(), u.Pass())


@@ 419,7 422,7 @@ func TestDeleteGood(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 437,12 440,12 @@ func TestDeleteGood(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentGet(u, s, ct, c.ID()).Return(c, nil).AnyTimes()
-	db.EXPECT().ContentDelete(u, s, ct, c).Return(nil).AnyTimes()
-	h.EXPECT().Do(u, s, c, webhook.HookDelete).Return().AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentGet(ctx, u, s, ct, c.ID()).Return(c, nil).AnyTimes()
+	db.EXPECT().ContentDelete(ctx, u, s, ct, c).Return(nil).AnyTimes()
+	h.EXPECT().Do(ctx, u, s, c, webhook.HookDelete).Return().AnyTimes()
 
 	req, _ := http.NewRequest("DELETE", ts.URL+"?"+form.Encode(), nil)
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")


@@ 457,7 460,7 @@ func TestSearchGood(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = content.NewMockDBer(ctrl)
+		db   = content.NewMockdber(ctrl)
 		e3   = content.NewMockE3er(ctrl)
 		h    = content.NewMockHooker(ctrl)
 		l    = log.New(os.Stdout, "", 0)


@@ 476,10 479,10 @@ func TestSearchGood(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-	db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-	db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(ct, nil).AnyTimes()
-	db.EXPECT().ContentSearch(u, s, ct, "name", "garfield", 0).Return(cl, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+	db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+	db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(ct, nil).AnyTimes()
+	db.EXPECT().ContentSearch(ctx, u, s, ct, "name", "garfield", 0).Return(cl, nil).AnyTimes()
 
 	req, _ := http.NewRequest("GET", ts.URL+"?"+form.Encode(), nil)
 	req.SetBasicAuth(u.Name(), u.Pass())


@@ 503,7 506,7 @@ func TestBad(t *testing.T) {
 		sc   int
 		err  error
 		form url.Values
-		mock func(*content.MockDBer, *content.MockE3er, *content.MockHooker)
+		mock func(*content.Mockdber, *content.MockE3er, *content.MockHooker)
 	}
 
 	tests := []spec{


@@ 514,8 517,8 @@ func TestBad(t *testing.T) {
 			url.Values{
 				"method": {"GET"},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 525,8 528,8 @@ func TestBad(t *testing.T) {
 				"method": {"GET"},
 				"query":  {"placeholder"},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 535,8 538,8 @@ func TestBad(t *testing.T) {
 			url.Values{
 				"method": {"PATCH"},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 545,8 548,8 @@ func TestBad(t *testing.T) {
 			url.Values{
 				"method": {"DELETE"},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 555,8 558,8 @@ func TestBad(t *testing.T) {
 			url.Values{
 				"method": {"POST"},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(nil, err).AnyTimes()
 			},
 		},
 		// No space.


@@ 567,9 570,9 @@ func TestBad(t *testing.T) {
 				"method": {"GET"},
 				"space":  {s.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 580,9 583,9 @@ func TestBad(t *testing.T) {
 				"query":  {"placeholder"},
 				"space":  {s.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 592,9 595,9 @@ func TestBad(t *testing.T) {
 				"method": {"PATCH"},
 				"space":  {s.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 604,9 607,9 @@ func TestBad(t *testing.T) {
 				"method": {"DELETE"},
 				"space":  {s.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 616,9 619,9 @@ func TestBad(t *testing.T) {
 				"method": {"POST"},
 				"space":  {s.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		// No content type


@@ 630,10 633,10 @@ func TestBad(t *testing.T) {
 				"space":       {s.ID()},
 				"contenttype": {ct.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-				db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+				db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 645,10 648,10 @@ func TestBad(t *testing.T) {
 				"space":       {s.ID()},
 				"contenttype": {ct.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-				db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+				db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 659,10 662,10 @@ func TestBad(t *testing.T) {
 				"space":       {s.ID()},
 				"contenttype": {ct.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-				db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+				db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 673,10 676,10 @@ func TestBad(t *testing.T) {
 				"space":       {s.ID()},
 				"contenttype": {ct.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-				db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+				db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 687,10 690,10 @@ func TestBad(t *testing.T) {
 				"space":       {s.ID()},
 				"contenttype": {ct.ID()},
 			},
-			func(db *content.MockDBer, e3 *content.MockE3er, h *content.MockHooker) {
-				db.EXPECT().UserGet(u.Name(), u.Pass()).Return(u, nil).AnyTimes()
-				db.EXPECT().SpaceGet(u, s.ID()).Return(s, nil).AnyTimes()
-				db.EXPECT().ContentTypeGet(u, s, ct.ID()).Return(nil, err).AnyTimes()
+			func(db *content.Mockdber, e3 *content.MockE3er, h *content.MockHooker) {
+				db.EXPECT().UserGet(ctx, u.Name(), u.Pass()).Return(u, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, u, s.ID()).Return(s, nil).AnyTimes()
+				db.EXPECT().ContentTypeGet(ctx, u, s, ct.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 	}


@@ 698,7 701,7 @@ func TestBad(t *testing.T) {
 	for _, test := range tests {
 		var (
 			ctrl = gomock.NewController(t)
-			db   = content.NewMockDBer(ctrl)
+			db   = content.NewMockdber(ctrl)
 			e3   = content.NewMockE3er(ctrl)
 			h    = content.NewMockHooker(ctrl)
 			l    = log.New(os.Stdout, "", 0)

@@ 46,7 46,7 @@ type dber interface {
 	SpaceGet(ctx context.Context, user user.User, spaceID string) (space.Space, error)
 	ContentTypeNew(ctx context.Context, user user.User, space space.Space, name string, params []db.ContentTypeNewParam) (contenttype.ContentType, error)
 	ContentTypeGet(ctx context.Context, user user.User, space space.Space, contenttypeID string) (contenttype.ContentType, error)
-	ContentTypeUpdate(ctx context.Context, user user.User, space space.Space, contenttype contenttype.ContentType, name string, newParams []db.ContentTypeNewParam, updateParams []db.ContentTypeUpdateParam) (contenttype.ContentType, error)
+	ContentTypeUpdate(ctx context.Context, user user.User, space space.Space, ct contenttype.ContentType, name string, newParams []db.ContentTypeNewParam, updateParams []db.ContentTypeUpdateParam) (contenttype.ContentType, error)
 	ContentTypeDelete(ctx context.Context, user user.User, space space.Space, ct contenttype.ContentType) error
 	ContentTypeSearch(ctx context.Context, user user.User, space space.Space, query string, before int) (contenttype.ContentTypeList, error)
 	ContentPerContentType(ctx context.Context, user user.User, space space.Space, ct contenttype.ContentType, before int, order db.OrderType, sortField string) (content.ContentList, error)

@@ 5,14 5,14 @@
 package contenttype
 
 import (
-	reflect "reflect"
-
+	context "context"
 	content "git.sr.ht/~evanj/cms/internal/m/content"
 	contenttype "git.sr.ht/~evanj/cms/internal/m/contenttype"
 	space "git.sr.ht/~evanj/cms/internal/m/space"
 	user "git.sr.ht/~evanj/cms/internal/m/user"
 	db "git.sr.ht/~evanj/cms/internal/s/db"
 	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
 )
 
 // Mockdber is a mock of dber interface


@@ 39,135 39,135 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }
 
 // SpaceGet mocks base method
-func (m *Mockdber) SpaceGet(user user.User, spaceID string) (space.Space, error) {
+func (m *Mockdber) SpaceGet(ctx context.Context, user user.User, spaceID string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceGet", user, spaceID)
+	ret := m.ctrl.Call(m, "SpaceGet", ctx, user, spaceID)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceGet indicates an expected call of SpaceGet
-func (mr *MockdberMockRecorder) SpaceGet(user, spaceID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceGet(ctx, user, spaceID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), user, spaceID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), ctx, user, spaceID)
 }
 
 // ContentTypeNew mocks base method
-func (m *Mockdber) ContentTypeNew(user user.User, space space.Space, name string, params []db.ContentTypeNewParam) (contenttype.ContentType, error) {
+func (m *Mockdber) ContentTypeNew(ctx context.Context, user user.User, space space.Space, name string, params []db.ContentTypeNewParam) (contenttype.ContentType, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypeNew", user, space, name, params)
+	ret := m.ctrl.Call(m, "ContentTypeNew", ctx, user, space, name, params)
 	ret0, _ := ret[0].(contenttype.ContentType)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentTypeNew indicates an expected call of ContentTypeNew
-func (mr *MockdberMockRecorder) ContentTypeNew(user, space, name, params interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypeNew(ctx, user, space, name, params interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeNew", reflect.TypeOf((*Mockdber)(nil).ContentTypeNew), user, space, name, params)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeNew", reflect.TypeOf((*Mockdber)(nil).ContentTypeNew), ctx, user, space, name, params)
 }
 
 // ContentTypeGet mocks base method
-func (m *Mockdber) ContentTypeGet(user user.User, space space.Space, contenttypeID string) (contenttype.ContentType, error) {
+func (m *Mockdber) ContentTypeGet(ctx context.Context, user user.User, space space.Space, contenttypeID string) (contenttype.ContentType, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypeGet", user, space, contenttypeID)
+	ret := m.ctrl.Call(m, "ContentTypeGet", ctx, user, space, contenttypeID)
 	ret0, _ := ret[0].(contenttype.ContentType)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentTypeGet indicates an expected call of ContentTypeGet
-func (mr *MockdberMockRecorder) ContentTypeGet(user, space, contenttypeID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypeGet(ctx, user, space, contenttypeID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeGet", reflect.TypeOf((*Mockdber)(nil).ContentTypeGet), user, space, contenttypeID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeGet", reflect.TypeOf((*Mockdber)(nil).ContentTypeGet), ctx, user, space, contenttypeID)
 }
 
 // ContentTypeUpdate mocks base method
-func (m *Mockdber) ContentTypeUpdate(user user.User, space space.Space, ct contenttype.ContentType, name string, newParams []db.ContentTypeNewParam, updateParams []db.ContentTypeUpdateParam) (contenttype.ContentType, error) {
+func (m *Mockdber) ContentTypeUpdate(ctx context.Context, user user.User, space space.Space, ct contenttype.ContentType, name string, newParams []db.ContentTypeNewParam, updateParams []db.ContentTypeUpdateParam) (contenttype.ContentType, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypeUpdate", user, space, ct, name, newParams, updateParams)
+	ret := m.ctrl.Call(m, "ContentTypeUpdate", ctx, user, space, ct, name, newParams, updateParams)
 	ret0, _ := ret[0].(contenttype.ContentType)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentTypeUpdate indicates an expected call of ContentTypeUpdate
-func (mr *MockdberMockRecorder) ContentTypeUpdate(user, space, contenttype, name, newParams, updateParams interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypeUpdate(ctx, user, space, ct, name, newParams, updateParams interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeUpdate", reflect.TypeOf((*Mockdber)(nil).ContentTypeUpdate), user, space, contenttype, name, newParams, updateParams)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeUpdate", reflect.TypeOf((*Mockdber)(nil).ContentTypeUpdate), ctx, user, space, ct, name, newParams, updateParams)
 }
 
 // ContentTypeDelete mocks base method
-func (m *Mockdber) ContentTypeDelete(user user.User, space space.Space, ct contenttype.ContentType) error {
+func (m *Mockdber) ContentTypeDelete(ctx context.Context, user user.User, space space.Space, ct contenttype.ContentType) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypeDelete", user, space, ct)
+	ret := m.ctrl.Call(m, "ContentTypeDelete", ctx, user, space, ct)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // ContentTypeDelete indicates an expected call of ContentTypeDelete
-func (mr *MockdberMockRecorder) ContentTypeDelete(user, space, ct interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypeDelete(ctx, user, space, ct interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeDelete", reflect.TypeOf((*Mockdber)(nil).ContentTypeDelete), user, space, ct)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeDelete", reflect.TypeOf((*Mockdber)(nil).ContentTypeDelete), ctx, user, space, ct)
 }
 
 // ContentTypeSearch mocks base method
-func (m *Mockdber) ContentTypeSearch(user user.User, space space.Space, query string, before int) (contenttype.ContentTypeList, error) {
+func (m *Mockdber) ContentTypeSearch(ctx context.Context, user user.User, space space.Space, query string, before int) (contenttype.ContentTypeList, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypeSearch", user, space, query, before)
+	ret := m.ctrl.Call(m, "ContentTypeSearch", ctx, user, space, query, before)
 	ret0, _ := ret[0].(contenttype.ContentTypeList)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentTypeSearch indicates an expected call of ContentTypeSearch
-func (mr *MockdberMockRecorder) ContentTypeSearch(user, space, query, before interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypeSearch(ctx, user, space, query, before interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeSearch", reflect.TypeOf((*Mockdber)(nil).ContentTypeSearch), user, space, query, before)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypeSearch", reflect.TypeOf((*Mockdber)(nil).ContentTypeSearch), ctx, user, space, query, before)
 }
 
 // ContentPerContentType mocks base method
-func (m *Mockdber) ContentPerContentType(user user.User, space space.Space, ct contenttype.ContentType, before int, order db.OrderType, sortField string) (content.ContentList, error) {
+func (m *Mockdber) ContentPerContentType(ctx context.Context, user user.User, space space.Space, ct contenttype.ContentType, before int, order db.OrderType, sortField string) (content.ContentList, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentPerContentType", user, space, ct, before, order, sortField)
+	ret := m.ctrl.Call(m, "ContentPerContentType", ctx, user, space, ct, before, order, sortField)
 	ret0, _ := ret[0].(content.ContentList)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentPerContentType indicates an expected call of ContentPerContentType
-func (mr *MockdberMockRecorder) ContentPerContentType(user, space, ct, before, order, sortField interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentPerContentType(ctx, user, space, ct, before, order, sortField interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentPerContentType", reflect.TypeOf((*Mockdber)(nil).ContentPerContentType), user, space, ct, before, order, sortField)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentPerContentType", reflect.TypeOf((*Mockdber)(nil).ContentPerContentType), ctx, user, space, ct, before, order, sortField)
 }

@@ 22,6 22,8 @@ import (
 	"github.com/google/uuid"
 )
 
+var ctx = gomock.Any()
+
 func TestNoUser(t *testing.T) {
 	t.Parallel()
 


@@ 91,9 93,9 @@ func TestContentTypeHappyPath(t *testing.T) {
 				newParams := []db.ContentTypeNewParam{
 					{"name", string(valuetype.StringSmall)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeNew(uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeNew(ctx, uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 116,10 118,10 @@ func TestContentTypeHappyPath(t *testing.T) {
 				updateParams := []db.ContentTypeUpdateParam{
 					{"1234", "desc", string(valuetype.StringBig)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeUpdate(uItem, sItem, ctItemUpdate, ctItemUpdate.Name(), newParams, updateParams).Return(ctItemUpdate, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItemUpdate.ID()).Return(ctItemUpdate, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeUpdate(ctx, uItem, sItem, ctItemUpdate, ctItemUpdate.Name(), newParams, updateParams).Return(ctItemUpdate, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItemUpdate.ID()).Return(ctItemUpdate, nil).AnyTimes()
 			},
 		},
 		{


@@ 130,10 132,10 @@ func TestContentTypeHappyPath(t *testing.T) {
 				"method":      {"GET"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(m *contenttype.Mockdber) {
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
-				m.EXPECT().ContentPerContentType(uItem, sItem, ctItem, 0, db.OrderAsc, "name").Return(cl, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().ContentPerContentType(ctx, uItem, sItem, ctItem, 0, db.OrderAsc, "name").Return(cl, nil).AnyTimes()
 			},
 		},
 		{


@@ 144,10 146,10 @@ func TestContentTypeHappyPath(t *testing.T) {
 				"method": {"GET"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(m *contenttype.Mockdber) {
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeSearch(uItem, sItem, "post", 0).Return(ctl, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeSearch(ctx, uItem, sItem, "post", 0).Return(ctl, nil).AnyTimes()
 			},
 		},
 		{


@@ 159,10 161,10 @@ func TestContentTypeHappyPath(t *testing.T) {
 				"method":      {"GET"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(m *contenttype.Mockdber) {
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
-				m.EXPECT().ContentPerContentType(uItem, sItem, ctItem, 0, db.OrderDesc, "name").Return(cl, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().ContentPerContentType(ctx, uItem, sItem, ctItem, 0, db.OrderDesc, "name").Return(cl, nil).AnyTimes()
 			},
 		},
 		{


@@ 173,10 175,10 @@ func TestContentTypeHappyPath(t *testing.T) {
 				"method":      {"DELETE"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(m *contenttype.Mockdber) {
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeDelete(uItem, sItem, ctItem).Return(nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItem.ID()).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeDelete(ctx, uItem, sItem, ctItem).Return(nil).AnyTimes()
 			},
 		},
 	}


@@ 238,9 240,9 @@ func TestContentTypeBadPath(t *testing.T) {
 				newParams := []db.ContentTypeNewParam{
 					{"name", string(valuetype.StringSmall)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeNew(uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeNew(ctx, uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 257,9 259,9 @@ func TestContentTypeBadPath(t *testing.T) {
 				newParams := []db.ContentTypeNewParam{
 					{"name", string(valuetype.StringSmall)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeNew(uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeNew(ctx, uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 276,9 278,9 @@ func TestContentTypeBadPath(t *testing.T) {
 				newParams := []db.ContentTypeNewParam{
 					{"name", string(valuetype.StringSmall)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeNew(uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeNew(ctx, uItem, sItem, ctItem.Name(), newParams).Return(ctItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 295,9 297,9 @@ func TestContentTypeBadPath(t *testing.T) {
 				newParams := []db.ContentTypeNewParam{
 					{"name", string(valuetype.StringSmall)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeNew(uItem, sItem, ctItem.Name(), newParams).Return(nil, err).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeNew(ctx, uItem, sItem, ctItem.Name(), newParams).Return(nil, err).AnyTimes()
 			},
 		},
 		{


@@ 321,10 323,10 @@ func TestContentTypeBadPath(t *testing.T) {
 				updateParams := []db.ContentTypeUpdateParam{
 					{"1234", "desc", string(valuetype.StringBig)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeUpdate(uItem, sItem, ctItemUpdate, ctItemUpdate.Name(), newParams, updateParams).Return(ctItemUpdate, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItemUpdate.ID()).Return(ctItemUpdate, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeUpdate(ctx, uItem, sItem, ctItemUpdate, ctItemUpdate.Name(), newParams, updateParams).Return(ctItemUpdate, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItemUpdate.ID()).Return(ctItemUpdate, nil).AnyTimes()
 			},
 		},
 		{


@@ 348,10 350,10 @@ func TestContentTypeBadPath(t *testing.T) {
 				updateParams := []db.ContentTypeUpdateParam{
 					{"1234", "desc", string(valuetype.StringBig)},
 				}
-				m.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				m.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				m.EXPECT().ContentTypeUpdate(uItem, sItem, ctItemUpdate, ctItemUpdate.Name(), newParams, updateParams).Return(ctItemUpdate, nil).AnyTimes()
-				m.EXPECT().ContentTypeGet(uItem, sItem, ctItemUpdate.ID()).Return(ctItemUpdate, nil).AnyTimes()
+				m.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				m.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				m.EXPECT().ContentTypeUpdate(ctx, uItem, sItem, ctItemUpdate, ctItemUpdate.Name(), newParams, updateParams).Return(ctItemUpdate, nil).AnyTimes()
+				m.EXPECT().ContentTypeGet(ctx, uItem, sItem, ctItemUpdate.ID()).Return(ctItemUpdate, nil).AnyTimes()
 			},
 		},
 	}

@@ 1,12 1,14 @@
 package doc
 
 import (
+	"context"
 	"html/template"
 	"log"
 	"net/http"
 
 	"git.sr.ht/~evanj/cms/internal/c"
 	"git.sr.ht/~evanj/cms/internal/m/tier"
+	"git.sr.ht/~evanj/cms/internal/m/user"
 	"git.sr.ht/~evanj/cms/internal/v"
 )
 


@@ 26,6 28,11 @@ type Doc struct {
 	log *log.Logger
 }
 
+type dber interface {
+	UserGet(ctx context.Context, username, password string) (user.User, error)
+	UserGetFromToken(ctx context.Context, token string) (user.User, error)
+}
+
 func New(c *c.Controller, log *log.Logger) *Doc {
 	return &Doc{c, log}
 }

@@ 5,6 5,7 @@
 package doc
 
 import (
+	context "context"
 	user "git.sr.ht/~evanj/cms/internal/m/user"
 	gomock "github.com/golang/mock/gomock"
 	reflect "reflect"


@@ 34,31 35,31 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }

@@ 13,13 13,15 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
+var ctx = gomock.Any()
+
 func TestWithoutUser(t *testing.T) {
 	t.Parallel()
 
 	var (
 		ctrl = gomock.NewController(t)
 		db   = doc.NewMockdber(ctrl)
-		s    = doc.New(c.New(nil, db, true, "test"), nil, db)
+		s    = doc.New(c.New(nil, db, true, "test"), nil)
 		ts   = httptest.NewServer(s)
 	)
 


@@ 34,11 36,11 @@ func TestWithUser(t *testing.T) {
 	var (
 		ctrl = gomock.NewController(t)
 		db   = doc.NewMockdber(ctrl)
-		s    = doc.New(c.New(nil, db, true, "test"), nil, db)
+		s    = doc.New(c.New(nil, db, true, "test"), nil)
 		ts   = httptest.NewServer(s)
 	)
 
-	db.EXPECT().UserGet("user", "pass").Return(userT.NewMock("", ""), nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, "user", "pass").Return(userT.NewMock("", ""), nil).AnyTimes()
 
 	req, _ := http.NewRequest("GET", ts.URL+"/page/doc", nil)
 	req.SetBasicAuth("user", "pass")


@@ 52,14 54,14 @@ func TestWithInvalidUserToken(t *testing.T) {
 	var (
 		ctrl = gomock.NewController(t)
 		db   = doc.NewMockdber(ctrl)
-		s    = doc.New(c.New(nil, db, true, "test"), nil, db)
+		s    = doc.New(c.New(nil, db, true, "test"), nil)
 		ts   = httptest.NewServer(s)
 		u    = userT.NewMock("", "")
 		tok  = u.Token()
 		err  = errors.New("placeholder")
 	)
 
-	db.EXPECT().UserGetFromToken(tok).Return(nil, err).AnyTimes()
+	db.EXPECT().UserGetFromToken(ctx, tok).Return(nil, err).AnyTimes()
 
 	// Shouldn't error.
 	req, _ := http.NewRequest("GET", ts.URL+"/page/doc", nil)


@@ 77,7 79,7 @@ func TestNotFound(t *testing.T) {
 	var (
 		ctrl = gomock.NewController(t)
 		db   = doc.NewMockdber(ctrl)
-		s    = doc.New(c.New(nil, db, true, "test"), nil, db)
+		s    = doc.New(c.New(nil, db, true, "test"), nil)
 		ts   = httptest.NewServer(s)
 	)
 

@@ 11,72 11,72 @@ import (
 	reflect "reflect"
 )
 
-// MockDBer is a mock of DBer interface
-type MockDBer struct {
+// Mockdber is a mock of dber interface
+type Mockdber struct {
 	ctrl     *gomock.Controller
-	recorder *MockDBerMockRecorder
+	recorder *MockdberMockRecorder
 }
 
-// MockDBerMockRecorder is the mock recorder for MockDBer
-type MockDBerMockRecorder struct {
-	mock *MockDBer
+// MockdberMockRecorder is the mock recorder for Mockdber
+type MockdberMockRecorder struct {
+	mock *Mockdber
 }
 
-// NewMockDBer creates a new mock instance
-func NewMockDBer(ctrl *gomock.Controller) *MockDBer {
-	mock := &MockDBer{ctrl: ctrl}
-	mock.recorder = &MockDBerMockRecorder{mock}
+// NewMockdber creates a new mock instance
+func NewMockdber(ctrl *gomock.Controller) *Mockdber {
+	mock := &Mockdber{ctrl: ctrl}
+	mock.recorder = &MockdberMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockDBer) EXPECT() *MockDBerMockRecorder {
+func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 	return m.recorder
 }
 
 // UserGet mocks base method
-func (m *MockDBer) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockDBerMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*MockDBer)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *MockDBer) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockDBerMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*MockDBer)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }
 
 // FileExists mocks base method
-func (m *MockDBer) FileExists(URL string) (bool, error) {
+func (m *Mockdber) FileExists(ctx context.Context, URL string) (bool, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FileExists", URL)
+	ret := m.ctrl.Call(m, "FileExists", ctx, URL)
 	ret0, _ := ret[0].(bool)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // FileExists indicates an expected call of FileExists
-func (mr *MockDBerMockRecorder) FileExists(URL interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) FileExists(ctx, URL interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FileExists", reflect.TypeOf((*MockDBer)(nil).FileExists), URL)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FileExists", reflect.TypeOf((*Mockdber)(nil).FileExists), ctx, URL)
 }
 
 // MockE3er is a mock of E3er interface

@@ 14,12 14,14 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
+var ctx = gomock.Any()
+
 func TestProxyGood(t *testing.T) {
 	t.Parallel()
 
 	var (
 		ctrl  = gomock.NewController(t)
-		db    = file.NewMockDBer(ctrl)
+		db    = file.NewMockdber(ctrl)
 		e3    = file.NewMockE3er(ctrl)
 		s     = file.New(c.New(nil, db, true, "test"), nil, db, e3, E3.DefaultURL)
 		ts    = httptest.NewServer(s)


@@ 28,7 30,7 @@ func TestProxyGood(t *testing.T) {
 		bytes []byte
 	)
 
-	db.EXPECT().FileExists(E3.DefaultURL+fp).Return(true, nil).AnyTimes()
+	db.EXPECT().FileExists(ctx, E3.DefaultURL+fp).Return(true, nil).AnyTimes()
 	e3.EXPECT().URL().Return(E3.DefaultURL).AnyTimes()
 	e3.EXPECT().Proxy(gomock.Any(), url).Return(bytes, nil).AnyTimes()
 


@@ 42,7 44,7 @@ func TestProxyBad(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = file.NewMockDBer(ctrl)
+		db   = file.NewMockdber(ctrl)
 		e3   = file.NewMockE3er(ctrl)
 		s    = file.New(c.New(nil, db, true, "test"), nil, db, e3, E3.DefaultURL)
 		ts   = httptest.NewServer(s)


@@ 51,7 53,7 @@ func TestProxyBad(t *testing.T) {
 		err  = errors.New("placeholder")
 	)
 
-	db.EXPECT().FileExists(E3.DefaultURL+fp).Return(true, nil).AnyTimes()
+	db.EXPECT().FileExists(ctx, E3.DefaultURL+fp).Return(true, nil).AnyTimes()
 	e3.EXPECT().URL().Return(E3.DefaultURL).AnyTimes()
 	e3.EXPECT().Proxy(gomock.Any(), url).Return(nil, err).AnyTimes()
 


@@ 65,7 67,7 @@ func TestFileDoesNotExit(t *testing.T) {
 
 	var (
 		ctrl = gomock.NewController(t)
-		db   = file.NewMockDBer(ctrl)
+		db   = file.NewMockdber(ctrl)
 		e3   = file.NewMockE3er(ctrl)
 		s    = file.New(c.New(nil, db, true, "test"), nil, db, e3, E3.DefaultURL)
 		ts   = httptest.NewServer(s)


@@ 73,7 75,7 @@ func TestFileDoesNotExit(t *testing.T) {
 		err  = errors.New("placeholder")
 	)
 
-	db.EXPECT().FileExists(E3.DefaultURL+fp).Return(false, err).AnyTimes()
+	db.EXPECT().FileExists(ctx, E3.DefaultURL+fp).Return(false, err).AnyTimes()
 
 	res, err := http.Get(ts.URL + fp)
 	assert.Equal(t, nil, err)

@@ 5,6 5,7 @@
 package hook
 
 import (
+	context "context"
 	hook "git.sr.ht/~evanj/cms/internal/m/hook"
 	space "git.sr.ht/~evanj/cms/internal/m/space"
 	user "git.sr.ht/~evanj/cms/internal/m/user"


@@ 36,90 37,90 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }
 
 // SpaceGet mocks base method
-func (m *Mockdber) SpaceGet(user user.User, spaceID string) (space.Space, error) {
+func (m *Mockdber) SpaceGet(ctx context.Context, user user.User, spaceID string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceGet", user, spaceID)
+	ret := m.ctrl.Call(m, "SpaceGet", ctx, user, spaceID)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceGet indicates an expected call of SpaceGet
-func (mr *MockdberMockRecorder) SpaceGet(user, spaceID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceGet(ctx, user, spaceID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), user, spaceID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), ctx, user, spaceID)
 }
 
 // HookNew mocks base method
-func (m *Mockdber) HookNew(user user.User, space space.Space, url string) (hook.Hook, error) {
+func (m *Mockdber) HookNew(ctx context.Context, user user.User, space space.Space, url string) (hook.Hook, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HookNew", user, space, url)
+	ret := m.ctrl.Call(m, "HookNew", ctx, user, space, url)
 	ret0, _ := ret[0].(hook.Hook)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // HookNew indicates an expected call of HookNew
-func (mr *MockdberMockRecorder) HookNew(user, space, url interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) HookNew(ctx, user, space, url interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HookNew", reflect.TypeOf((*Mockdber)(nil).HookNew), user, space, url)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HookNew", reflect.TypeOf((*Mockdber)(nil).HookNew), ctx, user, space, url)
 }
 
 // HookGet mocks base method
-func (m *Mockdber) HookGet(user user.User, space space.Space, id string) (hook.Hook, error) {
+func (m *Mockdber) HookGet(ctx context.Context, user user.User, space space.Space, id string) (hook.Hook, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HookGet", user, space, id)
+	ret := m.ctrl.Call(m, "HookGet", ctx, user, space, id)
 	ret0, _ := ret[0].(hook.Hook)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // HookGet indicates an expected call of HookGet
-func (mr *MockdberMockRecorder) HookGet(user, space, id interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) HookGet(ctx, user, space, id interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HookGet", reflect.TypeOf((*Mockdber)(nil).HookGet), user, space, id)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HookGet", reflect.TypeOf((*Mockdber)(nil).HookGet), ctx, user, space, id)
 }
 
 // HookDelete mocks base method
-func (m *Mockdber) HookDelete(user user.User, space space.Space, hook hook.Hook) error {
+func (m *Mockdber) HookDelete(ctx context.Context, user user.User, space space.Space, hook hook.Hook) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HookDelete", user, space, hook)
+	ret := m.ctrl.Call(m, "HookDelete", ctx, user, space, hook)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // HookDelete indicates an expected call of HookDelete
-func (mr *MockdberMockRecorder) HookDelete(user, space, hook interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) HookDelete(ctx, user, space, hook interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HookDelete", reflect.TypeOf((*Mockdber)(nil).HookDelete), user, space, hook)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HookDelete", reflect.TypeOf((*Mockdber)(nil).HookDelete), ctx, user, space, hook)
 }

@@ 19,11 19,15 @@ import (
 	"github.com/google/uuid"
 )
 
-var client = &http.Client{
-	CheckRedirect: func(req *http.Request, via []*http.Request) error {
-		return http.ErrUseLastResponse
-	},
-}
+var (
+	client = &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+
+	ctx = gomock.Any()
+)
 
 func TestNoUser(t *testing.T) {
 	t.Parallel()


@@ 74,9 78,9 @@ func TestHookHappyPath(t *testing.T) {
 				"method": {"POST"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookNew(uItem, sItem, hItem.URL()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookNew(ctx, uItem, sItem, hItem.URL()).Return(hItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 87,9 91,9 @@ func TestHookHappyPath(t *testing.T) {
 				"method": {"GET"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 100,10 104,10 @@ func TestHookHappyPath(t *testing.T) {
 				"method": {"DELETE"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
-				db.EXPECT().HookDelete(uItem, sItem, hItem).Return(nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().HookDelete(ctx, uItem, sItem, hItem).Return(nil).AnyTimes()
 			},
 		},
 	}


@@ 159,9 163,9 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"POST"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(nil, err).AnyTimes()
-				// db.EXPECT().HookNew(uItem, sItem, hItem.URL()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(nil, err).AnyTimes()
+				// db.EXPECT().HookNew(ctx, uItem, sItem, hItem.URL()).Return(hItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 173,9 177,9 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"POST"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookNew(uItem, sItem, hItem.URL()).Return(nil, err).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookNew(ctx, uItem, sItem, hItem.URL()).Return(nil, err).AnyTimes()
 			},
 		},
 		// GET


@@ 188,9 192,9 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"GET"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(nil, err).AnyTimes()
-				// db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(nil, err).AnyTimes()
+				// db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
 			},
 		},
 		{


@@ 202,9 206,9 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"GET"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(nil, err).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(nil, err).AnyTimes()
 			},
 		},
 		// DELETE


@@ 217,10 221,10 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"DELETE"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(nil, err).AnyTimes()
-				// db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
-				// db.EXPECT().HookDelete(uItem, sItem, hItem).Return(nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(nil, err).AnyTimes()
+				// db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				// db.EXPECT().HookDelete(ctx, uItem, sItem, hItem).Return(nil).AnyTimes()
 			},
 		},
 		{


@@ 232,10 236,10 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"DELETE"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(nil, err).AnyTimes()
-				// db.EXPECT().HookDelete(uItem, sItem, hItem).Return(nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(nil, err).AnyTimes()
+				// db.EXPECT().HookDelete(ctx, uItem, sItem, hItem).Return(nil).AnyTimes()
 			},
 		},
 		{


@@ 247,10 251,10 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"DELETE"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
-				db.EXPECT().HookDelete(uItem, sItem, hItem).Return(err).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().HookDelete(ctx, uItem, sItem, hItem).Return(err).AnyTimes()
 			},
 		},
 		// PATCH / NOT FOUND


@@ 263,10 267,10 @@ func TestHookBadPaths(t *testing.T) {
 				"method": {"PATCH"}, // By default net/http doesn't parse body on DELETE.
 			},
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
-				db.EXPECT().HookDelete(uItem, sItem, hItem).Return(err).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().HookDelete(ctx, uItem, sItem, hItem).Return(err).AnyTimes()
 			},
 		},
 	}


@@ 312,9 316,9 @@ func TestHookWeirdPath(t *testing.T) {
 		{
 			http.StatusOK,
 			func(db *hook.Mockdber) {
-				db.EXPECT().UserGet(uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().HookGet(uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uItem.Name(), uItem.Pass()).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().HookGet(ctx, uItem, sItem, hItem.ID()).Return(hItem, nil).AnyTimes()
 			},
 		},
 	}

@@ 5,6 5,7 @@
 package redirect
 
 import (
+	context "context"
 	user "git.sr.ht/~evanj/cms/internal/m/user"
 	gomock "github.com/golang/mock/gomock"
 	reflect "reflect"


@@ 34,31 35,31 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }

@@ 12,6 12,8 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
+var ctx = gomock.Any()
+
 func TestRedirect(t *testing.T) {
 	t.Parallel()
 

@@ 35,11 35,11 @@ type dber interface {
 	UserGetFromToken(ctx context.Context, token string) (user.User, error)
 	SpaceNew(ctx context.Context, user user.User, name, desc string) (space.Space, error)
 	SpaceGet(ctx context.Context, user user.User, spaceID string) (space.Space, error)
-	SpaceUpdate(ctx context.Context, user user.User, space space.Space, name, desc string) (space.Space, error)
-	SpaceCopy(ctx context.Context, user user.User, space space.Space, name, desc string) (space.Space, error)
-	SpaceDelete(ctx context.Context, user user.User, space space.Space) error
-	ContentTypesPerSpace(ctx context.Context, user user.User, space space.Space, before int) (contenttype.ContentTypeList, error)
-	HooksPerSpace(ctx context.Context, user user.User, space space.Space, before int) (hook.HookList, error)
+	SpaceUpdate(ctx context.Context, user user.User, s space.Space, name, desc string) (space.Space, error)
+	SpaceCopy(ctx context.Context, user user.User, s space.Space, name, desc string) (space.Space, error)
+	SpaceDelete(ctx context.Context, user user.User, s space.Space) error
+	ContentTypesPerSpace(ctx context.Context, user user.User, s space.Space, before int) (contenttype.ContentTypeList, error)
+	HooksPerSpace(ctx context.Context, user user.User, s space.Space, before int) (hook.HookList, error)
 }
 
 func New(c *c.Controller, log *log.Logger, db dber) *Space {

@@ 5,13 5,13 @@
 package space
 
 import (
-	reflect "reflect"
-
+	context "context"
 	contenttype "git.sr.ht/~evanj/cms/internal/m/contenttype"
 	hook "git.sr.ht/~evanj/cms/internal/m/hook"
 	space "git.sr.ht/~evanj/cms/internal/m/space"
 	user "git.sr.ht/~evanj/cms/internal/m/user"
 	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
 )
 
 // Mockdber is a mock of dber interface


@@ 38,135 38,135 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }
 
 // SpaceNew mocks base method
-func (m *Mockdber) SpaceNew(user user.User, name, desc string) (space.Space, error) {
+func (m *Mockdber) SpaceNew(ctx context.Context, user user.User, name, desc string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceNew", user, name, desc)
+	ret := m.ctrl.Call(m, "SpaceNew", ctx, user, name, desc)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceNew indicates an expected call of SpaceNew
-func (mr *MockdberMockRecorder) SpaceNew(user, name, desc interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceNew(ctx, user, name, desc interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceNew", reflect.TypeOf((*Mockdber)(nil).SpaceNew), user, name, desc)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceNew", reflect.TypeOf((*Mockdber)(nil).SpaceNew), ctx, user, name, desc)
 }
 
 // SpaceGet mocks base method
-func (m *Mockdber) SpaceGet(user user.User, spaceID string) (space.Space, error) {
+func (m *Mockdber) SpaceGet(ctx context.Context, user user.User, spaceID string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceGet", user, spaceID)
+	ret := m.ctrl.Call(m, "SpaceGet", ctx, user, spaceID)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceGet indicates an expected call of SpaceGet
-func (mr *MockdberMockRecorder) SpaceGet(user, spaceID interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceGet(ctx, user, spaceID interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), user, spaceID)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceGet", reflect.TypeOf((*Mockdber)(nil).SpaceGet), ctx, user, spaceID)
 }
 
 // SpaceUpdate mocks base method
-func (m *Mockdber) SpaceUpdate(user user.User, s space.Space, name, desc string) (space.Space, error) {
+func (m *Mockdber) SpaceUpdate(ctx context.Context, user user.User, s space.Space, name, desc string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceUpdate", user, s, name, desc)
+	ret := m.ctrl.Call(m, "SpaceUpdate", ctx, user, s, name, desc)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceUpdate indicates an expected call of SpaceUpdate
-func (mr *MockdberMockRecorder) SpaceUpdate(user, space, name, desc interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceUpdate(ctx, user, s, name, desc interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceUpdate", reflect.TypeOf((*Mockdber)(nil).SpaceUpdate), user, space, name, desc)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceUpdate", reflect.TypeOf((*Mockdber)(nil).SpaceUpdate), ctx, user, s, name, desc)
 }
 
 // SpaceCopy mocks base method
-func (m *Mockdber) SpaceCopy(user user.User, s space.Space, name, desc string) (space.Space, error) {
+func (m *Mockdber) SpaceCopy(ctx context.Context, user user.User, s space.Space, name, desc string) (space.Space, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceCopy", user, s, name, desc)
+	ret := m.ctrl.Call(m, "SpaceCopy", ctx, user, s, name, desc)
 	ret0, _ := ret[0].(space.Space)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpaceCopy indicates an expected call of SpaceCopy
-func (mr *MockdberMockRecorder) SpaceCopy(user, space, name, desc interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceCopy(ctx, user, s, name, desc interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceCopy", reflect.TypeOf((*Mockdber)(nil).SpaceCopy), user, space, name, desc)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceCopy", reflect.TypeOf((*Mockdber)(nil).SpaceCopy), ctx, user, s, name, desc)
 }
 
 // SpaceDelete mocks base method
-func (m *Mockdber) SpaceDelete(user user.User, space space.Space) error {
+func (m *Mockdber) SpaceDelete(ctx context.Context, user user.User, s space.Space) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpaceDelete", user, space)
+	ret := m.ctrl.Call(m, "SpaceDelete", ctx, user, s)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // SpaceDelete indicates an expected call of SpaceDelete
-func (mr *MockdberMockRecorder) SpaceDelete(user, space interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpaceDelete(ctx, user, s interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceDelete", reflect.TypeOf((*Mockdber)(nil).SpaceDelete), user, space)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceDelete", reflect.TypeOf((*Mockdber)(nil).SpaceDelete), ctx, user, s)
 }
 
 // ContentTypesPerSpace mocks base method
-func (m *Mockdber) ContentTypesPerSpace(user user.User, space space.Space, before int) (contenttype.ContentTypeList, error) {
+func (m *Mockdber) ContentTypesPerSpace(ctx context.Context, user user.User, s space.Space, before int) (contenttype.ContentTypeList, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContentTypesPerSpace", user, space, before)
+	ret := m.ctrl.Call(m, "ContentTypesPerSpace", ctx, user, s, before)
 	ret0, _ := ret[0].(contenttype.ContentTypeList)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ContentTypesPerSpace indicates an expected call of ContentTypesPerSpace
-func (mr *MockdberMockRecorder) ContentTypesPerSpace(user, space, before interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) ContentTypesPerSpace(ctx, user, s, before interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypesPerSpace", reflect.TypeOf((*Mockdber)(nil).ContentTypesPerSpace), user, space, before)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTypesPerSpace", reflect.TypeOf((*Mockdber)(nil).ContentTypesPerSpace), ctx, user, s, before)
 }
 
 // HooksPerSpace mocks base method
-func (m *Mockdber) HooksPerSpace(user user.User, space space.Space, before int) (hook.HookList, error) {
+func (m *Mockdber) HooksPerSpace(ctx context.Context, user user.User, s space.Space, before int) (hook.HookList, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HooksPerSpace", user, space, before)
+	ret := m.ctrl.Call(m, "HooksPerSpace", ctx, user, s, before)
 	ret0, _ := ret[0].(hook.HookList)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // HooksPerSpace indicates an expected call of HooksPerSpace
-func (mr *MockdberMockRecorder) HooksPerSpace(user, space, before interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) HooksPerSpace(ctx, user, s, before interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HooksPerSpace", reflect.TypeOf((*Mockdber)(nil).HooksPerSpace), user, space, before)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HooksPerSpace", reflect.TypeOf((*Mockdber)(nil).HooksPerSpace), ctx, user, s, before)
 }

@@ 22,11 22,15 @@ import (
 	"github.com/google/uuid"
 )
 
-var client = &http.Client{
-	CheckRedirect: func(req *http.Request, via []*http.Request) error {
-		return http.ErrUseLastResponse
-	},
-}
+var (
+	client = &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+
+	ctx = gomock.Any()
+)
 
 func emptyreq(ts *httptest.Server, method string) (*http.Response, error) {
 	req, err := newrequest(method, ts.URL, nil)


@@ 126,84 130,84 @@ func TestAll(t *testing.T) {
 		SpaceTest{
 			createSC: http.StatusFound,
 			create: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceNew(uItem, sname, sdesc).Return(sItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceNew(ctx, uItem, sname, sdesc).Return(sItem, nil).AnyTimes()
 			},
 			getSC: http.StatusOK,
 			get: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().ContentTypesPerSpace(uItem, sItem, 0).Return(contentTypeList, nil).AnyTimes()
-				db.EXPECT().HooksPerSpace(uItem, sItem, 0).Return(hookList, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().ContentTypesPerSpace(ctx, uItem, sItem, 0).Return(contentTypeList, nil).AnyTimes()
+				db.EXPECT().HooksPerSpace(ctx, uItem, sItem, 0).Return(hookList, nil).AnyTimes()
 			},
 			updateSC: http.StatusFound,
 			update: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().SpaceUpdate(uItem, sItem, snameUpdate, sdescUpdate).Return(sItemUpdate, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().SpaceUpdate(ctx, uItem, sItem, snameUpdate, sdescUpdate).Return(sItemUpdate, nil).AnyTimes()
 			},
 			copySC: http.StatusFound,
 			copy: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItemUpdate.ID()).Return(sItemUpdate, nil).AnyTimes()
-				db.EXPECT().SpaceCopy(uItem, sItemUpdate, snameCopy, sdescCopy).Return(sItemCopy, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItemUpdate.ID()).Return(sItemUpdate, nil).AnyTimes()
+				db.EXPECT().SpaceCopy(ctx, uItem, sItemUpdate, snameCopy, sdescCopy).Return(sItemCopy, nil).AnyTimes()
 			},
 			deleteSC: http.StatusFound,
 			delete: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
-				db.EXPECT().SpaceDelete(uItem, sItem).Return(nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(sItem, nil).AnyTimes()
+				db.EXPECT().SpaceDelete(ctx, uItem, sItem).Return(nil).AnyTimes()
 			},
 		},
 
 		SpaceTest{
 			createSC: http.StatusBadRequest,
 			create: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(nil, c.ErrNoLogin).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(nil, c.ErrNoLogin).AnyTimes()
 			},
 			getSC: http.StatusBadRequest,
 			get: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
 			},
 			updateSC: http.StatusBadRequest,
 			update: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
 			},
 			copySC: http.StatusBadRequest,
 			copy: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
 			},
 			deleteSC: http.StatusBadRequest,
 			delete: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
 			},
 		},
 
 		SpaceTest{
 			createSC: http.StatusBadRequest,
 			create: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceNew(uItem, sname, sdesc).Return(nil, space.ErrNoSpace).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceNew(ctx, uItem, sname, sdesc).Return(nil, space.ErrNoSpace).AnyTimes()
 			},
 			getSC: http.StatusNotFound,
 			get: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
 			},
 			updateSC: http.StatusNotFound,
 			update: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
 			},
 			copySC: http.StatusNotFound,
 			copy: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItemUpdate.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItemUpdate.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
 			},
 			deleteSC: http.StatusNotFound,
 			delete: func(db *space.Mockdber) {
-				db.EXPECT().UserGet(uname, upass).Return(uItem, nil).AnyTimes()
-				db.EXPECT().SpaceGet(uItem, sItem.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
+				db.EXPECT().UserGet(ctx, uname, upass).Return(uItem, nil).AnyTimes()
+				db.EXPECT().SpaceGet(ctx, uItem, sItem.ID()).Return(nil, space.ErrNoSpace).AnyTimes()
 			},
 		},
 	}

@@ 0,0 1,48 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: stripe.go
+
+// Package stripe is a generated GoMock package.
+package stripe
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockStriper is a mock of Striper interface
+type MockStriper struct {
+	ctrl     *gomock.Controller
+	recorder *MockStriperMockRecorder
+}
+
+// MockStriperMockRecorder is the mock recorder for MockStriper
+type MockStriperMockRecorder struct {
+	mock *MockStriper
+}
+
+// NewMockStriper creates a new mock instance
+func NewMockStriper(ctrl *gomock.Controller) *MockStriper {
+	mock := &MockStriper{ctrl: ctrl}
+	mock.recorder = &MockStriperMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockStriper) EXPECT() *MockStriperMockRecorder {
+	return m.recorder
+}
+
+// CompleteCheckout mocks base method
+func (m *MockStriper) CompleteCheckout(ctx context.Context, sessionID string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CompleteCheckout", ctx, sessionID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CompleteCheckout indicates an expected call of CompleteCheckout
+func (mr *MockStriperMockRecorder) CompleteCheckout(ctx, sessionID interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteCheckout", reflect.TypeOf((*MockStriper)(nil).CompleteCheckout), ctx, sessionID)
+}

@@ 5,6 5,7 @@
 package user
 
 import (
+	context "context"
 	space "git.sr.ht/~evanj/cms/internal/m/space"
 	tier "git.sr.ht/~evanj/cms/internal/m/tier"
 	user "git.sr.ht/~evanj/cms/internal/m/user"


@@ 36,93 37,93 @@ func (m *Mockdber) EXPECT() *MockdberMockRecorder {
 }
 
 // UserNew mocks base method
-func (m *Mockdber) UserNew(username, password, verifyPassword string) (user.User, error) {
+func (m *Mockdber) UserNew(ctx context.Context, username, password, verifyPassword string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserNew", username, password, verifyPassword)
+	ret := m.ctrl.Call(m, "UserNew", ctx, username, password, verifyPassword)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserNew indicates an expected call of UserNew
-func (mr *MockdberMockRecorder) UserNew(username, password, verifyPassword interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserNew(ctx, username, password, verifyPassword interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserNew", reflect.TypeOf((*Mockdber)(nil).UserNew), username, password, verifyPassword)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserNew", reflect.TypeOf((*Mockdber)(nil).UserNew), ctx, username, password, verifyPassword)
 }
 
 // UserGet mocks base method
-func (m *Mockdber) UserGet(username, password string) (user.User, error) {
+func (m *Mockdber) UserGet(ctx context.Context, username, password string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGet", username, password)
+	ret := m.ctrl.Call(m, "UserGet", ctx, username, password)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGet indicates an expected call of UserGet
-func (mr *MockdberMockRecorder) UserGet(username, password interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGet(ctx, username, password interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), username, password)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGet", reflect.TypeOf((*Mockdber)(nil).UserGet), ctx, username, password)
 }
 
 // UserGetFromToken mocks base method
-func (m *Mockdber) UserGetFromToken(token string) (user.User, error) {
+func (m *Mockdber) UserGetFromToken(ctx context.Context, token string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserGetFromToken", token)
+	ret := m.ctrl.Call(m, "UserGetFromToken", ctx, token)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserGetFromToken indicates an expected call of UserGetFromToken
-func (mr *MockdberMockRecorder) UserGetFromToken(token interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserGetFromToken(ctx, token interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), token)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGetFromToken", reflect.TypeOf((*Mockdber)(nil).UserGetFromToken), ctx, token)
 }
 
 // UserSetEmail mocks base method
-func (m *Mockdber) UserSetEmail(u user.User, email string) (user.User, error) {
+func (m *Mockdber) UserSetEmail(ctx context.Context, u user.User, email string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserSetEmail", u, email)
+	ret := m.ctrl.Call(m, "UserSetEmail", ctx, u, email)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserSetEmail indicates an expected call of UserSetEmail
-func (mr *MockdberMockRecorder) UserSetEmail(u, email interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserSetEmail(ctx, u, email interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserSetEmail", reflect.TypeOf((*Mockdber)(nil).UserSetEmail), u, email)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserSetEmail", reflect.TypeOf((*Mockdber)(nil).UserSetEmail), ctx, u, email)
 }
 
 // UserSetPassword mocks base method
-func (m *Mockdber) UserSetPassword(u user.User, current, password, verify string) (user.User, error) {
+func (m *Mockdber) UserSetPassword(ctx context.Context, u user.User, current, password, verify string) (user.User, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserSetPassword", u, current, password, verify)
+	ret := m.ctrl.Call(m, "UserSetPassword", ctx, u, current, password, verify)
 	ret0, _ := ret[0].(user.User)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UserSetPassword indicates an expected call of UserSetPassword
-func (mr *MockdberMockRecorder) UserSetPassword(u, current, password, verify interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) UserSetPassword(ctx, u, current, password, verify interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserSetPassword", reflect.TypeOf((*Mockdber)(nil).UserSetPassword), u, current, password, verify)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserSetPassword", reflect.TypeOf((*Mockdber)(nil).UserSetPassword), ctx, u, current, password, verify)
 }
 
 // SpacesPerUser mocks base method
-func (m *Mockdber) SpacesPerUser(user user.User, before int) (space.SpaceList, error) {
+func (m *Mockdber) SpacesPerUser(ctx context.Context, user user.User, before int) (space.SpaceList, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SpacesPerUser", user, before)
+	ret := m.ctrl.Call(m, "SpacesPerUser", ctx, user, before)
 	ret0, _ := ret[0].(space.SpaceList)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SpacesPerUser indicates an expected call of SpacesPerUser
-func (mr *MockdberMockRecorder) SpacesPerUser(user, before interface{}) *gomock.Call {
+func (mr *MockdberMockRecorder) SpacesPerUser(ctx, user, before interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacesPerUser", reflect.TypeOf((*Mockdber)(nil).SpacesPerUser), user, before)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacesPerUser", reflect.TypeOf((*Mockdber)(nil).SpacesPerUser), ctx, user, before)
 }
 
 // MockStriper is a mock of Striper interface


@@ 149,9 150,9 @@ func (m *MockStriper) EXPECT() *MockStriperMockRecorder {
 }
 
 // StartCheckout mocks base method
-func (m *MockStriper) StartCheckout(user user.User, t tier.Tier) (string, string, error) {
+func (m *MockStriper) StartCheckout(ctx context.Context, user user.User, t tier.Tier) (string, string, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartCheckout", user, t)
+	ret := m.ctrl.Call(m, "StartCheckout", ctx, user, t)
 	ret0, _ := ret[0].(string)
 	ret1, _ := ret[1].(string)
 	ret2, _ := ret[2].(error)


@@ 159,21 160,21 @@ func (m *MockStriper) StartCheckout(user user.User, t tier.Tier) (string, string
 }
 
 // StartCheckout indicates an expected call of StartCheckout
-func (mr *MockStriperMockRecorder) StartCheckout(user, t interface{}) *gomock.Call {
+func (mr *MockStriperMockRecorder) StartCheckout(ctx, user, t interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCheckout", reflect.TypeOf((*MockStriper)(nil).StartCheckout), user, t)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCheckout", reflect.TypeOf((*MockStriper)(nil).StartCheckout), ctx, user, t)
 }
 
 // CancelSubscription mocks base method
-func (m *MockStriper) CancelSubscription(user user.User) error {
+func (m *MockStriper) CancelSubscription(ctx context.Context, user user.User) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelSubscription", user)
+	ret := m.ctrl.Call(m, "CancelSubscription", ctx, user)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // CancelSubscription indicates an expected call of CancelSubscription
-func (mr *MockStriperMockRecorder) CancelSubscription(user interface{}) *gomock.Call {
+func (mr *MockStriperMockRecorder) CancelSubscription(ctx, user interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSubscription", reflect.TypeOf((*MockStriper)(nil).CancelSubscription), user)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSubscription", reflect.TypeOf((*MockStriper)(nil).CancelSubscription), ctx, user)
 }

@@ 17,6 17,8 @@ import (
 	"github.com/google/uuid"
 )
 
+var ctx = gomock.Any()
+
 type FakeSpaceList struct{}
 
 func (_ FakeSpaceList) List() (r []spaceType.Space) { return }


@@ 46,7 48,7 @@ func TestCreate(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserNew(uname, upass, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().UserNew(ctx, uname, upass, upass).Return(u, nil).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/signup", form)
 	assert.Equal(t, res.StatusCode, http.StatusOK)


@@ 73,7 75,7 @@ func TestLogin(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(uname, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, uname, upass).Return(u, nil).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/login", form)
 	assert.Equal(t, res.StatusCode, http.StatusOK)


@@ 120,9 122,9 @@ func TestHome(t *testing.T) {
 		sl = FakeSpaceList{}
 	)
 
-	db.EXPECT().UserNew(uname, upass, upass).Return(u, nil).AnyTimes()
-	db.EXPECT().UserGet(uname, upass).Return(u, nil).AnyTimes()
-	db.EXPECT().SpacesPerUser(u, 0).Return(sl, nil).AnyTimes()
+	db.EXPECT().UserNew(ctx, uname, upass, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, uname, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().SpacesPerUser(ctx, u, 0).Return(sl, nil).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/signup", form)
 	assert.Equal(t, res.StatusCode, http.StatusOK)


@@ 154,7 156,7 @@ func TestBadLogin(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserGet(uname, upass).Return(nil, c.ErrNoLogin).AnyTimes()
+	db.EXPECT().UserGet(ctx, uname, upass).Return(nil, c.ErrNoLogin).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/login", form)
 	assert.Equal(t, res.StatusCode, http.StatusBadRequest)


@@ 182,7 184,7 @@ func TestNoSignups(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserNew(uname, upass, upass).Return(nil, user.ErrNoSignup).AnyTimes()
+	db.EXPECT().UserNew(ctx, uname, upass, upass).Return(nil, user.ErrNoSignup).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/signup", form)
 	assert.Equal(t, res.StatusCode, http.StatusForbidden)


@@ 211,8 213,8 @@ func TestCreatePaid(t *testing.T) {
 		}
 	)
 
-	db.EXPECT().UserNew(uname, upass, upass).Return(u, nil).AnyTimes()
-	stripe.EXPECT().StartCheckout(u, tier.Business).Return("SomeSessionID", "SomePublicKey", nil).AnyTimes()
+	db.EXPECT().UserNew(ctx, uname, upass, upass).Return(u, nil).AnyTimes()
+	stripe.EXPECT().StartCheckout(ctx, u, tier.Business).Return("SomeSessionID", "SomePublicKey", nil).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/signup", form)
 	assert.Equal(t, res.StatusCode, http.StatusOK)


@@ 243,9 245,9 @@ func TestHomeNoUser(t *testing.T) {
 		sl = FakeSpaceList{}
 	)
 
-	db.EXPECT().UserNew(uname, upass, upass).Return(u, nil).AnyTimes()
-	db.EXPECT().UserGet(uname, upass).Return(u, nil).AnyTimes()
-	db.EXPECT().SpacesPerUser(u, 0).Return(sl, nil).AnyTimes()
+	db.EXPECT().UserNew(ctx, uname, upass, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().UserGet(ctx, uname, upass).Return(u, nil).AnyTimes()
+	db.EXPECT().SpacesPerUser(ctx, u, 0).Return(sl, nil).AnyTimes()
 
 	res, _ := http.PostForm(ts.URL+"/user/signup", form)
 	assert.Equal(t, res.StatusCode, http.StatusOK)