GitlabRequestParser -> GitlabRequestParserValidator

server/events_controller.go

@@ -39,9 +39,9 @@ type EventsController struct {
 	// GithubWebHookSecret is the secret added to this webhook via the GitHub
 	// UI that identifies this call as coming from GitHub. If empty, no
 	// request validation is done.
-	GithubWebHookSecret    []byte
-	GithubRequestValidator GithubRequestValidator
-	GitlabRequestParser    GitlabRequestParser
+	GithubWebHookSecret          []byte
+	GithubRequestValidator       GithubRequestValidator
+	GitlabRequestParserValidator GitlabRequestParserValidator
 	// GitlabWebHookSecret is the secret added to this webhook via the GitLab
 	// UI that identifies this call as coming from GitLab. If empty, no
 	// request validation is done.
@@ -208,7 +208,7 @@ func (e *EventsController) handlePullRequestEvent(w http.ResponseWriter, baseRep
 }
 
 func (e *EventsController) handleGitlabPost(w http.ResponseWriter, r *http.Request) {
-	event, err := e.GitlabRequestParser.Validate(r, e.GitlabWebHookSecret)
+	event, err := e.GitlabRequestParserValidator.ParseAndValidate(r, e.GitlabWebHookSecret)
 	if err != nil {
 		e.respond(w, logging.Warn, http.StatusBadRequest, err.Error())
 		return

server/events_controller_e2e_test.go

@@ -286,13 +286,13 @@ func setupE2E(t *testing.T) (server.EventsController, *vcsmocks.MockClientProxy,
 			VCSClient: e2eVCSClient,
 			Workspace: atlantisWorkspace,
 		},
-		Logger:                 logger,
-		Parser:                 eventParser,
-		CommentParser:          commentParser,
-		GithubWebHookSecret:    nil,
-		GithubRequestValidator: &server.DefaultGithubRequestValidator{},
-		GitlabRequestParser:    &server.DefaultGitlabRequestParser{},
-		GitlabWebHookSecret:    nil,
+		Logger:                       logger,
+		Parser:                       eventParser,
+		CommentParser:                commentParser,
+		GithubWebHookSecret:          nil,
+		GithubRequestValidator:       &server.DefaultGithubRequestValidator{},
+		GitlabRequestParserValidator: &server.DefaultGitlabRequestParserValidator{},
+		GitlabWebHookSecret:          nil,
 		RepoWhitelist: &events.RepoWhitelist{
 			Whitelist: "*",
 		},

server/events_controller_test.go

@@ -90,7 +90,7 @@ func TestPost_InvalidGitlabSecret(t *testing.T) {
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn(nil, errors.New("err"))
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(nil, errors.New("err"))
 	e.Post(w, req)
 	responseContains(t, w, http.StatusBadRequest, "err")
 }
@@ -112,7 +112,7 @@ func TestPost_UnsupportedGitlabEvent(t *testing.T) {
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn([]byte(`{"not an event": ""}`), nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn([]byte(`{"not an event": ""}`), nil)
 	e.Post(w, req)
 	responseContains(t, w, http.StatusOK, "Ignoring unsupported event")
 }
@@ -148,7 +148,7 @@ func TestPost_GitlabCommentInvalidCommand(t *testing.T) {
 	e, _, gl, _, _, _, _, cp := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn(gitlab.MergeCommentEvent{}, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlab.MergeCommentEvent{}, nil)
 	When(cp.Parse("", models.Gitlab)).ThenReturn(events.CommentParseResult{Ignore: true})
 	w := httptest.NewRecorder()
 	e.Post(w, req)
@@ -174,13 +174,13 @@ func TestPost_GitlabCommentNotWhitelisted(t *testing.T) {
 	RegisterMockTestingT(t)
 	vcsClient := vcsmocks.NewMockClientProxy()
 	e := server.EventsController{
-		Logger:              logging.NewNoopLogger(),
-		CommentParser:       &events.CommentParser{},
-		GitlabRequestParser: &server.DefaultGitlabRequestParser{},
-		Parser:              &events.EventParser{},
-		SupportedVCSHosts:   []models.VCSHostType{models.Gitlab},
-		RepoWhitelist:       &events.RepoWhitelist{},
-		VCSClient:           vcsClient,
+		Logger:                       logging.NewNoopLogger(),
+		CommentParser:                &events.CommentParser{},
+		GitlabRequestParserValidator: &server.DefaultGitlabRequestParserValidator{},
+		Parser:            &events.EventParser{},
+		SupportedVCSHosts: []models.VCSHostType{models.Gitlab},
+		RepoWhitelist:     &events.RepoWhitelist{},
+		VCSClient:         vcsClient,
 	}
 	requestJSON, err := ioutil.ReadFile(filepath.Join("testfixtures", "gitlabMergeCommentEvent_notWhitelisted.json"))
 	Ok(t, err)
@@ -231,7 +231,7 @@ func TestPost_GitlabCommentResponse(t *testing.T) {
 	e, _, gl, _, _, _, vcsClient, cp := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn(gitlab.MergeCommentEvent{}, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlab.MergeCommentEvent{}, nil)
 	When(cp.Parse("", models.Gitlab)).ThenReturn(events.CommentParseResult{CommentResponse: "a comment"})
 	w := httptest.NewRecorder()
 	e.Post(w, req)
@@ -262,7 +262,7 @@ func TestPost_GitlabCommentSuccess(t *testing.T) {
 	e, _, gl, _, cr, _, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn(gitlab.MergeCommentEvent{}, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlab.MergeCommentEvent{}, nil)
 	w := httptest.NewRecorder()
 	e.Post(w, req)
 	responseContains(t, w, http.StatusOK, "Processing...")
@@ -362,7 +362,7 @@ func TestPost_GitlabMergeRequestErrCleaningPull(t *testing.T) {
 	e, _, gl, p, _, c, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.Closed}
 	When(p.ParseGitlabMergeEvent(gitlabMergeEvent)).ThenReturn(pullRequest, repo, repo, nil)
@@ -395,7 +395,7 @@ func TestPost_GitlabMergeRequestSuccess(t *testing.T) {
 	e, _, gl, p, _, _, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.Validate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.Closed}
 	When(p.ParseGitlabMergeEvent(gitlabMergeEvent)).ThenReturn(pullRequest, repo, repo, nil)
@@ -404,26 +404,26 @@ func TestPost_GitlabMergeRequestSuccess(t *testing.T) {
 	responseContains(t, w, http.StatusOK, "Pull request cleaned successfully")
 }
 
-func setup(t *testing.T) (server.EventsController, *mocks.MockGithubRequestValidator, *mocks.MockGitlabRequestParser, *emocks.MockEventParsing, *emocks.MockCommandRunner, *emocks.MockPullCleaner, *vcsmocks.MockClientProxy, *emocks.MockCommentParsing) {
+func setup(t *testing.T) (server.EventsController, *mocks.MockGithubRequestValidator, *mocks.MockGitlabRequestParserValidator, *emocks.MockEventParsing, *emocks.MockCommandRunner, *emocks.MockPullCleaner, *vcsmocks.MockClientProxy, *emocks.MockCommentParsing) {
 	RegisterMockTestingT(t)
 	v := mocks.NewMockGithubRequestValidator()
-	gl := mocks.NewMockGitlabRequestParser()
+	gl := mocks.NewMockGitlabRequestParserValidator()
 	p := emocks.NewMockEventParsing()
 	cp := emocks.NewMockCommentParsing()
 	cr := emocks.NewMockCommandRunner()
 	c := emocks.NewMockPullCleaner()
 	vcsmock := vcsmocks.NewMockClientProxy()
 	e := server.EventsController{
-		Logger:                 logging.NewNoopLogger(),
-		GithubRequestValidator: v,
-		Parser:                 p,
-		CommentParser:          cp,
-		CommandRunner:          cr,
-		PullCleaner:            c,
-		GithubWebHookSecret:    secret,
-		SupportedVCSHosts:      []models.VCSHostType{models.Github, models.Gitlab},
-		GitlabWebHookSecret:    secret,
-		GitlabRequestParser:    gl,
+		Logger:                       logging.NewNoopLogger(),
+		GithubRequestValidator:       v,
+		Parser:                       p,
+		CommentParser:                cp,
+		CommandRunner:                cr,
+		PullCleaner:                  c,
+		GithubWebHookSecret:          secret,
+		SupportedVCSHosts:            []models.VCSHostType{models.Github, models.Gitlab},
+		GitlabWebHookSecret:          secret,
+		GitlabRequestParserValidator: gl,
 		RepoWhitelist: &events.RepoWhitelist{
 			Whitelist: "*",
 		},

server/gitlab_request_parser_validator.go

@@ -24,18 +24,18 @@ import (
 
 const secretHeader = "X-Gitlab-Token" // #nosec
 
-//go:generate pegomock generate -m --use-experimental-model-gen --package mocks -o mocks/mock_gitlab_request_parser.go GitlabRequestParser
+//go:generate pegomock generate -m --use-experimental-model-gen --package mocks -o mocks/mock_gitlab_request_parser_validator.go GitlabRequestParserValidator
 
-// GitlabRequestParser parses and validates GitLab requests.
-type GitlabRequestParser interface {
-	// Validate validates that the request has a token header matching secret.
+// GitlabRequestParserValidator parses and validates GitLab requests.
+type GitlabRequestParserValidator interface {
+	// ParseAndValidate validates that the request has a token header matching secret.
 	// If the secret does not match it returns an error.
 	// If secret is empty it does not check the token header.
 	// It then parses the request as a GitLab object depending on the header
 	// provided by GitLab identifying the webhook type. If the webhook type
 	// is not recognized it will return nil but will not return an error.
 	// Usage:
-	//	event, err := GitlabRequestParser.Validate(r, secret)
+	//	event, err := GitlabRequestParserValidator.ParseAndValidate(r, secret)
 	//	if err != nil {
 	//		return
 	//	}
@@ -47,15 +47,15 @@ type GitlabRequestParser interface {
 	//	default:
 	//		// unsupported event
 	//	}
-	Validate(r *http.Request, secret []byte) (interface{}, error)
+	ParseAndValidate(r *http.Request, secret []byte) (interface{}, error)
 }
 
-// DefaultGitlabRequestParser parses and validates GitLab requests.
-type DefaultGitlabRequestParser struct{}
+// DefaultGitlabRequestParserValidator parses and validates GitLab requests.
+type DefaultGitlabRequestParserValidator struct{}
 
-// Validate returns the JSON payload of the request.
-// See GitlabRequestParser.Validate()
-func (d *DefaultGitlabRequestParser) Validate(r *http.Request, secret []byte) (interface{}, error) {
+// ParseAndValidate returns the JSON payload of the request.
+// See GitlabRequestParserValidator.ParseAndValidate().
+func (d *DefaultGitlabRequestParserValidator) ParseAndValidate(r *http.Request, secret []byte) (interface{}, error) {
 	const mergeEventHeader = "Merge Request Hook"
 	const noteEventHeader = "Note Hook"
 

server/gitlab_request_parser_validator_test.go

@@ -24,7 +24,7 @@ import (
 	. "github.com/runatlantis/atlantis/testing"
 )
 
-var parser = server.DefaultGitlabRequestParser{}
+var parser = server.DefaultGitlabRequestParserValidator{}
 
 func TestValidate_InvalidSecret(t *testing.T) {
 	t.Log("If the secret header is set and doesn't match expected an error is returned")
@@ -33,7 +33,7 @@ func TestValidate_InvalidSecret(t *testing.T) {
 	req, err := http.NewRequest("POST", "http://localhost/event", buf)
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Token", "does-not-match")
-	_, err = parser.Validate(req, []byte("secret"))
+	_, err = parser.ParseAndValidate(req, []byte("secret"))
 	Assert(t, err != nil, "should be an error")
 	Equals(t, "header X-Gitlab-Token=does-not-match did not match expected secret", err.Error())
 }
@@ -46,7 +46,7 @@ func TestValidate_ValidSecret(t *testing.T) {
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Token", "secret")
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
-	b, err := parser.Validate(req, []byte("secret"))
+	b, err := parser.ParseAndValidate(req, []byte("secret"))
 	Ok(t, err)
 	Equals(t, "Gitlab Test", b.(gitlab.MergeEvent).Project.Name)
 }
@@ -59,7 +59,7 @@ func TestValidate_NoSecret(t *testing.T) {
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Token", "random secret")
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
-	b, err := parser.Validate(req, nil)
+	b, err := parser.ParseAndValidate(req, nil)
 	Ok(t, err)
 	Equals(t, "Gitlab Test", b.(gitlab.MergeEvent).Project.Name)
 }
@@ -71,7 +71,7 @@ func TestValidate_InvalidMergeEvent(t *testing.T) {
 	req, err := http.NewRequest("POST", "http://localhost/event", buf)
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
-	_, err = parser.Validate(req, nil)
+	_, err = parser.ParseAndValidate(req, nil)
 	Assert(t, err != nil, "should be an error")
 	Equals(t, "unexpected end of JSON input", err.Error())
 }
@@ -83,7 +83,7 @@ func TestValidate_InvalidMergeCommentEvent(t *testing.T) {
 	req, err := http.NewRequest("POST", "http://localhost/event", buf)
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Event", "Note Hook")
-	_, err = parser.Validate(req, nil)
+	_, err = parser.ParseAndValidate(req, nil)
 	Assert(t, err != nil, "should be an error")
 	Equals(t, "unexpected end of JSON input", err.Error())
 }
@@ -95,7 +95,7 @@ func TestValidate_UnrecognizedEvent(t *testing.T) {
 	req, err := http.NewRequest("POST", "http://localhost/event", buf)
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Event", "Random Event")
-	event, err := parser.Validate(req, nil)
+	event, err := parser.ParseAndValidate(req, nil)
 	Ok(t, err)
 	Equals(t, nil, event)
 }
@@ -107,7 +107,7 @@ func TestValidate_ValidMergeEvent(t *testing.T) {
 	req, err := http.NewRequest("POST", "http://localhost/event", buf)
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
-	b, err := parser.Validate(req, nil)
+	b, err := parser.ParseAndValidate(req, nil)
 	Ok(t, err)
 	Equals(t, "Gitlab Test", b.(gitlab.MergeEvent).Project.Name)
 	RegisterMockTestingT(t)
@@ -120,7 +120,7 @@ func TestValidate_ValidMergeCommentEvent(t *testing.T) {
 	req, err := http.NewRequest("POST", "http://localhost/event", buf)
 	Ok(t, err)
 	req.Header.Set("X-Gitlab-Event", "Note Hook")
-	b, err := parser.Validate(req, nil)
+	b, err := parser.ParseAndValidate(req, nil)
 	Ok(t, err)
 	Equals(t, "Gitlab Test", b.(gitlab.MergeCommentEvent).Project.Name)
 	RegisterMockTestingT(t)

server/mocks/mock_gitlab_request_parser.go

@@ -1,84 +0,0 @@
-// Automatically generated by pegomock. DO NOT EDIT!
-// Source: github.com/runatlantis/atlantis/server (interfaces: GitlabRequestParser)
-
-package mocks
-
-import (
-	http "net/http"
-	"reflect"
-
-	pegomock "github.com/petergtz/pegomock"
-)
-
-type MockGitlabRequestParser struct {
-	fail func(message string, callerSkip ...int)
-}
-
-func NewMockGitlabRequestParser() *MockGitlabRequestParser {
-	return &MockGitlabRequestParser{fail: pegomock.GlobalFailHandler}
-}
-
-func (mock *MockGitlabRequestParser) Validate(r *http.Request, secret []byte) (interface{}, error) {
-	params := []pegomock.Param{r, secret}
-	result := pegomock.GetGenericMockFrom(mock).Invoke("Validate", params, []reflect.Type{reflect.TypeOf((*interface{})(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
-	var ret0 interface{}
-	var ret1 error
-	if len(result) != 0 {
-		if result[0] != nil {
-			ret0 = result[0].(interface{})
-		}
-		if result[1] != nil {
-			ret1 = result[1].(error)
-		}
-	}
-	return ret0, ret1
-}
-
-func (mock *MockGitlabRequestParser) VerifyWasCalledOnce() *VerifierGitlabRequestParser {
-	return &VerifierGitlabRequestParser{mock, pegomock.Times(1), nil}
-}
-
-func (mock *MockGitlabRequestParser) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierGitlabRequestParser {
-	return &VerifierGitlabRequestParser{mock, invocationCountMatcher, nil}
-}
-
-func (mock *MockGitlabRequestParser) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierGitlabRequestParser {
-	return &VerifierGitlabRequestParser{mock, invocationCountMatcher, inOrderContext}
-}
-
-type VerifierGitlabRequestParser struct {
-	mock                   *MockGitlabRequestParser
-	invocationCountMatcher pegomock.Matcher
-	inOrderContext         *pegomock.InOrderContext
-}
-
-func (verifier *VerifierGitlabRequestParser) Validate(r *http.Request, secret []byte) *GitlabRequestParser_Validate_OngoingVerification {
-	params := []pegomock.Param{r, secret}
-	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Validate", params)
-	return &GitlabRequestParser_Validate_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
-}
-
-type GitlabRequestParser_Validate_OngoingVerification struct {
-	mock              *MockGitlabRequestParser
-	methodInvocations []pegomock.MethodInvocation
-}
-
-func (c *GitlabRequestParser_Validate_OngoingVerification) GetCapturedArguments() (*http.Request, []byte) {
-	r, secret := c.GetAllCapturedArguments()
-	return r[len(r)-1], secret[len(secret)-1]
-}
-
-func (c *GitlabRequestParser_Validate_OngoingVerification) GetAllCapturedArguments() (_param0 []*http.Request, _param1 [][]byte) {
-	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
-	if len(params) > 0 {
-		_param0 = make([]*http.Request, len(params[0]))
-		for u, param := range params[0] {
-			_param0[u] = param.(*http.Request)
-		}
-		_param1 = make([][]byte, len(params[1]))
-		for u, param := range params[1] {
-			_param1[u] = param.([]byte)
-		}
-	}
-	return
-}

server/mocks/mock_gitlab_request_parser_validator.go

@@ -0,0 +1,84 @@
+// Automatically generated by pegomock. DO NOT EDIT!
+// Source: github.com/runatlantis/atlantis/server (interfaces: GitlabRequestParserValidator)
+
+package mocks
+
+import (
+	http "net/http"
+	"reflect"
+
+	pegomock "github.com/petergtz/pegomock"
+)
+
+type MockGitlabRequestParserValidator struct {
+	fail func(message string, callerSkip ...int)
+}
+
+func NewMockGitlabRequestParserValidator() *MockGitlabRequestParserValidator {
+	return &MockGitlabRequestParserValidator{fail: pegomock.GlobalFailHandler}
+}
+
+func (mock *MockGitlabRequestParserValidator) ParseAndValidate(r *http.Request, secret []byte) (interface{}, error) {
+	params := []pegomock.Param{r, secret}
+	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseAndValidate", params, []reflect.Type{reflect.TypeOf((*interface{})(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
+	var ret0 interface{}
+	var ret1 error
+	if len(result) != 0 {
+		if result[0] != nil {
+			ret0 = result[0].(interface{})
+		}
+		if result[1] != nil {
+			ret1 = result[1].(error)
+		}
+	}
+	return ret0, ret1
+}
+
+func (mock *MockGitlabRequestParserValidator) VerifyWasCalledOnce() *VerifierGitlabRequestParserValidator {
+	return &VerifierGitlabRequestParserValidator{mock, pegomock.Times(1), nil}
+}
+
+func (mock *MockGitlabRequestParserValidator) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierGitlabRequestParserValidator {
+	return &VerifierGitlabRequestParserValidator{mock, invocationCountMatcher, nil}
+}
+
+func (mock *MockGitlabRequestParserValidator) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierGitlabRequestParserValidator {
+	return &VerifierGitlabRequestParserValidator{mock, invocationCountMatcher, inOrderContext}
+}
+
+type VerifierGitlabRequestParserValidator struct {
+	mock                   *MockGitlabRequestParserValidator
+	invocationCountMatcher pegomock.Matcher
+	inOrderContext         *pegomock.InOrderContext
+}
+
+func (verifier *VerifierGitlabRequestParserValidator) ParseAndValidate(r *http.Request, secret []byte) *GitlabRequestParserValidator_ParseAndValidate_OngoingVerification {
+	params := []pegomock.Param{r, secret}
+	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseAndValidate", params)
+	return &GitlabRequestParserValidator_ParseAndValidate_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
+}
+
+type GitlabRequestParserValidator_ParseAndValidate_OngoingVerification struct {
+	mock              *MockGitlabRequestParserValidator
+	methodInvocations []pegomock.MethodInvocation
+}
+
+func (c *GitlabRequestParserValidator_ParseAndValidate_OngoingVerification) GetCapturedArguments() (*http.Request, []byte) {
+	r, secret := c.GetAllCapturedArguments()
+	return r[len(r)-1], secret[len(secret)-1]
+}
+
+func (c *GitlabRequestParserValidator_ParseAndValidate_OngoingVerification) GetAllCapturedArguments() (_param0 []*http.Request, _param1 [][]byte) {
+	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
+	if len(params) > 0 {
+		_param0 = make([]*http.Request, len(params[0]))
+		for u, param := range params[0] {
+			_param0[u] = param.(*http.Request)
+		}
+		_param1 = make([][]byte, len(params[1]))
+		for u, param := range params[1] {
+			_param1[u] = param.([]byte)
+		}
+	}
+	return
+}

server/server.go

@@ -273,20 +273,20 @@ func NewServer(userConfig UserConfig, config Config) (*Server, error) {
 		LockDetailTemplate: lockTemplate,
 	}
 	eventsController := &EventsController{
-		CommandRunner:          commandHandler,
-		PullCleaner:            pullClosedExecutor,
-		Parser:                 eventParser,
-		CommentParser:          commentParser,
-		Logger:                 logger,
-		GithubWebHookSecret:    []byte(userConfig.GithubWebHookSecret),
-		GithubRequestValidator: &DefaultGithubRequestValidator{},
-		GitlabRequestParser:    &DefaultGitlabRequestParser{},
-		GitlabWebHookSecret:    []byte(userConfig.GitlabWebHookSecret),
-		RepoWhitelist:          repoWhitelist,
-		SupportedVCSHosts:      supportedVCSHosts,
-		VCSClient:              vcsClient,
-		AtlantisGithubUser:     models.User{Username: userConfig.GithubUser},
-		AtlantisGitlabUser:     models.User{Username: userConfig.GitlabUser},
+		CommandRunner:                commandHandler,
+		PullCleaner:                  pullClosedExecutor,
+		Parser:                       eventParser,
+		CommentParser:                commentParser,
+		Logger:                       logger,
+		GithubWebHookSecret:          []byte(userConfig.GithubWebHookSecret),
+		GithubRequestValidator:       &DefaultGithubRequestValidator{},
+		GitlabRequestParserValidator: &DefaultGitlabRequestParserValidator{},
+		GitlabWebHookSecret:          []byte(userConfig.GitlabWebHookSecret),
+		RepoWhitelist:                repoWhitelist,
+		SupportedVCSHosts:            supportedVCSHosts,
+		VCSClient:                    vcsClient,
+		AtlantisGithubUser:           models.User{Username: userConfig.GithubUser},
+		AtlantisGitlabUser:           models.User{Username: userConfig.GitlabUser},
 	}
 	return &Server{
 		AtlantisVersion:    config.AtlantisVersion,