9344046161

Committed 03 Jun 2024 03:59AM UTC coverage: 74.915% (-0.3%) from 75.222%

Build # 9344046161

Build Type

Pull #125

github

Committed by

rahmatrhd

Commit Message

chore: add additional checking for isExpired

Pull Request Pull Request #125: feat(grant): add restore grant API

Run Details

34 of 108 new or added lines in 4 files covered. (31.48%)

73 existing lines in 3 files now uncovered.

9664 of 12900 relevant lines covered (74.91%)

4.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

51.58

/api/handler/v1beta1/grant.go

package v1beta1

import (
        "context"
        "errors"

        guardianv1beta1 "github.com/goto/guardian/api/proto/gotocompany/guardian/v1beta1"
        "github.com/goto/guardian/core/grant"
        "github.com/goto/guardian/core/provider"
        "github.com/goto/guardian/domain"
        "golang.org/x/sync/errgroup"
        "google.golang.org/grpc/codes"
        "google.golang.org/grpc/status"
)

func (s *GRPCServer) ListGrants(ctx context.Context, req *guardianv1beta1.ListGrantsRequest) (*guardianv1beta1.ListGrantsResponse, error) {
        filter := domain.ListGrantsFilter{
                Q:             req.GetQ(),
                Statuses:      req.GetStatuses(),
                AccountIDs:    req.GetAccountIds(),
                AccountTypes:  req.GetAccountTypes(),
                ResourceIDs:   req.GetResourceIds(),
                Roles:         req.GetRoles(),
                ProviderTypes: req.GetProviderTypes(),
                ProviderURNs:  req.GetProviderUrns(),
                ResourceTypes: req.GetResourceTypes(),
                ResourceURNs:  req.GetResourceUrns(),
                CreatedBy:     req.GetCreatedBy(),
                Owner:         req.GetOwner(),
                OrderBy:       req.GetOrderBy(),
                Size:          int(req.GetSize()),
                Offset:        int(req.GetOffset()),
        }
        grants, total, err := s.listGrants(ctx, filter)
        if err != nil {
                return nil, err
        }

        return &guardianv1beta1.ListGrantsResponse{
                Grants: grants,
                Total:  int32(total),
        }, nil
}

func (s *GRPCServer) ListUserGrants(ctx context.Context, req *guardianv1beta1.ListUserGrantsRequest) (*guardianv1beta1.ListUserGrantsResponse, error) {
        user, err := s.getUser(ctx)

        if err != nil {
                return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")
        }

        filter := domain.ListGrantsFilter{
                Q:             req.GetQ(),
                Statuses:      req.GetStatuses(),
                AccountIDs:    req.GetAccountIds(),
                AccountTypes:  req.GetAccountTypes(),
                ResourceIDs:   req.GetResourceIds(),
                Roles:         req.GetRoles(),
                ProviderTypes: req.GetProviderTypes(),
                ProviderURNs:  req.GetProviderUrns(),
                ResourceTypes: req.GetResourceTypes(),
                ResourceURNs:  req.GetResourceUrns(),
                OrderBy:       req.GetOrderBy(),
                Size:          int(req.GetSize()),
                Offset:        int(req.GetOffset()),
                Owner:         user,
        }
        grants, total, err := s.listGrants(ctx, filter)
        if err != nil {
                return nil, err
        }

        return &guardianv1beta1.ListUserGrantsResponse{
                Grants: grants,
                Total:  int32(total),
        }, nil
}

func (s *GRPCServer) GetGrant(ctx context.Context, req *guardianv1beta1.GetGrantRequest) (*guardianv1beta1.GetGrantResponse, error) {
        a, err := s.grantService.GetByID(ctx, req.GetId())
        if err != nil {
                if errors.Is(err, grant.ErrGrantNotFound) {
                        return nil, status.Errorf(codes.NotFound, "grant %q not found: %v", req.GetId(), err)
                }
                return nil, s.internalError(ctx, "failed to get grant details: %v", err)
        }

        grantProto, err := s.adapter.ToGrantProto(a)
        if err != nil {
                return nil, s.internalError(ctx, "failed to parse grant: %v", err)
        }

        return &guardianv1beta1.GetGrantResponse{
                Grant: grantProto,
        }, nil
}

