package api import ( "bytes" "context" "encoding/json" "errors" "io" "net/http" "net/http/httptest" "testing" "time" "github.com/go-chi/chi" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "github.com/smallstep/assert" "github.com/smallstep/certificates/authority/admin" "github.com/smallstep/certificates/authority/provisioner" "go.step.sm/linkedca" "google.golang.org/protobuf/types/known/timestamppb" ) type mockAdminAuthority struct { MockLoadProvisionerByName func(name string) (provisioner.Interface, error) MockGetProvisioners func(nextCursor string, limit int) (provisioner.List, string, error) MockRet1, MockRet2 interface{} // TODO: refactor the ret1/ret2 into those two MockErr error MockIsAdminAPIEnabled func() bool MockLoadAdminByID func(id string) (*linkedca.Admin, bool) MockGetAdmins func(cursor string, limit int) ([]*linkedca.Admin, string, error) MockStoreAdmin func(ctx context.Context, adm *linkedca.Admin, prov provisioner.Interface) error MockUpdateAdmin func(ctx context.Context, id string, nu *linkedca.Admin) (*linkedca.Admin, error) MockRemoveAdmin func(ctx context.Context, id string) error MockAuthorizeAdminToken func(r *http.Request, token string) (*linkedca.Admin, error) MockStoreProvisioner func(ctx context.Context, prov *linkedca.Provisioner) error MockLoadProvisionerByID func(id string) (provisioner.Interface, error) MockUpdateProvisioner func(ctx context.Context, nu *linkedca.Provisioner) error MockRemoveProvisioner func(ctx context.Context, id string) error } func (m *mockAdminAuthority) IsAdminAPIEnabled() bool { if m.MockIsAdminAPIEnabled != nil { return m.MockIsAdminAPIEnabled() } return m.MockRet1.(bool) } func (m *mockAdminAuthority) LoadProvisionerByName(name string) (provisioner.Interface, error) { if m.MockLoadProvisionerByName != nil { return m.MockLoadProvisionerByName(name) } return m.MockRet1.(provisioner.Interface), m.MockErr } func (m *mockAdminAuthority) GetProvisioners(nextCursor string, limit int) (provisioner.List, string, error) { if m.MockGetProvisioners != nil { return m.MockGetProvisioners(nextCursor, limit) } return m.MockRet1.(provisioner.List), m.MockRet2.(string), m.MockErr } func (m *mockAdminAuthority) LoadAdminByID(id string) (*linkedca.Admin, bool) { if m.MockLoadAdminByID != nil { return m.MockLoadAdminByID(id) } return m.MockRet1.(*linkedca.Admin), m.MockRet2.(bool) } func (m *mockAdminAuthority) GetAdmins(cursor string, limit int) ([]*linkedca.Admin, string, error) { if m.MockGetAdmins != nil { return m.MockGetAdmins(cursor, limit) } return m.MockRet1.([]*linkedca.Admin), m.MockRet2.(string), m.MockErr } func (m *mockAdminAuthority) StoreAdmin(ctx context.Context, adm *linkedca.Admin, prov provisioner.Interface) error { if m.MockStoreAdmin != nil { return m.MockStoreAdmin(ctx, adm, prov) } return m.MockErr } func (m *mockAdminAuthority) UpdateAdmin(ctx context.Context, id string, nu *linkedca.Admin) (*linkedca.Admin, error) { if m.MockUpdateAdmin != nil { return m.MockUpdateAdmin(ctx, id, nu) } return m.MockRet1.(*linkedca.Admin), m.MockErr } func (m *mockAdminAuthority) RemoveAdmin(ctx context.Context, id string) error { if m.MockRemoveAdmin != nil { return m.MockRemoveAdmin(ctx, id) } return m.MockErr } func (m *mockAdminAuthority) AuthorizeAdminToken(r *http.Request, token string) (*linkedca.Admin, error) { if m.MockAuthorizeAdminToken != nil { return m.MockAuthorizeAdminToken(r, token) } return m.MockRet1.(*linkedca.Admin), m.MockErr } func (m *mockAdminAuthority) StoreProvisioner(ctx context.Context, prov *linkedca.Provisioner) error { if m.MockStoreProvisioner != nil { return m.MockStoreProvisioner(ctx, prov) } return m.MockErr } func (m *mockAdminAuthority) LoadProvisionerByID(id string) (provisioner.Interface, error) { if m.MockLoadProvisionerByID != nil { return m.MockLoadProvisionerByID(id) } return m.MockRet1.(provisioner.Interface), m.MockErr } func (m *mockAdminAuthority) UpdateProvisioner(ctx context.Context, nu *linkedca.Provisioner) error { if m.MockUpdateProvisioner != nil { return m.MockUpdateProvisioner(ctx, nu) } return m.MockErr } func (m *mockAdminAuthority) RemoveProvisioner(ctx context.Context, id string) error { if m.MockRemoveProvisioner != nil { return m.MockRemoveProvisioner(ctx, id) } return m.MockErr } func TestCreateAdminRequest_Validate(t *testing.T) { type fields struct { Subject string Provisioner string Type linkedca.Admin_Type } tests := []struct { name string fields fields err *admin.Error }{ { name: "fail/subject-empty", fields: fields{ Subject: "", Provisioner: "", Type: 0, }, err: admin.NewError(admin.ErrorBadRequestType, "subject cannot be empty"), }, { name: "fail/provisioner-empty", fields: fields{ Subject: "admin", Provisioner: "", Type: 0, }, err: admin.NewError(admin.ErrorBadRequestType, "provisioner cannot be empty"), }, { name: "fail/invalid-type", fields: fields{ Subject: "admin", Provisioner: "prov", Type: -1, }, err: admin.NewError(admin.ErrorBadRequestType, "invalid value for admin type"), }, { name: "ok", fields: fields{ Subject: "admin", Provisioner: "prov", Type: linkedca.Admin_SUPER_ADMIN, }, err: nil, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { car := &CreateAdminRequest{ Subject: tt.fields.Subject, Provisioner: tt.fields.Provisioner, Type: tt.fields.Type, } err := car.Validate() if (err != nil) != (tt.err != nil) { t.Errorf("CreateAdminRequest.Validate() error = %v, wantErr %v", err, (tt.err != nil)) return } if err != nil { assert.Type(t, &admin.Error{}, err) adminErr, _ := err.(*admin.Error) assert.Equals(t, tt.err.Type, adminErr.Type) assert.Equals(t, tt.err.Detail, adminErr.Detail) assert.Equals(t, tt.err.Status, adminErr.Status) assert.Equals(t, tt.err.Message, adminErr.Message) } }) } } func TestUpdateAdminRequest_Validate(t *testing.T) { type fields struct { Type linkedca.Admin_Type } tests := []struct { name string fields fields err *admin.Error }{ { name: "fail/invalid-type", fields: fields{ Type: -1, }, err: admin.NewError(admin.ErrorBadRequestType, "invalid value for admin type"), }, { name: "ok", fields: fields{ Type: linkedca.Admin_SUPER_ADMIN, }, err: nil, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { uar := &UpdateAdminRequest{ Type: tt.fields.Type, } err := uar.Validate() if (err != nil) != (tt.err != nil) { t.Errorf("CreateAdminRequest.Validate() error = %v, wantErr %v", err, (tt.err != nil)) return } if err != nil { assert.Type(t, &admin.Error{}, err) adminErr, _ := err.(*admin.Error) assert.Equals(t, tt.err.Type, adminErr.Type) assert.Equals(t, tt.err.Detail, adminErr.Detail) assert.Equals(t, tt.err.Status, adminErr.Status) assert.Equals(t, tt.err.Message, adminErr.Message) } }) } } func TestHandler_GetAdmin(t *testing.T) { type test struct { ctx context.Context auth adminAuthority statusCode int err *admin.Error adm *linkedca.Admin } var tests = map[string]func(t *testing.T) test{ "fail/auth.LoadAdminByID-not-found": func(t *testing.T) test { chiCtx := chi.NewRouteContext() chiCtx.URLParams.Add("id", "adminID") ctx := context.WithValue(context.Background(), chi.RouteCtxKey, chiCtx) auth := &mockAdminAuthority{ MockLoadAdminByID: func(id string) (*linkedca.Admin, bool) { assert.Equals(t, "adminID", id) return nil, false }, } return test{ ctx: ctx, auth: auth, statusCode: 404, err: &admin.Error{ Type: admin.ErrorNotFoundType.String(), Status: 404, Detail: "resource not found", Message: "admin adminID not found", }, } }, "ok": func(t *testing.T) test { chiCtx := chi.NewRouteContext() chiCtx.URLParams.Add("id", "adminID") ctx := context.WithValue(context.Background(), chi.RouteCtxKey, chiCtx) createdAt := time.Now() var deletedAt time.Time adm := &linkedca.Admin{ Id: "adminID", AuthorityId: "authorityID", Subject: "admin", ProvisionerId: "provID", Type: linkedca.Admin_SUPER_ADMIN, CreatedAt: timestamppb.New(createdAt), DeletedAt: timestamppb.New(deletedAt), } auth := &mockAdminAuthority{ MockLoadAdminByID: func(id string) (*linkedca.Admin, bool) { assert.Equals(t, "adminID", id) return adm, true }, } return test{ ctx: ctx, auth: auth, statusCode: 200, err: nil, adm: adm, } }, } for name, prep := range tests { tc := prep(t) t.Run(name, func(t *testing.T) { h := &Handler{ auth: tc.auth, } req := httptest.NewRequest("GET", "/foo", nil) // chi routing is prepared in test setup req = req.WithContext(tc.ctx) w := httptest.NewRecorder() h.GetAdmin(w, req) res := w.Result() assert.Equals(t, tc.statusCode, res.StatusCode) if res.StatusCode >= 400 { body, err := io.ReadAll(res.Body) res.Body.Close() assert.FatalError(t, err) adminErr := admin.Error{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &adminErr)) assert.Equals(t, tc.err.Type, adminErr.Type) assert.Equals(t, tc.err.Message, adminErr.Message) assert.Equals(t, tc.err.Detail, adminErr.Detail) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) return } adm := &linkedca.Admin{} err := readProtoJSON(res.Body, adm) assert.FatalError(t, err) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) opts := []cmp.Option{cmpopts.IgnoreUnexported(linkedca.Admin{}, timestamppb.Timestamp{})} if !cmp.Equal(tc.adm, adm, opts...) { t.Errorf("linkedca.Admin diff =\n%s", cmp.Diff(tc.adm, adm, opts...)) } }) } } func TestHandler_GetAdmins(t *testing.T) { type test struct { ctx context.Context auth adminAuthority req *http.Request statusCode int err *admin.Error resp GetAdminsResponse } var tests = map[string]func(t *testing.T) test{ "fail/parse-cursor": func(t *testing.T) test { req := httptest.NewRequest("GET", "/foo?limit=A", nil) return test{ ctx: context.Background(), req: req, statusCode: 400, err: &admin.Error{ Status: 400, Type: admin.ErrorBadRequestType.String(), Detail: "bad request", Message: "error parsing cursor and limit from query params: limit 'A' is not an integer: strconv.Atoi: parsing \"A\": invalid syntax", }, } }, "fail/auth.GetAdmins": func(t *testing.T) test { req := httptest.NewRequest("GET", "/foo", nil) auth := &mockAdminAuthority{ MockGetAdmins: func(cursor string, limit int) ([]*linkedca.Admin, string, error) { assert.Equals(t, "", cursor) assert.Equals(t, 0, limit) return nil, "", errors.New("force") }, } return test{ ctx: context.Background(), req: req, auth: auth, statusCode: 500, err: &admin.Error{ Status: 500, Type: admin.ErrorServerInternalType.String(), Detail: "the server experienced an internal error", Message: "error retrieving paginated admins: force", }, } }, "ok": func(t *testing.T) test { req := httptest.NewRequest("GET", "/foo", nil) createdAt := time.Now() var deletedAt time.Time adm1 := &linkedca.Admin{ Id: "adminID1", AuthorityId: "authorityID1", Subject: "admin1", ProvisionerId: "provID", Type: linkedca.Admin_SUPER_ADMIN, CreatedAt: timestamppb.New(createdAt), DeletedAt: timestamppb.New(deletedAt), } adm2 := &linkedca.Admin{ Id: "adminID2", AuthorityId: "authorityID", Subject: "admin2", ProvisionerId: "provID", Type: linkedca.Admin_ADMIN, CreatedAt: timestamppb.New(createdAt), DeletedAt: timestamppb.New(deletedAt), } auth := &mockAdminAuthority{ MockGetAdmins: func(cursor string, limit int) ([]*linkedca.Admin, string, error) { assert.Equals(t, "", cursor) assert.Equals(t, 0, limit) return []*linkedca.Admin{ adm1, adm2, }, "nextCursorValue", nil }, } return test{ ctx: context.Background(), req: req, auth: auth, statusCode: 200, err: nil, resp: GetAdminsResponse{ Admins: []*linkedca.Admin{ adm1, adm2, }, NextCursor: "nextCursorValue", }, } }, } for name, prep := range tests { tc := prep(t) t.Run(name, func(t *testing.T) { h := &Handler{ auth: tc.auth, } req := tc.req.WithContext(tc.ctx) w := httptest.NewRecorder() h.GetAdmins(w, req) res := w.Result() assert.Equals(t, tc.statusCode, res.StatusCode) body, err := io.ReadAll(res.Body) res.Body.Close() assert.FatalError(t, err) if res.StatusCode >= 400 { adminErr := admin.Error{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &adminErr)) assert.Equals(t, tc.err.Type, adminErr.Type) assert.Equals(t, tc.err.Message, adminErr.Message) assert.Equals(t, tc.err.Detail, adminErr.Detail) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) return } response := GetAdminsResponse{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &response)) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) opts := []cmp.Option{cmpopts.IgnoreUnexported(linkedca.Admin{}, timestamppb.Timestamp{})} if !cmp.Equal(tc.resp, response, opts...) { t.Errorf("GetAdmins diff =\n%s", cmp.Diff(tc.resp, response, opts...)) } }) } } func TestHandler_CreateAdmin(t *testing.T) { type test struct { ctx context.Context auth adminAuthority body []byte statusCode int err *admin.Error adm *linkedca.Admin } var tests = map[string]func(t *testing.T) test{ "fail/ReadJSON": func(t *testing.T) test { body := []byte("{!?}") return test{ ctx: context.Background(), body: body, statusCode: 400, err: &admin.Error{ Type: admin.ErrorBadRequestType.String(), Status: 400, Detail: "bad request", Message: "error reading request body: error decoding json: invalid character '!' looking for beginning of object key string", }, } }, "fail/validate": func(t *testing.T) test { req := CreateAdminRequest{ Subject: "", Provisioner: "", Type: -1, } body, err := json.Marshal(req) assert.FatalError(t, err) return test{ ctx: context.Background(), body: body, statusCode: 400, err: &admin.Error{ Type: admin.ErrorBadRequestType.String(), Status: 400, Detail: "bad request", Message: "subject cannot be empty", }, } }, "fail/auth.LoadProvisionerByName": func(t *testing.T) test { req := CreateAdminRequest{ Subject: "admin", Provisioner: "prov", Type: linkedca.Admin_SUPER_ADMIN, } body, err := json.Marshal(req) assert.FatalError(t, err) auth := &mockAdminAuthority{ MockLoadProvisionerByName: func(name string) (provisioner.Interface, error) { assert.Equals(t, "prov", name) return nil, errors.New("force") }, } return test{ ctx: context.Background(), body: body, auth: auth, statusCode: 500, err: &admin.Error{ Type: admin.ErrorServerInternalType.String(), Status: 500, Detail: "the server experienced an internal error", Message: "error loading provisioner prov: force", }, } }, "fail/auth.StoreAdmin": func(t *testing.T) test { req := CreateAdminRequest{ Subject: "admin", Provisioner: "prov", Type: linkedca.Admin_SUPER_ADMIN, } body, err := json.Marshal(req) assert.FatalError(t, err) auth := &mockAdminAuthority{ MockLoadProvisionerByName: func(name string) (provisioner.Interface, error) { assert.Equals(t, "prov", name) return &provisioner.ACME{ ID: "provID", Name: "prov", }, nil }, MockStoreAdmin: func(ctx context.Context, adm *linkedca.Admin, prov provisioner.Interface) error { assert.Equals(t, "admin", adm.Subject) assert.Equals(t, "provID", prov.GetID()) return errors.New("force") }, } return test{ ctx: context.Background(), body: body, auth: auth, statusCode: 500, err: &admin.Error{ Type: admin.ErrorServerInternalType.String(), Status: 500, Detail: "the server experienced an internal error", Message: "error storing admin: force", }, } }, "ok": func(t *testing.T) test { req := CreateAdminRequest{ Subject: "admin", Provisioner: "prov", Type: linkedca.Admin_SUPER_ADMIN, } body, err := json.Marshal(req) assert.FatalError(t, err) auth := &mockAdminAuthority{ MockLoadProvisionerByName: func(name string) (provisioner.Interface, error) { assert.Equals(t, "prov", name) return &provisioner.ACME{ ID: "provID", Name: "prov", }, nil }, MockStoreAdmin: func(ctx context.Context, adm *linkedca.Admin, prov provisioner.Interface) error { assert.Equals(t, "admin", adm.Subject) assert.Equals(t, "provID", prov.GetID()) return nil }, } return test{ ctx: context.Background(), body: body, auth: auth, statusCode: 201, err: nil, adm: &linkedca.Admin{ ProvisionerId: "provID", Subject: "admin", Type: linkedca.Admin_SUPER_ADMIN, }, } }, } for name, prep := range tests { tc := prep(t) t.Run(name, func(t *testing.T) { h := &Handler{ auth: tc.auth, } req := httptest.NewRequest("GET", "/foo", io.NopCloser(bytes.NewBuffer(tc.body))) req = req.WithContext(tc.ctx) w := httptest.NewRecorder() h.CreateAdmin(w, req) res := w.Result() assert.Equals(t, tc.statusCode, res.StatusCode) if res.StatusCode >= 400 { body, err := io.ReadAll(res.Body) res.Body.Close() assert.FatalError(t, err) adminErr := admin.Error{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &adminErr)) assert.Equals(t, tc.err.Type, adminErr.Type) assert.Equals(t, tc.err.Message, adminErr.Message) assert.Equals(t, tc.err.Detail, adminErr.Detail) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) return } adm := &linkedca.Admin{} err := readProtoJSON(res.Body, adm) assert.FatalError(t, err) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) opts := []cmp.Option{cmpopts.IgnoreUnexported(linkedca.Admin{}, timestamppb.Timestamp{})} if !cmp.Equal(tc.adm, adm, opts...) { t.Errorf("h.CreateAdmin diff =\n%s", cmp.Diff(tc.adm, adm, opts...)) } }) } } func TestHandler_DeleteAdmin(t *testing.T) { type test struct { ctx context.Context auth adminAuthority statusCode int err *admin.Error } var tests = map[string]func(t *testing.T) test{ "fail/auth.RemoveAdmin": func(t *testing.T) test { chiCtx := chi.NewRouteContext() chiCtx.URLParams.Add("id", "adminID") ctx := context.WithValue(context.Background(), chi.RouteCtxKey, chiCtx) auth := &mockAdminAuthority{ MockRemoveAdmin: func(ctx context.Context, id string) error { assert.Equals(t, "adminID", id) return errors.New("force") }, } return test{ ctx: ctx, auth: auth, statusCode: 500, err: &admin.Error{ Type: admin.ErrorServerInternalType.String(), Status: 500, Detail: "the server experienced an internal error", Message: "error deleting admin adminID: force", }, } }, "ok": func(t *testing.T) test { chiCtx := chi.NewRouteContext() chiCtx.URLParams.Add("id", "adminID") ctx := context.WithValue(context.Background(), chi.RouteCtxKey, chiCtx) auth := &mockAdminAuthority{ MockRemoveAdmin: func(ctx context.Context, id string) error { assert.Equals(t, "adminID", id) return nil }, } return test{ ctx: ctx, auth: auth, statusCode: 200, err: nil, } }, } for name, prep := range tests { tc := prep(t) t.Run(name, func(t *testing.T) { h := &Handler{ auth: tc.auth, } req := httptest.NewRequest("DELETE", "/foo", nil) // chi routing is prepared in test setup req = req.WithContext(tc.ctx) w := httptest.NewRecorder() h.DeleteAdmin(w, req) res := w.Result() assert.Equals(t, tc.statusCode, res.StatusCode) if res.StatusCode >= 400 { body, err := io.ReadAll(res.Body) res.Body.Close() assert.FatalError(t, err) adminErr := admin.Error{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &adminErr)) assert.Equals(t, tc.err.Type, adminErr.Type) assert.Equals(t, tc.err.Message, adminErr.Message) assert.Equals(t, tc.err.StatusCode(), res.StatusCode) assert.Equals(t, tc.err.Detail, adminErr.Detail) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) return } body, err := io.ReadAll(res.Body) res.Body.Close() assert.FatalError(t, err) response := DeleteResponse{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &response)) assert.Equals(t, "ok", response.Status) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) }) } } func TestHandler_UpdateAdmin(t *testing.T) { type test struct { ctx context.Context auth adminAuthority body []byte statusCode int err *admin.Error adm *linkedca.Admin } var tests = map[string]func(t *testing.T) test{ "fail/ReadJSON": func(t *testing.T) test { body := []byte("{!?}") return test{ ctx: context.Background(), body: body, statusCode: 400, err: &admin.Error{ Type: admin.ErrorBadRequestType.String(), Status: 400, Detail: "bad request", Message: "error reading request body: error decoding json: invalid character '!' looking for beginning of object key string", }, } }, "fail/validate": func(t *testing.T) test { req := UpdateAdminRequest{ Type: -1, } body, err := json.Marshal(req) assert.FatalError(t, err) return test{ ctx: context.Background(), body: body, statusCode: 400, err: &admin.Error{ Type: admin.ErrorBadRequestType.String(), Status: 400, Detail: "bad request", Message: "invalid value for admin type", }, } }, "fail/auth.UpdateAdmin": func(t *testing.T) test { req := UpdateAdminRequest{ Type: linkedca.Admin_ADMIN, } body, err := json.Marshal(req) assert.FatalError(t, err) chiCtx := chi.NewRouteContext() chiCtx.URLParams.Add("id", "adminID") ctx := context.WithValue(context.Background(), chi.RouteCtxKey, chiCtx) auth := &mockAdminAuthority{ MockUpdateAdmin: func(ctx context.Context, id string, nu *linkedca.Admin) (*linkedca.Admin, error) { assert.Equals(t, "adminID", id) assert.Equals(t, linkedca.Admin_ADMIN, nu.Type) return nil, errors.New("force") }, } return test{ ctx: ctx, body: body, auth: auth, statusCode: 500, err: &admin.Error{ Type: admin.ErrorServerInternalType.String(), Status: 500, Detail: "the server experienced an internal error", Message: "error updating admin adminID: force", }, } }, "ok": func(t *testing.T) test { req := UpdateAdminRequest{ Type: linkedca.Admin_ADMIN, } body, err := json.Marshal(req) assert.FatalError(t, err) chiCtx := chi.NewRouteContext() chiCtx.URLParams.Add("id", "adminID") ctx := context.WithValue(context.Background(), chi.RouteCtxKey, chiCtx) adm := &linkedca.Admin{ Id: "adminID", ProvisionerId: "provID", Subject: "admin", Type: linkedca.Admin_SUPER_ADMIN, } auth := &mockAdminAuthority{ MockUpdateAdmin: func(ctx context.Context, id string, nu *linkedca.Admin) (*linkedca.Admin, error) { assert.Equals(t, "adminID", id) assert.Equals(t, linkedca.Admin_ADMIN, nu.Type) return adm, nil }, } return test{ ctx: ctx, body: body, auth: auth, statusCode: 200, err: nil, adm: adm, } }, } for name, prep := range tests { tc := prep(t) t.Run(name, func(t *testing.T) { h := &Handler{ auth: tc.auth, } req := httptest.NewRequest("GET", "/foo", io.NopCloser(bytes.NewBuffer(tc.body))) req = req.WithContext(tc.ctx) w := httptest.NewRecorder() h.UpdateAdmin(w, req) res := w.Result() assert.Equals(t, tc.statusCode, res.StatusCode) if res.StatusCode >= 400 { body, err := io.ReadAll(res.Body) res.Body.Close() assert.FatalError(t, err) adminErr := admin.Error{} assert.FatalError(t, json.Unmarshal(bytes.TrimSpace(body), &adminErr)) assert.Equals(t, tc.err.Type, adminErr.Type) assert.Equals(t, tc.err.Message, adminErr.Message) assert.Equals(t, tc.err.Detail, adminErr.Detail) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) return } adm := &linkedca.Admin{} err := readProtoJSON(res.Body, adm) assert.FatalError(t, err) assert.Equals(t, []string{"application/json"}, res.Header["Content-Type"]) opts := []cmp.Option{cmpopts.IgnoreUnexported(linkedca.Admin{}, timestamppb.Timestamp{})} if !cmp.Equal(tc.adm, adm, opts...) { t.Errorf("h.UpdateAdmin diff =\n%s", cmp.Diff(tc.adm, adm, opts...)) } }) } }