5038348639

Committed 21 May 2023 03:11PM UTC coverage: 89.716% (+0.05%) from 89.667%

Build Type

push

github

Committed by Dean Karn

Commit Message

fix test

Run Details

759 of 846 relevant lines covered (89.72%)

9.46 hits per line

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

87.38

/gitlab/gitlab.go

package gitlab

import (
        "crypto/sha512"
        "crypto/subtle"
        "encoding/json"
        "errors"
        "fmt"
        "io"
        "io/ioutil"
        "net/http"
)

// parse errors
var (
        ErrEventNotSpecifiedToParse      = errors.New("no Event specified to parse")
        ErrInvalidHTTPMethod             = errors.New("invalid HTTP Method")
        ErrMissingGitLabEventHeader      = errors.New("missing X-Gitlab-Event Header")
        ErrGitLabTokenVerificationFailed = errors.New("X-Gitlab-Token validation failed")
        ErrEventNotFound                 = errors.New("event not defined to be parsed")
        ErrParsingPayload                = errors.New("error parsing payload")
        ErrParsingSystemPayload          = errors.New("error parsing system payload")
        // ErrHMACVerificationFailed    = errors.New("HMAC verification failed")
)

// GitLab hook types
const (
        PushEvents               Event  = "Push Hook"
        TagEvents                Event  = "Tag Push Hook"
        IssuesEvents             Event  = "Issue Hook"
        ConfidentialIssuesEvents Event  = "Confidential Issue Hook"
        CommentEvents            Event  = "Note Hook"
        ConfidentialCommentEvents Event = "Confidential Note Hook"
        MergeRequestEvents       Event  = "Merge Request Hook"
        WikiPageEvents           Event  = "Wiki Page Hook"
        PipelineEvents           Event  = "Pipeline Hook"
        BuildEvents              Event  = "Build Hook"
        JobEvents                Event  = "Job Hook"
  DeploymentEvents         Event = "Deployment Hook"
        SystemHookEvents         Event  = "System Hook"
        objectPush               string = "push"
        objectTag                string = "tag_push"
        objectMergeRequest       string = "merge_request"
        objectBuild              string = "build"
        eventProjectCreate       string = "project_create"
        eventProjectDestroy      string = "project_destroy"
        eventProjectRename       string = "project_rename"
        eventProjectTransfer     string = "project_transfer"
        eventProjectUpdate       string = "project_update"
        eventUserAddToTeam       string = "user_add_to_team"
        eventUserRemoveFromTeam  string = "user_remove_from_team"
        eventUserUpdateForTeam   string = "user_update_for_team"
        eventUserCreate          string = "user_create"
        eventUserDestroy         string = "user_destroy"
        eventUserFailedLogin     string = "user_failed_login"
        eventUserRename          string = "user_rename"
        eventKeyCreate           string = "key_create"
        eventKeyDestroy          string = "key_destroy"
        eventGroupCreate         string = "group_create"
        eventGroupDestroy        string = "group_destroy"
        eventGroupRename         string = "group_rename"
        eventUserAddToGroup      string = "user_add_to_group"
        eventUserRemoveFromGroup string = "user_remove_from_group"
        eventUserUpdateForGroup  string = "user_update_for_group"
)

// Option is a configuration option for the webhook
type Option func(*Webhook) error

// Options is a namespace var for configuration options
var Options = WebhookOptions{}

// WebhookOptions is a namespace for configuration option methods
type WebhookOptions struct{}

// Secret registers the GitLab secret
func (WebhookOptions) Secret(secret string) Option {
        return func(hook *Webhook) error {
                // already convert here to prevent timing attack (conversion depends on secret)
                hash := sha512.Sum512([]byte(secret))
                hook.secretHash = hash[:]
                return nil
        }
}

// Webhook instance contains all methods needed to process events
type Webhook struct {
        secretHash []byte
}

// Event defines a GitLab hook event type by the X-Gitlab-Event Header
type Event string

