10825846087

Committed 04 Sep 2024 10:54AM UTC coverage: 73.998% (-0.3%) from 74.26%

Build # 10825846087

Build Type

push

github

Committed by

web-flow

Commit Message

feat(grant): update grant expiration date (#171)

* feat(grant): update grant expiration date

* chore: fix lint

* fix: fix double imports

* fix: introduce Patch in grant repository to update falsy value to db

* feat: introduce grant diff in update

* fix: pass auth user as actor from handler

* fix: assign actors for diff items

* chore: remove is_permanent field from grant update payload

* fix: add check if grant is inactive

* fix: check update payload diff

* chore: handle error codes properly

* Revert "fix: check update payload diff"

This reverts commit 2dab9f51d.

* test: fix test

Run Details

67 of 128 new or added lines in 5 files covered. (52.34%)

3 existing lines in 2 files now uncovered.

10393 of 14045 relevant lines covered (74.0%)

4.85 hits per line

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

51.34

/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) {
        actor, err := s.getUser(ctx)
        if err != nil {
                return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")
        }

        payload := s.adapter.FromUpdateGrantRequestProto(req)
        payload.Actor = actor
        updatedGrant, err := s.grantService.Update(ctx, payload)
        if err != nil {
                switch {
                case errors.Is(err, grant.ErrGrantNotFound):
                        return nil, status.Error(codes.NotFound, err.Error())
                case errors.Is(err, grant.ErrEmptyOwner),
                        errors.Is(err, domain.ErrInvalidGrantUpdateRequest):
                        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(updatedGrant)
        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, domain.ErrInvalidGrantRestoreParams):
                        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	actor, err := s.getUser(ctx)	4✔
124	if err != nil {	4✔
NEW 125	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")	×
UNCOV 126	}	×
127
128	payload := s.adapter.FromUpdateGrantRequestProto(req)	4✔
129	payload.Actor = actor	4✔
130	updatedGrant, err := s.grantService.Update(ctx, payload)	4✔
131	if err != nil {	7✔
132	switch {	3✔
133	case errors.Is(err, grant.ErrGrantNotFound):	1✔
134	return nil, status.Error(codes.NotFound, err.Error())	1✔
135	case errors.Is(err, grant.ErrEmptyOwner),
136	errors.Is(err, domain.ErrInvalidGrantUpdateRequest):	1✔
137	return nil, status.Error(codes.InvalidArgument, err.Error())	1✔
138	default:	1✔
139	return nil, s.internalError(ctx, "failed to update grant: %v", err)	1✔
140	}
141	}
142
143	grantProto, err := s.adapter.ToGrantProto(updatedGrant)	1✔
144	if err != nil {	1✔
145	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
146	}	×
147
148	return &guardianv1beta1.UpdateGrantResponse{	1✔
149	Grant: grantProto,	1✔
150	}, nil	1✔
151	}
152
153	func (s GRPCServer) RevokeGrants(ctx context.Context, req guardianv1beta1.RevokeGrantsRequest) (*guardianv1beta1.RevokeGrantsResponse, error) {	×
154	actor, err := s.getUser(ctx)	×
155	if err != nil {	×
156	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")	×
157	}	×
158
159	filter := domain.RevokeGrantsFilter{	×
160	AccountIDs: req.GetAccountIds(),	×
161	ProviderTypes: req.GetProviderTypes(),	×
162	ProviderURNs: req.GetProviderUrns(),	×
163	ResourceTypes: req.GetResourceTypes(),	×
164	ResourceURNs: req.GetResourceUrns(),	×
165	}	×
166	grants, err := s.grantService.BulkRevoke(ctx, filter, actor, req.GetReason())	×
167	if err != nil {	×
168	return nil, s.internalError(ctx, "failed to revoke grants in bulk")	×
169	}	×
170
171	var grantsProto []*guardianv1beta1.Grant	×
172	for _, a := range grants {	×
173	grantProto, err := s.adapter.ToGrantProto(a)	×
174	if err != nil {	×
175	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
176	}	×
177	grantsProto = append(grantsProto, grantProto)	×
178	}
179
180	return &guardianv1beta1.RevokeGrantsResponse{	×
181	Grants: grantsProto,	×
182	}, nil	×
183	}
184
185	func (s GRPCServer) RestoreGrant(ctx context.Context, req guardianv1beta1.RestoreGrantRequest) (*guardianv1beta1.RestoreGrantResponse, error) {	×
186	actor, err := s.getUser(ctx)	×
187	if err != nil {	×
188	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: actor")	×
189	}	×
190
191	g, err := s.grantService.Restore(ctx, req.GetId(), actor, req.GetReason())	×
192	if err != nil {	×
193	switch {	×
194	case errors.Is(err, grant.ErrGrantNotFound):	×
195	return nil, status.Error(codes.NotFound, err.Error())	×
196	case errors.Is(err, domain.ErrInvalidGrantRestoreParams):	×
197	return nil, status.Error(codes.InvalidArgument, err.Error())	×
198	default:	×
199	return nil, s.internalError(ctx, "failed to restore grant: %v", err)	×
200	}
201	}
202
203	grantProto, err := s.adapter.ToGrantProto(g)	×
204	if err != nil {	×
205	return nil, s.internalError(ctx, "failed to parse grant: %v", err)	×
206	}	×
207
208	return &guardianv1beta1.RestoreGrantResponse{	×
209	Grant: grantProto,	×
210	}, nil	×
211	}
212
213	func (s GRPCServer) listGrants(ctx context.Context, filter domain.ListGrantsFilter) ([]guardianv1beta1.Grant, int64, error) {	3✔
214	eg, ctx := errgroup.WithContext(ctx)	3✔
215	var grants []domain.Grant	3✔
216	var total int64	3✔
217		3✔
218	eg.Go(func() error {	6✔
219	grantRecords, err := s.grantService.List(ctx, filter)	3✔
220	if err != nil {	4✔
221	return s.internalError(ctx, "failed to get grant list: %s", err)	1✔
222	}	1✔
223	grants = grantRecords	2✔
224	return nil	2✔
225	})
226	eg.Go(func() error {	6✔
227	totalRecord, err := s.grantService.GetGrantsTotalCount(ctx, filter)	3✔
228	if err != nil {	3✔
229	return s.internalError(ctx, "failed to get grant total count: %s", err)	×
230	}	×
231	total = totalRecord	3✔
232	return nil	3✔
233	})
234
235	if err := eg.Wait(); err != nil {	4✔
236	return nil, 0, err	1✔
237	}	1✔
238
239	var grantProtos []*guardianv1beta1.Grant	2✔
240	for i, a := range grants {	4✔
241	grantProto, err := s.adapter.ToGrantProto(&grants[i])	2✔
242	if err != nil {	3✔
243	return nil, 0, s.internalError(ctx, "failed to parse grant %q: %v", a.ID, err)	1✔
244	}	1✔
245	grantProtos = append(grantProtos, grantProto)	1✔
246	}
247
248	return grantProtos, total, nil	1✔
249	}
250
251	func (s GRPCServer) ImportGrantsFromProvider(ctx context.Context, req guardianv1beta1.ImportGrantsFromProviderRequest) (*guardianv1beta1.ImportGrantsFromProviderResponse, error) {	1✔
252	grants, err := s.grantService.ImportFromProvider(ctx, grant.ImportFromProviderCriteria{	1✔
253	ProviderID: req.GetProviderId(),	1✔
254	ResourceIDs: req.GetResourceIds(),	1✔
255	ResourceTypes: req.GetResourceTypes(),	1✔
256	ResourceURNs: req.GetResourceUrns(),	1✔
257	})	1✔
258	if err != nil {	1✔
259	switch {	×
260	case errors.Is(err, provider.ErrRecordNotFound):	×
261	return nil, status.Errorf(codes.NotFound, "provider with id %q not found: %v", req.GetProviderId(), err)	×
262	case errors.Is(err, grant.ErrEmptyImportedGrants):	×
263	return nil, status.Error(codes.InvalidArgument, err.Error())	×
264	}
265
266	return nil, s.internalError(ctx, "failed to import access: %v", err)	×
267	}
268
269	grantsProto := []*guardianv1beta1.Grant{}	1✔
270	for _, g := range grants {	2✔
271	grantProto, err := s.adapter.ToGrantProto(g)	1✔
272	if err != nil {	1✔
273	return nil, s.internalError(ctx, "failed to parse appeal proto %q: %v", g.ID, err)	×
274	}	×
275	grantsProto = append(grantsProto, grantProto)	1✔
276	}
277
278	return &guardianv1beta1.ImportGrantsFromProviderResponse{	1✔
279	Grants: grantsProto,	1✔
280	}, nil	1✔
281	}
282
283	func (s GRPCServer) ListUserRoles(ctx context.Context, req guardianv1beta1.ListUserRolesRequest) (*guardianv1beta1.ListUserRolesResponse, error) {	3✔
284	user, err := s.getUser(ctx)	3✔
285	if err != nil {	4✔
286	return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")	1✔
287	}	1✔
288
289	roles, err := s.grantService.ListUserRoles(ctx, user)	2✔
290	if err != nil {	3✔
291	return nil, s.internalError(ctx, "Internal Error: %s", err)	1✔
292	}	1✔
293	return &guardianv1beta1.ListUserRolesResponse{	1✔
294	Roles: roles,	1✔
295	}, nil	1✔
296	}

goto / guardian / 10825846087

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