func (s *GRPCServer) RevokeGrant(ctx context.Context, req *guardianv1beta1.RevokeGrantRequest) (*guardianv1beta1.RevokeGrantResponse, error) {
        actor, err := s.getUser(ctx)
        if err != nil {
                return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")
        }

        a, err := s.grantService.Revoke(ctx, req.GetId(), actor, req.GetReason())
        if err != nil {
                if errors.Is(err, grant.ErrGrantNotFound) {
                        return nil, status.Error(codes.NotFound, "grant not found")
                }
                return nil, s.internalError(ctx, "failed to revoke grant: %v", err)
        }

        grantProto, err := s.adapter.ToGrantProto(a)
        if err != nil {
                return nil, s.internalError(ctx, "failed to parse grant: %v", err)
        }

        return &guardianv1beta1.RevokeGrantResponse{
                Grant: grantProto,
        }, nil
}

func (s *GRPCServer) UpdateGrant(ctx context.Context, req *guardianv1beta1.UpdateGrantRequest) (*guardianv1beta1.UpdateGrantResponse, error) {
        g := &domain.Grant{
                ID:    req.GetId(),
                Owner: req.GetOwner(),
        }
        if err := s.grantService.Update(ctx, g); err != nil {
                switch {
                case errors.Is(err, grant.ErrGrantNotFound):
                        return nil, status.Error(codes.NotFound, err.Error())
                case errors.Is(err, grant.ErrEmptyOwner):
                        return nil, status.Error(codes.InvalidArgument, err.Error())
                default:
                        return nil, s.internalError(ctx, "failed to update grant: %v", err)
                }
        }

        grantProto, err := s.adapter.ToGrantProto(g)
        if err != nil {
                return nil, s.internalError(ctx, "failed to parse grant: %v", err)
        }

        return &guardianv1beta1.UpdateGrantResponse{
                Grant: grantProto,
        }, nil
}

func (s *GRPCServer) RevokeGrants(ctx context.Context, req *guardianv1beta1.RevokeGrantsRequest) (*guardianv1beta1.RevokeGrantsResponse, error) {
        actor, err := s.getUser(ctx)
        if err != nil {
                return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")
        }

        filter := domain.RevokeGrantsFilter{
                AccountIDs:    req.GetAccountIds(),
                ProviderTypes: req.GetProviderTypes(),
                ProviderURNs:  req.GetProviderUrns(),
                ResourceTypes: req.GetResourceTypes(),
                ResourceURNs:  req.GetResourceUrns(),
        }
        grants, err := s.grantService.BulkRevoke(ctx, filter, actor, req.GetReason())
        if err != nil {
                return nil, s.internalError(ctx, "failed to revoke grants in bulk")
        }

        var grantsProto []*guardianv1beta1.Grant
        for _, a := range grants {
                grantProto, err := s.adapter.ToGrantProto(a)
                if err != nil {
                        return nil, s.internalError(ctx, "failed to parse grant: %v", err)
                }
                grantsProto = append(grantsProto, grantProto)
        }

        return &guardianv1beta1.RevokeGrantsResponse{
                Grants: grantsProto,
        }, nil
}

func (s *GRPCServer) RestoreGrant(ctx context.Context, req *guardianv1beta1.RestoreGrantRequest) (*guardianv1beta1.RestoreGrantResponse, error) {
        actor, err := s.getUser(ctx)
        if err != nil {
                return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")
        }

        g, err := s.grantService.Restore(ctx, req.GetId(), actor, req.GetReason())
        if err != nil {
                switch {
                case errors.Is(err, grant.ErrGrantNotFound):
                        return nil, status.Error(codes.NotFound, err.Error())
                case errors.Is(err, grant.ErrInvalidRequest):
                        return nil, status.Error(codes.InvalidArgument, err.Error())
                default:
                        return nil, s.internalError(ctx, "failed to restore grant: %v", err)
                }
        }

        grantProto, err := s.adapter.ToGrantProto(g)
        if err != nil {
                return nil, s.internalError(ctx, "failed to parse grant: %v", err)
        }

        return &guardianv1beta1.RestoreGrantResponse{
                Grant: grantProto,
        }, nil
}