// New creates and returns a WebHook instance denoted by the Provider type
func New(options ...Option) (*Webhook, error) {
        hook := new(Webhook)
        for _, opt := range options {
                if err := opt(hook); err != nil {
                        return nil, errors.New("Error applying Option")
                }
        }
        return hook, nil
}

// Parse verifies and parses the events specified and returns the payload object or an error
func (hook Webhook) Parse(r *http.Request, events ...Event) (interface{}, error) {
        defer func() {
                _, _ = io.Copy(ioutil.Discard, r.Body)
                _ = r.Body.Close()
        }()

        if len(events) == 0 {
                return nil, ErrEventNotSpecifiedToParse
        }
        if r.Method != http.MethodPost {
                return nil, ErrInvalidHTTPMethod
        }

        // If we have a Secret set, we should check in constant time
        if len(hook.secretHash) > 0 {
                tokenHash := sha512.Sum512([]byte(r.Header.Get("X-Gitlab-Token")))
                if subtle.ConstantTimeCompare(tokenHash[:], hook.secretHash[:]) == 0 {
                        return nil, ErrGitLabTokenVerificationFailed
                }
        }

        event := r.Header.Get("X-Gitlab-Event")
        if len(event) == 0 {
                return nil, ErrMissingGitLabEventHeader
        }

        gitLabEvent := Event(event)

        payload, err := ioutil.ReadAll(r.Body)
        if err != nil || len(payload) == 0 {
                return nil, ErrParsingPayload
        }

        return eventParsing(gitLabEvent, events, payload)
}

func eventParsing(gitLabEvent Event, events []Event, payload []byte) (interface{}, error) {

        var found bool
        for _, evt := range events {
                if evt == gitLabEvent {
                        found = true
                        break
                }
        }
        // event not defined to be parsed
        if !found {
                return nil, ErrEventNotFound
        }

        switch gitLabEvent {
        case PushEvents:
                var pl PushEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case TagEvents:
                var pl TagEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case ConfidentialIssuesEvents:
                var pl ConfidentialIssueEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case IssuesEvents:
                var pl IssueEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case ConfidentialCommentEvents:
                var pl ConfidentialCommentEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case CommentEvents:
                var pl CommentEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case MergeRequestEvents:
                var pl MergeRequestEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case WikiPageEvents:
                var pl WikiPageEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case PipelineEvents:
                var pl PipelineEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case BuildEvents:
                var pl BuildEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                return pl, err

        case JobEvents:
                var pl JobEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                if err != nil {
                        return nil, err
                }
                if pl.ObjectKind == objectBuild {
                        return eventParsing(BuildEvents, events, payload)
                }
                return pl, nil

        case DeploymentEvents:
                var pl DeploymentEventPayload
                err := json.Unmarshal([]byte(payload), &pl)
                if err != nil {
                        return nil, err
                }
                return pl, nil

        case SystemHookEvents:
                var pl SystemHookPayload
                err := json.Unmarshal([]byte(payload), &pl)
                if err != nil {
                        return nil, err
                }

                switch pl.ObjectKind {
                case objectPush:
                        return eventParsing(PushEvents, events, payload)

                case objectTag:
                        return eventParsing(TagEvents, events, payload)

                case objectMergeRequest:
                        return eventParsing(MergeRequestEvents, events, payload)
                default:
                        switch pl.EventName {
                        case objectPush:
                                return eventParsing(PushEvents, events, payload)

                        case objectTag:
                                return eventParsing(TagEvents, events, payload)

                        case objectMergeRequest:
                                return eventParsing(MergeRequestEvents, events, payload)

                        case eventProjectCreate:
                                var pl ProjectCreatedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventProjectDestroy:
                                var pl ProjectDestroyedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventProjectRename:
                                var pl ProjectRenamedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventProjectTransfer:
                                var pl ProjectTransferredEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventProjectUpdate:
                                var pl ProjectUpdatedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserAddToTeam:
                                var pl TeamMemberAddedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserRemoveFromTeam:
                                var pl TeamMemberRemovedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserUpdateForTeam:
                                var pl TeamMemberUpdatedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserCreate:
                                var pl UserCreatedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserDestroy:
                                var pl UserRemovedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserFailedLogin:
                                var pl UserFailedLoginEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserRename:
                                var pl UserRenamedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventKeyCreate:
                                var pl KeyAddedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventKeyDestroy:
                                var pl KeyRemovedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventGroupCreate:
                                var pl GroupCreatedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventGroupDestroy:
                                var pl GroupRemovedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventGroupRename:
                                var pl GroupRenamedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserAddToGroup:
                                var pl GroupMemberAddedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserRemoveFromGroup:
                                var pl GroupMemberRemovedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        case eventUserUpdateForGroup:
                                var pl GroupMemberUpdatedEventPayload
                                err := json.Unmarshal([]byte(payload), &pl)
                                return pl, err

                        default:
                                return nil, fmt.Errorf("unknown system hook event %s", gitLabEvent)
                        }
                }
        default:
                return nil, fmt.Errorf("unknown event %s", gitLabEvent)
        }
}

