From 0c966d50e9b4e3d00cc2a8bfc24f2f653f1b10bb Mon Sep 17 00:00:00 2001 From: Luke Kysow Date: Wed, 20 Jun 2018 15:11:44 +0100 Subject: [PATCH] GitlabRequestParser -> GitlabRequestParserValidator --- server/events_controller.go | 8 +- server/events_controller_e2e_test.go | 14 ++-- server/events_controller_test.go | 52 ++++++------ ....go => gitlab_request_parser_validator.go} | 22 ++--- ...> gitlab_request_parser_validator_test.go} | 18 ++-- server/mocks/mock_gitlab_request_parser.go | 84 ------------------- .../mock_gitlab_request_parser_validator.go | 84 +++++++++++++++++++ server/server.go | 28 +++---- 8 files changed, 155 insertions(+), 155 deletions(-) rename server/{gitlab_request_parser.go => gitlab_request_parser_validator.go} (74%) rename server/{gitlab_request_parser_test.go => gitlab_request_parser_validator_test.go} (96%) delete mode 100644 server/mocks/mock_gitlab_request_parser.go create mode 100644 server/mocks/mock_gitlab_request_parser_validator.go diff --git a/server/events_controller.go b/server/events_controller.go index a132b094c..95faa7029 100644 --- a/server/events_controller.go +++ b/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 diff --git a/server/events_controller_e2e_test.go b/server/events_controller_e2e_test.go index 6044b0163..f1dc0958f 100644 --- a/server/events_controller_e2e_test.go +++ b/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: "*", }, diff --git a/server/events_controller_test.go b/server/events_controller_test.go index bb0682ba6..9d35a2265 100644 --- a/server/events_controller_test.go +++ b/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: "*", }, diff --git a/server/gitlab_request_parser.go b/server/gitlab_request_parser_validator.go similarity index 74% rename from server/gitlab_request_parser.go rename to server/gitlab_request_parser_validator.go index 94ab4ddd5..ee486248f 100644 --- a/server/gitlab_request_parser.go +++ b/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" diff --git a/server/gitlab_request_parser_test.go b/server/gitlab_request_parser_validator_test.go similarity index 96% rename from server/gitlab_request_parser_test.go rename to server/gitlab_request_parser_validator_test.go index 385d71879..eacbc1d4a 100644 --- a/server/gitlab_request_parser_test.go +++ b/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) diff --git a/server/mocks/mock_gitlab_request_parser.go b/server/mocks/mock_gitlab_request_parser.go deleted file mode 100644 index e4598a1fe..000000000 --- a/server/mocks/mock_gitlab_request_parser.go +++ /dev/null @@ -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 -} diff --git a/server/mocks/mock_gitlab_request_parser_validator.go b/server/mocks/mock_gitlab_request_parser_validator.go new file mode 100644 index 000000000..c23738294 --- /dev/null +++ b/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 +} diff --git a/server/server.go b/server/server.go index 734a36de4..63bd77a83 100644 --- a/server/server.go +++ b/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,