func (s *GRPCServer) listGrants(ctx context.Context, filter domain.ListGrantsFilter) ([]*guardianv1beta1.Grant, int64, error) {
        eg, ctx := errgroup.WithContext(ctx)
        var grants []domain.Grant
        var total int64

        eg.Go(func() error {
                grantRecords, err := s.grantService.List(ctx, filter)
                if err != nil {
                        return s.internalError(ctx, "failed to get grant list: %s", err)
                }
                grants = grantRecords
                return nil
        })
        eg.Go(func() error {
                totalRecord, err := s.grantService.GetGrantsTotalCount(ctx, filter)
                if err != nil {
                        return s.internalError(ctx, "failed to get grant total count: %s", err)
                }
                total = totalRecord
                return nil
        })

        if err := eg.Wait(); err != nil {
                return nil, 0, err
        }

        var grantProtos []*guardianv1beta1.Grant
        for i, a := range grants {
                grantProto, err := s.adapter.ToGrantProto(&grants[i])
                if err != nil {
                        return nil, 0, s.internalError(ctx, "failed to parse grant %q: %v", a.ID, err)
                }
                grantProtos = append(grantProtos, grantProto)
        }

        return grantProtos, total, nil
}

func (s *GRPCServer) ImportGrantsFromProvider(ctx context.Context, req *guardianv1beta1.ImportGrantsFromProviderRequest) (*guardianv1beta1.ImportGrantsFromProviderResponse, error) {
        grants, err := s.grantService.ImportFromProvider(ctx, grant.ImportFromProviderCriteria{
                ProviderID:    req.GetProviderId(),
                ResourceIDs:   req.GetResourceIds(),
                ResourceTypes: req.GetResourceTypes(),
                ResourceURNs:  req.GetResourceUrns(),
        })
        if err != nil {
                switch {
                case errors.Is(err, provider.ErrRecordNotFound):
                        return nil, status.Errorf(codes.NotFound, "provider with id %q not found: %v", req.GetProviderId(), err)
                case errors.Is(err, grant.ErrEmptyImportedGrants):
                        return nil, status.Error(codes.InvalidArgument, err.Error())
                }

                return nil, s.internalError(ctx, "failed to import access: %v", err)
        }

        grantsProto := []*guardianv1beta1.Grant{}
        for _, g := range grants {
                grantProto, err := s.adapter.ToGrantProto(g)
                if err != nil {
                        return nil, s.internalError(ctx, "failed to parse appeal proto %q: %v", g.ID, err)
                }
                grantsProto = append(grantsProto, grantProto)
        }

        return &guardianv1beta1.ImportGrantsFromProviderResponse{
                Grants: grantsProto,
        }, nil
}

func (s *GRPCServer) ListUserRoles(ctx context.Context, req *guardianv1beta1.ListUserRolesRequest) (*guardianv1beta1.ListUserRolesResponse, error) {
        user, err := s.getUser(ctx)
        if err != nil {
                return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")
        }

        roles, err := s.grantService.ListUserRoles(ctx, user)
        if err != nil {
                return nil, s.internalError(ctx, "Internal Error: %s", err)
        }
        return &guardianv1beta1.ListUserRolesResponse{
                Roles: roles,
        }, nil
}