1	package gitlab
2
3	import (
4	"crypto/sha512"
5	"crypto/subtle"
6	"encoding/json"
7	"errors"
8	"fmt"
9	"io"
10	"io/ioutil"
11	"net/http"
12	)
13
14	// parse errors
15	var (
16	ErrEventNotSpecifiedToParse = errors.New("no Event specified to parse")
17	ErrInvalidHTTPMethod = errors.New("invalid HTTP Method")
18	ErrMissingGitLabEventHeader = errors.New("missing X-Gitlab-Event Header")
19	ErrGitLabTokenVerificationFailed = errors.New("X-Gitlab-Token validation failed")
20	ErrEventNotFound = errors.New("event not defined to be parsed")
21	ErrParsingPayload = errors.New("error parsing payload")
22	ErrParsingSystemPayload = errors.New("error parsing system payload")
23	// ErrHMACVerificationFailed = errors.New("HMAC verification failed")
24	)
25
26	// GitLab hook types
27	const (
28	PushEvents Event = "Push Hook"
29	TagEvents Event = "Tag Push Hook"
30	IssuesEvents Event = "Issue Hook"
31	ConfidentialIssuesEvents Event = "Confidential Issue Hook"
32	CommentEvents Event = "Note Hook"
33	ConfidentialCommentEvents Event = "Confidential Note Hook"
34	MergeRequestEvents Event = "Merge Request Hook"
35	WikiPageEvents Event = "Wiki Page Hook"
36	PipelineEvents Event = "Pipeline Hook"
37	BuildEvents Event = "Build Hook"
38	JobEvents Event = "Job Hook"
39	DeploymentEvents Event = "Deployment Hook"
40	SystemHookEvents Event = "System Hook"
41	objectPush string = "push"
42	objectTag string = "tag_push"
43	objectMergeRequest string = "merge_request"
44	objectBuild string = "build"
45	eventProjectCreate string = "project_create"
46	eventProjectDestroy string = "project_destroy"
47	eventProjectRename string = "project_rename"
48	eventProjectTransfer string = "project_transfer"
49	eventProjectUpdate string = "project_update"
50	eventUserAddToTeam string = "user_add_to_team"
51	eventUserRemoveFromTeam string = "user_remove_from_team"
52	eventUserUpdateForTeam string = "user_update_for_team"
53	eventUserCreate string = "user_create"
54	eventUserDestroy string = "user_destroy"
55	eventUserFailedLogin string = "user_failed_login"
56	eventUserRename string = "user_rename"
57	eventKeyCreate string = "key_create"
58	eventKeyDestroy string = "key_destroy"
59	eventGroupCreate string = "group_create"
60	eventGroupDestroy string = "group_destroy"
61	eventGroupRename string = "group_rename"
62	eventUserAddToGroup string = "user_add_to_group"
63	eventUserRemoveFromGroup string = "user_remove_from_group"
64	eventUserUpdateForGroup string = "user_update_for_group"
65	)
66
67	// Option is a configuration option for the webhook
68	type Option func(*Webhook) error
69
70	// Options is a namespace var for configuration options
71	var Options = WebhookOptions{}
72
73	// WebhookOptions is a namespace for configuration option methods
74	type WebhookOptions struct{}
75
76	// Secret registers the GitLab secret
77	func (WebhookOptions) Secret(secret string) Option {	1✔
78	return func(hook *Webhook) error {	2✔
79	// already convert here to prevent timing attack (conversion depends on secret)	1✔
80	hash := sha512.Sum512([]byte(secret))	1✔
81	hook.secretHash = hash[:]	1✔
82	return nil	1✔
83	}	1✔
84	}
85
86	// Webhook instance contains all methods needed to process events
87	type Webhook struct {
88	secretHash []byte
89	}
90
91	// Event defines a GitLab hook event type by the X-Gitlab-Event Header
92	type Event string
93
94	// New creates and returns a WebHook instance denoted by the Provider type
95	func New(options ...Option) (*Webhook, error) {	1✔
96	hook := new(Webhook)	1✔
97	for _, opt := range options {	2✔
98	if err := opt(hook); err != nil {	1✔
99	return nil, errors.New("Error applying Option")	×
100	}	×
101	}
102	return hook, nil	1✔
103	}
104
105	// Parse verifies and parses the events specified and returns the payload object or an error
106	func (hook Webhook) Parse(r *http.Request, events ...Event) (interface{}, error) {	42✔
107	defer func() {	84✔
108	_, _ = io.Copy(ioutil.Discard, r.Body)	42✔
109	_ = r.Body.Close()	42✔
110	}()	42✔
111
112	if len(events) == 0 {	42✔
113	return nil, ErrEventNotSpecifiedToParse	×
114	}	×
115	if r.Method != http.MethodPost {	42✔
116	return nil, ErrInvalidHTTPMethod	×
117	}	×
118
119	// If we have a Secret set, we should check in constant time
120	if len(hook.secretHash) > 0 {	84✔
121	tokenHash := sha512.Sum512([]byte(r.Header.Get("X-Gitlab-Token")))	42✔
122	if subtle.ConstantTimeCompare(tokenHash[:], hook.secretHash[:]) == 0 {	45✔
123	return nil, ErrGitLabTokenVerificationFailed	3✔
124	}	3✔
125	}
126
127	event := r.Header.Get("X-Gitlab-Event")	39✔
128	if len(event) == 0 {	39✔
129	return nil, ErrMissingGitLabEventHeader	×
130	}	×
131
132	gitLabEvent := Event(event)	39✔
133		39✔
134	payload, err := ioutil.ReadAll(r.Body)	39✔
135	if err != nil \|\| len(payload) == 0 {	40✔
136	return nil, ErrParsingPayload	1✔
137	}	1✔
138
139	return eventParsing(gitLabEvent, events, payload)	38✔
140	}
141
142	func eventParsing(gitLabEvent Event, events []Event, payload []byte) (interface{}, error) {	42✔
143		42✔
144	var found bool	42✔
145	for _, evt := range events {	88✔
146	if evt == gitLabEvent {	88✔
147	found = true	42✔
148	break	42✔
149	}
150	}
151	// event not defined to be parsed
152	if !found {	42✔
153	return nil, ErrEventNotFound	×
154	}	×
155
156	switch gitLabEvent {	42✔
157	case PushEvents:	2✔
158	var pl PushEventPayload	2✔
159	err := json.Unmarshal([]byte(payload), &pl)	2✔
160	return pl, err	2✔
161
162	case TagEvents:	2✔
163	var pl TagEventPayload	2✔
164	err := json.Unmarshal([]byte(payload), &pl)	2✔
165	return pl, err	2✔
166
167	case ConfidentialIssuesEvents:	1✔
168	var pl ConfidentialIssueEventPayload	1✔
169	err := json.Unmarshal([]byte(payload), &pl)	1✔
170	return pl, err	1✔
171
172	case IssuesEvents:	1✔
173	var pl IssueEventPayload	1✔
174	err := json.Unmarshal([]byte(payload), &pl)	1✔
175	return pl, err	1✔
176
177	case ConfidentialCommentEvents:	1✔
178	var pl ConfidentialCommentEventPayload	1✔
179	err := json.Unmarshal([]byte(payload), &pl)	1✔
180	return pl, err	1✔
181
182	case CommentEvents:	4✔
183	var pl CommentEventPayload	4✔
184	err := json.Unmarshal([]byte(payload), &pl)	4✔
185	return pl, err	4✔
186
187	case MergeRequestEvents:	2✔
188	var pl MergeRequestEventPayload	2✔
189	err := json.Unmarshal([]byte(payload), &pl)	2✔
190	return pl, err	2✔
191
192	case WikiPageEvents:	1✔
193	var pl WikiPageEventPayload	1✔
194	err := json.Unmarshal([]byte(payload), &pl)	1✔
195	return pl, err	1✔
196
197	case PipelineEvents:	1✔
198	var pl PipelineEventPayload	1✔
199	err := json.Unmarshal([]byte(payload), &pl)	1✔
200	return pl, err	1✔
201
202	case BuildEvents:	2✔
203	var pl BuildEventPayload	2✔
204	err := json.Unmarshal([]byte(payload), &pl)	2✔
205	return pl, err	2✔
206
207	case JobEvents:	1✔
208	var pl JobEventPayload	1✔
209	err := json.Unmarshal([]byte(payload), &pl)	1✔
210	if err != nil {	1✔
211	return nil, err	×
212	}	×
213	if pl.ObjectKind == objectBuild {	2✔
214	return eventParsing(BuildEvents, events, payload)	1✔
215	}	1✔
216	return pl, nil	×
217
218	case DeploymentEvents:	1✔
219	var pl DeploymentEventPayload	1✔
220	err := json.Unmarshal([]byte(payload), &pl)	1✔
221	if err != nil {	1✔
222	return nil, err	×
223	}	×
224	return pl, nil	1✔
225
226	case SystemHookEvents:	23✔
227	var pl SystemHookPayload	23✔
228	err := json.Unmarshal([]byte(payload), &pl)	23✔
229	if err != nil {	23✔
230	return nil, err	×
231	}	×
232
233	switch pl.ObjectKind {	23✔
234	case objectPush:	×
235	return eventParsing(PushEvents, events, payload)	×
236
237	case objectTag:	×
238	return eventParsing(TagEvents, events, payload)	×
239
240	case objectMergeRequest:	1✔
241	return eventParsing(MergeRequestEvents, events, payload)	1✔
242	default:	22✔
243	switch pl.EventName {	22✔
244	case objectPush:	1✔
245	return eventParsing(PushEvents, events, payload)	1✔
246
247	case objectTag:	1✔
248	return eventParsing(TagEvents, events, payload)	1✔
249
250	case objectMergeRequest:	×
251	return eventParsing(MergeRequestEvents, events, payload)	×
252
253	case eventProjectCreate:	1✔
254	var pl ProjectCreatedEventPayload	1✔
255	err := json.Unmarshal([]byte(payload), &pl)	1✔
256	return pl, err	1✔
257
258	case eventProjectDestroy:	1✔
259	var pl ProjectDestroyedEventPayload	1✔
260	err := json.Unmarshal([]byte(payload), &pl)	1✔
261	return pl, err	1✔
262
263	case eventProjectRename:	1✔
264	var pl ProjectRenamedEventPayload	1✔
265	err := json.Unmarshal([]byte(payload), &pl)	1✔
266	return pl, err	1✔
267
268	case eventProjectTransfer:	1✔
269	var pl ProjectTransferredEventPayload	1✔
270	err := json.Unmarshal([]byte(payload), &pl)	1✔
271	return pl, err	1✔
272
273	case eventProjectUpdate:	1✔
274	var pl ProjectUpdatedEventPayload	1✔
275	err := json.Unmarshal([]byte(payload), &pl)	1✔
276	return pl, err	1✔
277
278	case eventUserAddToTeam:	1✔
279	var pl TeamMemberAddedEventPayload	1✔
280	err := json.Unmarshal([]byte(payload), &pl)	1✔
281	return pl, err	1✔
282
283	case eventUserRemoveFromTeam:	1✔
284	var pl TeamMemberRemovedEventPayload	1✔
285	err := json.Unmarshal([]byte(payload), &pl)	1✔
286	return pl, err	1✔
287
288	case eventUserUpdateForTeam:	1✔
289	var pl TeamMemberUpdatedEventPayload	1✔
290	err := json.Unmarshal([]byte(payload), &pl)	1✔
291	return pl, err	1✔
292
293	case eventUserCreate:	1✔
294	var pl UserCreatedEventPayload	1✔
295	err := json.Unmarshal([]byte(payload), &pl)	1✔
296	return pl, err	1✔
297
298	case eventUserDestroy:	1✔
299	var pl UserRemovedEventPayload	1✔
300	err := json.Unmarshal([]byte(payload), &pl)	1✔
301	return pl, err	1✔
302
303	case eventUserFailedLogin:	1✔
304	var pl UserFailedLoginEventPayload	1✔
305	err := json.Unmarshal([]byte(payload), &pl)	1✔
306	return pl, err	1✔
307
308	case eventUserRename:	1✔
309	var pl UserRenamedEventPayload	1✔
310	err := json.Unmarshal([]byte(payload), &pl)	1✔
311	return pl, err	1✔
312
313	case eventKeyCreate:	1✔
314	var pl KeyAddedEventPayload	1✔
315	err := json.Unmarshal([]byte(payload), &pl)	1✔
316	return pl, err	1✔
317
318	case eventKeyDestroy:	1✔
319	var pl KeyRemovedEventPayload	1✔
320	err := json.Unmarshal([]byte(payload), &pl)	1✔
321	return pl, err	1✔
322
323	case eventGroupCreate:	1✔
324	var pl GroupCreatedEventPayload	1✔
325	err := json.Unmarshal([]byte(payload), &pl)	1✔
326	return pl, err	1✔
327
328	case eventGroupDestroy:	1✔
329	var pl GroupRemovedEventPayload	1✔
330	err := json.Unmarshal([]byte(payload), &pl)	1✔
331	return pl, err	1✔
332
333	case eventGroupRename:	1✔
334	var pl GroupRenamedEventPayload	1✔
335	err := json.Unmarshal([]byte(payload), &pl)	1✔
336	return pl, err	1✔
337
338	case eventUserAddToGroup:	1✔
339	var pl GroupMemberAddedEventPayload	1✔
340	err := json.Unmarshal([]byte(payload), &pl)	1✔
341	return pl, err	1✔
342
343	case eventUserRemoveFromGroup:	1✔
344	var pl GroupMemberRemovedEventPayload	1✔
345	err := json.Unmarshal([]byte(payload), &pl)	1✔
346	return pl, err	1✔
347
348	case eventUserUpdateForGroup:	1✔
349	var pl GroupMemberUpdatedEventPayload	1✔
350	err := json.Unmarshal([]byte(payload), &pl)	1✔
351	return pl, err	1✔
352
353	default:	×
354	return nil, fmt.Errorf("unknown system hook event %s", gitLabEvent)	×
355	}
356	}
357	default:	×
358	return nil, fmt.Errorf("unknown event %s", gitLabEvent)	×
359	}
360	}

go-playground / webhooks / 5038348639

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