1	package v1beta1
2
3	import (
4	"context"
5	"errors"
6
7	guardianv1beta1 "github.com/goto/guardian/api/proto/gotocompany/guardian/v1beta1"
8	"github.com/goto/guardian/core/grant"
9	"github.com/goto/guardian/core/provider"
10	"github.com/goto/guardian/domain"
11	"golang.org/x/sync/errgroup"
12	"google.golang.org/grpc/codes"
13	"google.golang.org/grpc/status"
14	)
15
16	func (s GRPCServer) ListGrants(ctx context.Context, req guardianv1beta1.ListGrantsRequest) (*guardianv1beta1.ListGrantsResponse, error) {	3✔
17	filter := domain.ListGrantsFilter{	3✔
18	Q: req.GetQ(),	3✔
19	Statuses: req.GetStatuses(),	3✔
20	AccountIDs: req.GetAccountIds(),	3✔
21	AccountTypes: req.GetAccountTypes(),	3✔
22	ResourceIDs: req.GetResourceIds(),	3✔
23	Roles: req.GetRoles(),	3✔
24	ProviderTypes: req.GetProviderTypes(),	3✔
25	ProviderURNs: req.GetProviderUrns(),	3✔
26	ResourceTypes: req.GetResourceTypes(),	3✔
27	ResourceURNs: req.GetResourceUrns(),	3✔
28	CreatedBy: req.GetCreatedBy(),	3✔
29	Owner: req.GetOwner(),	3✔
30	OrderBy: req.GetOrderBy(),	3✔
31	Size: int(req.GetSize()),	3✔
32	Offset: int(req.GetOffset()),	3✔
33	}	3✔
34	grants, total, err := s.listGrants(ctx, filter)	3✔
35	if err != nil {	5✔
36	return nil, err	2✔
37	}	2✔
38
39	return &guardianv1beta1.ListGrantsResponse{	1✔
40	Grants: grants,	1✔
41	Total: int32(total),	1✔
42	}, nil	1✔
43	}
44
45	func (s GRPCServer) ListUserGrants(ctx context.Context, req guardianv1beta1.ListUserGrantsRequest) (*guardianv1beta1.ListUserGrantsResponse, error) {	×
46	user, err := s.getUser(ctx)	×
47		×
48	if err != nil {	×
49	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")	×
50	}	×
51
52	filter := domain.ListGrantsFilter{	×
53	Q: req.GetQ(),	×
54	Statuses: req.GetStatuses(),	×
55	AccountIDs: req.GetAccountIds(),	×
56	AccountTypes: req.GetAccountTypes(),	×
57	ResourceIDs: req.GetResourceIds(),	×
58	Roles: req.GetRoles(),	×
59	ProviderTypes: req.GetProviderTypes(),	×
60	ProviderURNs: req.GetProviderUrns(),	×
61	ResourceTypes: req.GetResourceTypes(),	×
62	ResourceURNs: req.GetResourceUrns(),	×
63	OrderBy: req.GetOrderBy(),	×
64	Size: int(req.GetSize()),	×
65	Offset: int(req.GetOffset()),	×
66	Owner: user,	×
67	}	×
68	grants, total, err := s.listGrants(ctx, filter)	×
69	if err != nil {	×
70	return nil, err	×
71	}	×
72
73	return &guardianv1beta1.ListUserGrantsResponse{	×
74	Grants: grants,	×
75	Total: int32(total),	×
76	}, nil	×
77	}
78
79	func (s GRPCServer) GetGrant(ctx context.Context, req guardianv1beta1.GetGrantRequest) (*guardianv1beta1.GetGrantResponse, error) {	4✔
80	a, err := s.grantService.GetByID(ctx, req.GetId())	4✔
81	if err != nil {	6✔
82	if errors.Is(err, grant.ErrGrantNotFound) {	3✔
83	return nil, status.Errorf(codes.NotFound, "grant %q not found: %v", req.GetId(), err)	1✔
84	}	1✔
85	return nil, s.internalError(ctx, "failed to get grant details: %v", err)	1✔
86	}
87
88	grantProto, err := s.adapter.ToGrantProto(a)	2✔
89	if err != nil {	3✔
90	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	1✔
91	}	1✔
92
93	return &guardianv1beta1.GetGrantResponse{	1✔
94	Grant: grantProto,	1✔
95	}, nil	1✔
96	}
97
98	func (s GRPCServer) RevokeGrant(ctx context.Context, req guardianv1beta1.RevokeGrantRequest) (*guardianv1beta1.RevokeGrantResponse, error) {	×
99	actor, err := s.getUser(ctx)	×
100	if err != nil {	×
101	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")	×
102	}	×
103
104	a, err := s.grantService.Revoke(ctx, req.GetId(), actor, req.GetReason())	×
105	if err != nil {	×
106	if errors.Is(err, grant.ErrGrantNotFound) {	×
107	return nil, status.Error(codes.NotFound, "grant not found")	×
108	}	×
109	return nil, s.internalError(ctx, "failed to revoke grant: %v", err)	×
110	}
111
112	grantProto, err := s.adapter.ToGrantProto(a)	×
113	if err != nil {	×
114	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
115	}	×
116
117	return &guardianv1beta1.RevokeGrantResponse{	×
118	Grant: grantProto,	×
119	}, nil	×
120	}
121
122	func (s GRPCServer) UpdateGrant(ctx context.Context, req guardianv1beta1.UpdateGrantRequest) (*guardianv1beta1.UpdateGrantResponse, error) {	4✔
123	g := &domain.Grant{	4✔
124	ID: req.GetId(),	4✔
125	Owner: req.GetOwner(),	4✔
126	}	4✔
127	if err := s.grantService.Update(ctx, g); err != nil {	7✔
128	switch {	3✔
129	case errors.Is(err, grant.ErrGrantNotFound):	1✔
130	return nil, status.Error(codes.NotFound, err.Error())	1✔
131	case errors.Is(err, grant.ErrEmptyOwner):	1✔
132	return nil, status.Error(codes.InvalidArgument, err.Error())	1✔
133	default:	1✔
134	return nil, s.internalError(ctx, "failed to update grant: %v", err)	1✔
135	}
136	}
137
138	grantProto, err := s.adapter.ToGrantProto(g)	1✔
139	if err != nil {	1✔
140	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
141	}	×
142
143	return &guardianv1beta1.UpdateGrantResponse{	1✔
144	Grant: grantProto,	1✔
145	}, nil	1✔
146	}
147
148	func (s GRPCServer) RevokeGrants(ctx context.Context, req guardianv1beta1.RevokeGrantsRequest) (*guardianv1beta1.RevokeGrantsResponse, error) {	×
149	actor, err := s.getUser(ctx)	×
150	if err != nil {	×
151	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")	×
152	}	×
153
154	filter := domain.RevokeGrantsFilter{	×
155	AccountIDs: req.GetAccountIds(),	×
156	ProviderTypes: req.GetProviderTypes(),	×
157	ProviderURNs: req.GetProviderUrns(),	×
158	ResourceTypes: req.GetResourceTypes(),	×
159	ResourceURNs: req.GetResourceUrns(),	×
160	}	×
161	grants, err := s.grantService.BulkRevoke(ctx, filter, actor, req.GetReason())	×
162	if err != nil {	×
163	return nil, s.internalError(ctx, "failed to revoke grants in bulk")	×
164	}	×
165
166	var grantsProto []*guardianv1beta1.Grant	×
167	for _, a := range grants {	×
168	grantProto, err := s.adapter.ToGrantProto(a)	×
169	if err != nil {	×
170	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
171	}	×
172	grantsProto = append(grantsProto, grantProto)	×
173	}
174
175	return &guardianv1beta1.RevokeGrantsResponse{	×
176	Grants: grantsProto,	×
177	}, nil	×
178	}
179
NEW 180	func (s GRPCServer) RestoreGrant(ctx context.Context, req guardianv1beta1.RestoreGrantRequest) (*guardianv1beta1.RestoreGrantResponse, error) {	×
NEW 181	actor, err := s.getUser(ctx)	×
NEW 182	if err != nil {	×
NEW 183	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")	×
NEW 184	}	×
185
NEW 186	g, err := s.grantService.Restore(ctx, req.GetId(), actor, req.GetReason())	×
NEW 187	if err != nil {	×
NEW 188	switch {	×
NEW 189	case errors.Is(err, grant.ErrGrantNotFound):	×
NEW 190	return nil, status.Error(codes.NotFound, err.Error())	×
NEW 191	case errors.Is(err, grant.ErrInvalidRequest):	×
NEW 192	return nil, status.Error(codes.InvalidArgument, err.Error())	×
NEW 193	default:	×
NEW 194	return nil, s.internalError(ctx, "failed to restore grant: %v", err)	×
195	}
196	}
197
NEW 198	grantProto, err := s.adapter.ToGrantProto(g)	×
NEW 199	if err != nil {	×
NEW 200	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
NEW 201	}	×
202
NEW 203	return &guardianv1beta1.RestoreGrantResponse{	×
NEW 204	Grant: grantProto,	×
NEW 205	}, nil	×
206	}
207
208	func (s GRPCServer) listGrants(ctx context.Context, filter domain.ListGrantsFilter) ([]guardianv1beta1.Grant, int64, error) {	3✔
209	eg, ctx := errgroup.WithContext(ctx)	3✔
210	var grants []domain.Grant	3✔
211	var total int64	3✔
212		3✔
213	eg.Go(func() error {	6✔
214	grantRecords, err := s.grantService.List(ctx, filter)	3✔
215	if err != nil {	4✔
216	return s.internalError(ctx, "failed to get grant list: %s", err)	1✔
217	}	1✔
218	grants = grantRecords	2✔
219	return nil	2✔
220	})
221	eg.Go(func() error {	6✔
222	totalRecord, err := s.grantService.GetGrantsTotalCount(ctx, filter)	3✔
223	if err != nil {	3✔
224	return s.internalError(ctx, "failed to get grant total count: %s", err)	×
225	}	×
226	total = totalRecord	3✔
227	return nil	3✔
228	})
229
230	if err := eg.Wait(); err != nil {	4✔
231	return nil, 0, err	1✔
232	}	1✔
233
234	var grantProtos []*guardianv1beta1.Grant	2✔
235	for i, a := range grants {	4✔
236	grantProto, err := s.adapter.ToGrantProto(&grants[i])	2✔
237	if err != nil {	3✔
238	return nil, 0, s.internalError(ctx, "failed to parse grant %q: %v", a.ID, err)	1✔
239	}	1✔
240	grantProtos = append(grantProtos, grantProto)	1✔
241	}
242
243	return grantProtos, total, nil	1✔
244	}
245
246	func (s GRPCServer) ImportGrantsFromProvider(ctx context.Context, req guardianv1beta1.ImportGrantsFromProviderRequest) (*guardianv1beta1.ImportGrantsFromProviderResponse, error) {	1✔
247	grants, err := s.grantService.ImportFromProvider(ctx, grant.ImportFromProviderCriteria{	1✔
248	ProviderID: req.GetProviderId(),	1✔
249	ResourceIDs: req.GetResourceIds(),	1✔
250	ResourceTypes: req.GetResourceTypes(),	1✔
251	ResourceURNs: req.GetResourceUrns(),	1✔
252	})	1✔
253	if err != nil {	1✔
254	switch {	×
255	case errors.Is(err, provider.ErrRecordNotFound):	×
256	return nil, status.Errorf(codes.NotFound, "provider with id %q not found: %v", req.GetProviderId(), err)	×
257	case errors.Is(err, grant.ErrEmptyImportedGrants):	×
258	return nil, status.Error(codes.InvalidArgument, err.Error())	×
259	}
260
261	return nil, s.internalError(ctx, "failed to import access: %v", err)	×
262	}
263
264	grantsProto := []*guardianv1beta1.Grant{}	1✔
265	for _, g := range grants {	2✔
266	grantProto, err := s.adapter.ToGrantProto(g)	1✔
267	if err != nil {	1✔
268	return nil, s.internalError(ctx, "failed to parse appeal proto %q: %v", g.ID, err)	×
269	}	×
270	grantsProto = append(grantsProto, grantProto)	1✔
271	}
272
273	return &guardianv1beta1.ImportGrantsFromProviderResponse{	1✔
274	Grants: grantsProto,	1✔
275	}, nil	1✔
276	}
277
278	func (s GRPCServer) ListUserRoles(ctx context.Context, req guardianv1beta1.ListUserRolesRequest) (*guardianv1beta1.ListUserRolesResponse, error) {	3✔
279	user, err := s.getUser(ctx)	3✔
280	if err != nil {	4✔
281	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")	1✔
282	}	1✔
283
284	roles, err := s.grantService.ListUserRoles(ctx, user)	2✔
285	if err != nil {	3✔
286	return nil, s.internalError(ctx, "Internal Error: %s", err)	1✔
287	}	1✔
288	return &guardianv1beta1.ListUserRolesResponse{	1✔
289	Roles: roles,	1✔
290	}, nil	1✔
291	}

goto / guardian / 9344046161

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous