mocks

May 22, 2024

Changes in this version

+ type MockCommandRequirementHandler_ValidateProjectDependencies_OngoingVerification struct

+ func (c *MockCommandRequirementHandler_ValidateProjectDependencies_OngoingVerification) GetAllCapturedArguments() (_param0 []command.ProjectContext)

+ func (c *MockCommandRequirementHandler_ValidateProjectDependencies_OngoingVerification) GetCapturedArguments() command.ProjectContext

type MockEventParsing

+ func (mock *MockEventParsing) ParseGiteaIssueCommentEvent(event gitea0.GiteaIssueCommentPayload) (models.Repo, models.User, int, error)

+ func (mock *MockEventParsing) ParseGiteaPull(pull *gitea.PullRequest) (models.PullRequest, models.Repo, models.Repo, error)

+ func (mock *MockEventParsing) ParseGiteaPullRequestEvent(event gitea.PullRequest) (models.PullRequest, models.PullRequestEventType, models.Repo, models.Repo, ...)

+ type MockEventParsing_ParseGiteaIssueCommentEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGiteaIssueCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []gitea0.GiteaIssueCommentPayload)

+ func (c *MockEventParsing_ParseGiteaIssueCommentEvent_OngoingVerification) GetCapturedArguments() gitea0.GiteaIssueCommentPayload

+ type MockEventParsing_ParseGiteaPullRequestEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGiteaPullRequestEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []gitea.PullRequest)

+ func (c *MockEventParsing_ParseGiteaPullRequestEvent_OngoingVerification) GetCapturedArguments() gitea.PullRequest

+ type MockEventParsing_ParseGiteaPull_OngoingVerification struct

+ func (c *MockEventParsing_ParseGiteaPull_OngoingVerification) GetAllCapturedArguments() (_param0 []*gitea.PullRequest)

+ func (c *MockEventParsing_ParseGiteaPull_OngoingVerification) GetCapturedArguments() *gitea.PullRequest

type VerifierMockCommandRequirementHandler

+ func (verifier *VerifierMockCommandRequirementHandler) ValidateProjectDependencies(ctx command.ProjectContext) *MockCommandRequirementHandler_ValidateProjectDependencies_OngoingVerification

type VerifierMockEventParsing

+ func (verifier *VerifierMockEventParsing) ParseGiteaIssueCommentEvent(event gitea0.GiteaIssueCommentPayload) *MockEventParsing_ParseGiteaIssueCommentEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGiteaPull(pull *gitea.PullRequest) *MockEventParsing_ParseGiteaPull_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGiteaPullRequestEvent(event gitea.PullRequest) *MockEventParsing_ParseGiteaPullRequestEvent_OngoingVerification

Dec 12, 2023

Changes in this version

type MockCommandRequirementHandler

+ func (mock *MockCommandRequirementHandler) ValidateProjectDependencies(_param0 command.ProjectContext) (string, error)

Oct 6, 2023

Changes in this version

type MockWorkingDir

+ func (mock *MockWorkingDir) GetGitUntrackedFiles(r models.Repo, p models.PullRequest, workspace string) ([]string, error)

+ func (mock *MockWorkingDir) SetCheckForUpstreamChanges()

+ type MockWorkingDir_GetGitUntrackedFiles_OngoingVerification struct

+ func (c *MockWorkingDir_GetGitUntrackedFiles_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *MockWorkingDir_GetGitUntrackedFiles_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)

+ type MockWorkingDir_SetCheckForUpstreamChanges_OngoingVerification struct

+ func (c *MockWorkingDir_SetCheckForUpstreamChanges_OngoingVerification) GetAllCapturedArguments()

+ func (c *MockWorkingDir_SetCheckForUpstreamChanges_OngoingVerification) GetCapturedArguments()

type VerifierMockWorkingDir

+ func (verifier *VerifierMockWorkingDir) GetGitUntrackedFiles(r models.Repo, p models.PullRequest, workspace string) *MockWorkingDir_GetGitUntrackedFiles_OngoingVerification

+ func (verifier *VerifierMockWorkingDir) SetCheckForUpstreamChanges() *MockWorkingDir_SetCheckForUpstreamChanges_OngoingVerification

Jul 12, 2023

Changes in this version

type MockWorkingDir

+ func (mock *MockWorkingDir) DeletePlan(r models.Repo, p models.PullRequest, workspace string, path string, ...) error

+ type MockWorkingDir_DeletePlan_OngoingVerification struct

+ func (c *MockWorkingDir_DeletePlan_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string, ...)

+ func (c *MockWorkingDir_DeletePlan_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string, string, string)

type VerifierMockWorkingDir

+ func (verifier *VerifierMockWorkingDir) DeletePlan(r models.Repo, p models.PullRequest, workspace string, path string, ...) *MockWorkingDir_DeletePlan_OngoingVerification

Jun 20, 2023

Changes in this version

+ type MockCommentBuilder_BuildApprovePoliciesComment_OngoingVerification struct

+ func (c *MockCommentBuilder_BuildApprovePoliciesComment_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string)

+ func (c *MockCommentBuilder_BuildApprovePoliciesComment_OngoingVerification) GetCapturedArguments() (string, string, string)

type MockWorkingDir

+ func (mock *MockWorkingDir) SetSafeToReClone()

+ type MockWorkingDir_SetSafeToReClone_OngoingVerification struct

+ func (c *MockWorkingDir_SetSafeToReClone_OngoingVerification) GetAllCapturedArguments()

+ func (c *MockWorkingDir_SetSafeToReClone_OngoingVerification) GetCapturedArguments()

type VerifierMockCommentBuilder

+ func (verifier *VerifierMockCommentBuilder) BuildApprovePoliciesComment(repoRelDir string, workspace string, project string) *MockCommentBuilder_BuildApprovePoliciesComment_OngoingVerification

type VerifierMockWorkingDir

+ func (verifier *VerifierMockWorkingDir) SetSafeToReClone() *MockWorkingDir_SetSafeToReClone_OngoingVerification

May 22, 2023

Changes in this version

type MockCommentBuilder

+ func (mock *MockCommentBuilder) BuildApprovePoliciesComment(_param0 string, _param1 string, _param2 string) string

Mar 1, 2023

Changes in this version

type MockCommandRequirementHandler

+ func (mock *MockCommandRequirementHandler) ValidatePlanProject(_param0 string, _param1 command.ProjectContext) (string, error)

+ type MockCommandRequirementHandler_ValidatePlanProject_OngoingVerification struct

+ func (c *MockCommandRequirementHandler_ValidatePlanProject_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []command.ProjectContext)

+ func (c *MockCommandRequirementHandler_ValidatePlanProject_OngoingVerification) GetCapturedArguments() (string, command.ProjectContext)

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) BuildStateRmCommands(_param0 *command.Context, _param1 *events.CommentCommand) ([]command.ProjectContext, error)

+ type MockProjectCommandBuilder_BuildStateRmCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildStateRmCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*command.Context, _param1 []*events.CommentCommand)

+ func (c *MockProjectCommandBuilder_BuildStateRmCommands_OngoingVerification) GetCapturedArguments() (*command.Context, *events.CommentCommand)

type MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) StateRm(_param0 command.ProjectContext) command.ProjectResult

+ type MockProjectCommandRunner_StateRm_OngoingVerification struct

+ func (c *MockProjectCommandRunner_StateRm_OngoingVerification) GetAllCapturedArguments() (_param0 []command.ProjectContext)

+ func (c *MockProjectCommandRunner_StateRm_OngoingVerification) GetCapturedArguments() command.ProjectContext

type VerifierMockCommandRequirementHandler

+ func (verifier *VerifierMockCommandRequirementHandler) ValidatePlanProject(_param0 string, _param1 command.ProjectContext) *MockCommandRequirementHandler_ValidatePlanProject_OngoingVerification

type VerifierMockProjectCommandBuilder

+ func (verifier *VerifierMockProjectCommandBuilder) BuildStateRmCommands(_param0 *command.Context, _param1 *events.CommentCommand) *MockProjectCommandBuilder_BuildStateRmCommands_OngoingVerification

type VerifierMockProjectCommandRunner

+ func (verifier *VerifierMockProjectCommandRunner) StateRm(_param0 command.ProjectContext) *MockProjectCommandRunner_StateRm_OngoingVerification

Dec 30, 2022

Changes in this version

+ type MockCommandRequirementHandler struct

+ func NewMockCommandRequirementHandler(options ...pegomock.Option) *MockCommandRequirementHandler

+ func (mock *MockCommandRequirementHandler) FailHandler() pegomock.FailHandler

+ func (mock *MockCommandRequirementHandler) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockCommandRequirementHandler) ValidateApplyProject(_param0 string, _param1 command.ProjectContext) (string, error)

+ func (mock *MockCommandRequirementHandler) ValidateImportProject(_param0 string, _param1 command.ProjectContext) (string, error)

+ func (mock *MockCommandRequirementHandler) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockCommandRequirementHandler

+ func (mock *MockCommandRequirementHandler) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockCommandRequirementHandler

+ func (mock *MockCommandRequirementHandler) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockCommandRequirementHandler

+ func (mock *MockCommandRequirementHandler) VerifyWasCalledOnce() *VerifierMockCommandRequirementHandler

+ type MockCommandRequirementHandler_ValidateApplyProject_OngoingVerification struct

+ func (c *MockCommandRequirementHandler_ValidateApplyProject_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []command.ProjectContext)

+ func (c *MockCommandRequirementHandler_ValidateApplyProject_OngoingVerification) GetCapturedArguments() (string, command.ProjectContext)

+ type MockCommandRequirementHandler_ValidateImportProject_OngoingVerification struct

+ func (c *MockCommandRequirementHandler_ValidateImportProject_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []command.ProjectContext)

+ func (c *MockCommandRequirementHandler_ValidateImportProject_OngoingVerification) GetCapturedArguments() (string, command.ProjectContext)

type MockCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) UpdatePostWorkflowHook(_param0 models.PullRequest, _param1 models.CommitStatus, _param2 string, ...) error

+ func (mock *MockCommitStatusUpdater) UpdatePreWorkflowHook(_param0 models.PullRequest, _param1 models.CommitStatus, _param2 string, ...) error

+ type MockCommitStatusUpdater_UpdatePostWorkflowHook_OngoingVerification struct

+ func (c *MockCommitStatusUpdater_UpdatePostWorkflowHook_OngoingVerification) GetAllCapturedArguments() (_param0 []models.PullRequest, _param1 []models.CommitStatus, _param2 []string, ...)

+ func (c *MockCommitStatusUpdater_UpdatePostWorkflowHook_OngoingVerification) GetCapturedArguments() (models.PullRequest, models.CommitStatus, string, string, string)

+ type MockCommitStatusUpdater_UpdatePreWorkflowHook_OngoingVerification struct

+ func (c *MockCommitStatusUpdater_UpdatePreWorkflowHook_OngoingVerification) GetAllCapturedArguments() (_param0 []models.PullRequest, _param1 []models.CommitStatus, _param2 []string, ...)

+ func (c *MockCommitStatusUpdater_UpdatePreWorkflowHook_OngoingVerification) GetCapturedArguments() (models.PullRequest, models.CommitStatus, string, string, string)

+ type MockEventParsing_ParseAPIPlanRequest_OngoingVerification struct

+ func (c *MockEventParsing_ParseAPIPlanRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []models.VCSHostType, _param1 []string, _param2 []string)

+ func (c *MockEventParsing_ParseAPIPlanRequest_OngoingVerification) GetCapturedArguments() (models.VCSHostType, string, string)

+ type MockPostWorkflowHookURLGenerator struct

+ func NewMockPostWorkflowHookURLGenerator(options ...pegomock.Option) *MockPostWorkflowHookURLGenerator

+ func (mock *MockPostWorkflowHookURLGenerator) FailHandler() pegomock.FailHandler

+ func (mock *MockPostWorkflowHookURLGenerator) GenerateProjectWorkflowHookURL(_param0 string) (string, error)

+ func (mock *MockPostWorkflowHookURLGenerator) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockPostWorkflowHookURLGenerator) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockPostWorkflowHookURLGenerator

+ func (mock *MockPostWorkflowHookURLGenerator) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockPostWorkflowHookURLGenerator

+ func (mock *MockPostWorkflowHookURLGenerator) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockPostWorkflowHookURLGenerator

+ func (mock *MockPostWorkflowHookURLGenerator) VerifyWasCalledOnce() *VerifierMockPostWorkflowHookURLGenerator

+ type MockPostWorkflowHookURLGenerator_GenerateProjectWorkflowHookURL_OngoingVerification struct

+ func (c *MockPostWorkflowHookURLGenerator_GenerateProjectWorkflowHookURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockPostWorkflowHookURLGenerator_GenerateProjectWorkflowHookURL_OngoingVerification) GetCapturedArguments() string

+ type MockPreWorkflowHookURLGenerator struct

+ func NewMockPreWorkflowHookURLGenerator(options ...pegomock.Option) *MockPreWorkflowHookURLGenerator

+ func (mock *MockPreWorkflowHookURLGenerator) FailHandler() pegomock.FailHandler

+ func (mock *MockPreWorkflowHookURLGenerator) GenerateProjectWorkflowHookURL(_param0 string) (string, error)

+ func (mock *MockPreWorkflowHookURLGenerator) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockPreWorkflowHookURLGenerator) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockPreWorkflowHookURLGenerator

+ func (mock *MockPreWorkflowHookURLGenerator) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockPreWorkflowHookURLGenerator

+ func (mock *MockPreWorkflowHookURLGenerator) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockPreWorkflowHookURLGenerator

+ func (mock *MockPreWorkflowHookURLGenerator) VerifyWasCalledOnce() *VerifierMockPreWorkflowHookURLGenerator

+ type MockPreWorkflowHookURLGenerator_GenerateProjectWorkflowHookURL_OngoingVerification struct

+ func (c *MockPreWorkflowHookURLGenerator_GenerateProjectWorkflowHookURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockPreWorkflowHookURLGenerator_GenerateProjectWorkflowHookURL_OngoingVerification) GetCapturedArguments() string

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) BuildImportCommands(_param0 *command.Context, _param1 *events.CommentCommand) ([]command.ProjectContext, error)

+ type MockProjectCommandBuilder_BuildImportCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildImportCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*command.Context, _param1 []*events.CommentCommand)

+ func (c *MockProjectCommandBuilder_BuildImportCommands_OngoingVerification) GetCapturedArguments() (*command.Context, *events.CommentCommand)

type MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) Import(_param0 command.ProjectContext) command.ProjectResult

+ type MockProjectCommandRunner_Import_OngoingVerification struct

+ func (c *MockProjectCommandRunner_Import_OngoingVerification) GetAllCapturedArguments() (_param0 []command.ProjectContext)

+ func (c *MockProjectCommandRunner_Import_OngoingVerification) GetCapturedArguments() command.ProjectContext

+ type VerifierMockCommandRequirementHandler struct

+ func (verifier *VerifierMockCommandRequirementHandler) ValidateApplyProject(_param0 string, _param1 command.ProjectContext) *MockCommandRequirementHandler_ValidateApplyProject_OngoingVerification

+ func (verifier *VerifierMockCommandRequirementHandler) ValidateImportProject(_param0 string, _param1 command.ProjectContext) *MockCommandRequirementHandler_ValidateImportProject_OngoingVerification

type VerifierMockCommitStatusUpdater

+ func (verifier *VerifierMockCommitStatusUpdater) UpdatePostWorkflowHook(_param0 models.PullRequest, _param1 models.CommitStatus, _param2 string, ...) *MockCommitStatusUpdater_UpdatePostWorkflowHook_OngoingVerification

+ func (verifier *VerifierMockCommitStatusUpdater) UpdatePreWorkflowHook(_param0 models.PullRequest, _param1 models.CommitStatus, _param2 string, ...) *MockCommitStatusUpdater_UpdatePreWorkflowHook_OngoingVerification

type VerifierMockEventParsing

+ func (verifier *VerifierMockEventParsing) ParseAPIPlanRequest(_param0 models.VCSHostType, _param1 string, _param2 string) *MockEventParsing_ParseAPIPlanRequest_OngoingVerification

+ type VerifierMockPostWorkflowHookURLGenerator struct

+ func (verifier *VerifierMockPostWorkflowHookURLGenerator) GenerateProjectWorkflowHookURL(_param0 string) ...

+ type VerifierMockPreWorkflowHookURLGenerator struct

+ func (verifier *VerifierMockPreWorkflowHookURLGenerator) GenerateProjectWorkflowHookURL(_param0 string) ...

type VerifierMockProjectCommandBuilder

+ func (verifier *VerifierMockProjectCommandBuilder) BuildImportCommands(_param0 *command.Context, _param1 *events.CommentCommand) *MockProjectCommandBuilder_BuildImportCommands_OngoingVerification

type VerifierMockProjectCommandRunner

+ func (verifier *VerifierMockProjectCommandRunner) Import(_param0 command.ProjectContext) *MockProjectCommandRunner_Import_OngoingVerification

Aug 16, 2022

Changes in this version

type MockEventParsing

+ func (mock *MockEventParsing) ParseAPIPlanRequest(vcsHostType models.VCSHostType, repoFullName string, cloneURL string) (models.Repo, error)

Jul 14, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jul 8, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jul 8, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

type MockEventParsing

+ func (mock *MockEventParsing) ParseGitlabMergeRequestUpdateEvent(event go_gitlab.MergeEvent) models.PullRequestEventType

+ type MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeEvent)

+ func (c *MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeEvent

type VerifierMockEventParsing

+ func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequestUpdateEvent(event go_gitlab.MergeEvent) *MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification

Jun 29, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jun 22, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jun 16, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jun 6, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

May 13, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

May 13, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 29, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 8, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 11, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 8, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 7, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 4, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 3, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 2, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Feb 28, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockJobIDGenerator struct

+ func NewMockJobIDGenerator(options ...pegomock.Option) *MockJobIDGenerator

+ func (mock *MockJobIDGenerator) FailHandler() pegomock.FailHandler

+ func (mock *MockJobIDGenerator) GenerateJobID() string

+ func (mock *MockJobIDGenerator) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockJobIDGenerator) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockJobIDGenerator

+ func (mock *MockJobIDGenerator) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockJobIDGenerator

+ func (mock *MockJobIDGenerator) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockJobIDGenerator

+ func (mock *MockJobIDGenerator) VerifyWasCalledOnce() *VerifierMockJobIDGenerator

+ type MockJobIDGenerator_GenerateJobID_OngoingVerification struct

+ func (c *MockJobIDGenerator_GenerateJobID_OngoingVerification) GetAllCapturedArguments()

+ func (c *MockJobIDGenerator_GenerateJobID_OngoingVerification) GetCapturedArguments()

+ type MockJobMessageSender struct

+ func NewMockJobMessageSender(options ...pegomock.Option) *MockJobMessageSender

+ func (mock *MockJobMessageSender) FailHandler() pegomock.FailHandler

+ func (mock *MockJobMessageSender) Send(_param0 models.ProjectCommandContext, _param1 string, _param2 bool)

+ func (mock *MockJobMessageSender) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockJobMessageSender) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockJobMessageSender

+ func (mock *MockJobMessageSender) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockJobMessageSender

+ func (mock *MockJobMessageSender) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockJobMessageSender

+ func (mock *MockJobMessageSender) VerifyWasCalledOnce() *VerifierMockJobMessageSender

+ type MockJobMessageSender_Send_OngoingVerification struct

+ func (c *MockJobMessageSender_Send_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []string, _param2 []bool)

+ func (c *MockJobMessageSender_Send_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, string, bool)

+ type MockJobURLSetter struct

+ func NewMockJobURLSetter(options ...pegomock.Option) *MockJobURLSetter

+ func (mock *MockJobURLSetter) FailHandler() pegomock.FailHandler

+ func (mock *MockJobURLSetter) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockJobURLSetter) SetJobURLWithStatus(_param0 models.ProjectCommandContext, _param1 models.CommandName, ...) error

+ func (mock *MockJobURLSetter) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockJobURLSetter

+ func (mock *MockJobURLSetter) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockJobURLSetter

+ func (mock *MockJobURLSetter) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockJobURLSetter

+ func (mock *MockJobURLSetter) VerifyWasCalledOnce() *VerifierMockJobURLSetter

+ type MockJobURLSetter_SetJobURLWithStatus_OngoingVerification struct

+ func (c *MockJobURLSetter_SetJobURLWithStatus_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []models.CommandName, ...)

+ func (c *MockJobURLSetter_SetJobURLWithStatus_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, models.CommandName, models.CommitStatus)

+ type MockResourceCleaner struct

+ func NewMockResourceCleaner(options ...pegomock.Option) *MockResourceCleaner

+ func (mock *MockResourceCleaner) CleanUp(_param0 jobs.PullInfo)

+ func (mock *MockResourceCleaner) FailHandler() pegomock.FailHandler

+ func (mock *MockResourceCleaner) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockResourceCleaner) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockResourceCleaner

+ func (mock *MockResourceCleaner) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockResourceCleaner

+ func (mock *MockResourceCleaner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockResourceCleaner

+ func (mock *MockResourceCleaner) VerifyWasCalledOnce() *VerifierMockResourceCleaner

+ type MockResourceCleaner_CleanUp_OngoingVerification struct

+ func (c *MockResourceCleaner_CleanUp_OngoingVerification) GetAllCapturedArguments() (_param0 []jobs.PullInfo)

+ func (c *MockResourceCleaner_CleanUp_OngoingVerification) GetCapturedArguments() jobs.PullInfo

+ type VerifierMockJobIDGenerator struct

+ func (verifier *VerifierMockJobIDGenerator) GenerateJobID() *MockJobIDGenerator_GenerateJobID_OngoingVerification

+ type VerifierMockJobMessageSender struct

+ func (verifier *VerifierMockJobMessageSender) Send(_param0 models.ProjectCommandContext, _param1 string, _param2 bool) *MockJobMessageSender_Send_OngoingVerification

+ type VerifierMockJobURLSetter struct

+ func (verifier *VerifierMockJobURLSetter) SetJobURLWithStatus(_param0 models.ProjectCommandContext, _param1 models.CommandName, ...) *MockJobURLSetter_SetJobURLWithStatus_OngoingVerification

+ type VerifierMockResourceCleaner struct

+ func (verifier *VerifierMockResourceCleaner) CleanUp(_param0 jobs.PullInfo) *MockResourceCleaner_CleanUp_OngoingVerification

Jan 25, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockPostWorkflowHooksCommandRunner struct

+ func NewMockPostWorkflowHooksCommandRunner(options ...pegomock.Option) *MockPostWorkflowHooksCommandRunner

+ func (mock *MockPostWorkflowHooksCommandRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockPostWorkflowHooksCommandRunner) RunPostHooks(ctx *events.CommandContext) error

+ func (mock *MockPostWorkflowHooksCommandRunner) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockPostWorkflowHooksCommandRunner) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockPostWorkflowHooksCommandRunner

+ func (mock *MockPostWorkflowHooksCommandRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockPostWorkflowHooksCommandRunner

+ func (mock *MockPostWorkflowHooksCommandRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockPostWorkflowHooksCommandRunner

+ func (mock *MockPostWorkflowHooksCommandRunner) VerifyWasCalledOnce() *VerifierMockPostWorkflowHooksCommandRunner

+ type MockPostWorkflowHooksCommandRunner_RunPostHooks_OngoingVerification struct

+ func (c *MockPostWorkflowHooksCommandRunner_RunPostHooks_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *MockPostWorkflowHooksCommandRunner_RunPostHooks_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type VerifierMockPostWorkflowHooksCommandRunner struct

+ func (verifier *VerifierMockPostWorkflowHooksCommandRunner) RunPostHooks(ctx *events.CommandContext) *MockPostWorkflowHooksCommandRunner_RunPostHooks_OngoingVerification

Jan 5, 2022 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Dec 30, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockJobsUrlGenerator struct

+ func NewMockJobsUrlGenerator(options ...pegomock.Option) *MockJobsUrlGenerator

+ func (mock *MockJobsUrlGenerator) FailHandler() pegomock.FailHandler

+ func (mock *MockJobsUrlGenerator) GenerateProjectJobsUrl(pull models.PullRequest, p models.ProjectCommandContext) string

+ func (mock *MockJobsUrlGenerator) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockJobsUrlGenerator) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockJobsUrlGenerator

+ func (mock *MockJobsUrlGenerator) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockJobsUrlGenerator

+ func (mock *MockJobsUrlGenerator) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockJobsUrlGenerator

+ func (mock *MockJobsUrlGenerator) VerifyWasCalledOnce() *VerifierMockJobsUrlGenerator

+ type MockJobsUrlGenerator_GenerateProjectJobsUrl_OngoingVerification struct

+ func (c *MockJobsUrlGenerator_GenerateProjectJobsUrl_OngoingVerification) GetAllCapturedArguments() (_param0 []models.PullRequest, _param1 []models.ProjectCommandContext)

+ func (c *MockJobsUrlGenerator_GenerateProjectJobsUrl_OngoingVerification) GetCapturedArguments() (models.PullRequest, models.ProjectCommandContext)

+ type VerifierMockJobsUrlGenerator struct

+ func (verifier *VerifierMockJobsUrlGenerator) GenerateProjectJobsUrl(pull models.PullRequest, p models.ProjectCommandContext) *MockJobsUrlGenerator_GenerateProjectJobsUrl_OngoingVerification

Dec 17, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Nov 4, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Oct 6, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Aug 31, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockApplyRequirement struct

+ func NewMockApplyRequirement(options ...pegomock.Option) *MockApplyRequirement

+ func (mock *MockApplyRequirement) FailHandler() pegomock.FailHandler

+ func (mock *MockApplyRequirement) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockApplyRequirement) ValidateProject(_param0 string, _param1 models.ProjectCommandContext) (string, error)

+ func (mock *MockApplyRequirement) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockApplyRequirement

+ func (mock *MockApplyRequirement) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockApplyRequirement

+ func (mock *MockApplyRequirement) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockApplyRequirement

+ func (mock *MockApplyRequirement) VerifyWasCalledOnce() *VerifierMockApplyRequirement

+ type MockApplyRequirement_ValidateProject_OngoingVerification struct

+ func (c *MockApplyRequirement_ValidateProject_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []models.ProjectCommandContext)

+ func (c *MockApplyRequirement_ValidateProject_OngoingVerification) GetCapturedArguments() (string, models.ProjectCommandContext)

type MockCommentBuilder

+ func (mock *MockCommentBuilder) BuildVersionComment(repoRelDir string, workspace string, project string) string

+ type MockCommentBuilder_BuildVersionComment_OngoingVerification struct

+ func (c *MockCommentBuilder_BuildVersionComment_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string)

+ func (c *MockCommentBuilder_BuildVersionComment_OngoingVerification) GetCapturedArguments() (string, string, string)

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) BuildVersionCommands(ctx *events.CommandContext, comment *events.CommentCommand) ([]models.ProjectCommandContext, error)

+ type MockProjectCommandBuilder_BuildVersionCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildVersionCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *MockProjectCommandBuilder_BuildVersionCommands_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

type MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) Version(ctx models.ProjectCommandContext) models.ProjectResult

+ type MockProjectCommandRunner_Version_OngoingVerification struct

+ func (c *MockProjectCommandRunner_Version_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *MockProjectCommandRunner_Version_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

type MockWorkingDir

+ func (mock *MockWorkingDir) IsFileTracked(log logging.SimpleLogging, cloneDir string, filename string) (bool, error)

+ type MockWorkingDir_HasDiverged_OngoingVerification struct

+ func (c *MockWorkingDir_HasDiverged_OngoingVerification) GetAllCapturedArguments() (_param0 []logging.SimpleLogging, _param1 []string)

+ func (c *MockWorkingDir_HasDiverged_OngoingVerification) GetCapturedArguments() (logging.SimpleLogging, string)

+ type MockWorkingDir_IsFileTracked_OngoingVerification struct

+ func (c *MockWorkingDir_IsFileTracked_OngoingVerification) GetAllCapturedArguments() (_param0 []logging.SimpleLogging, _param1 []string, _param2 []string)

+ func (c *MockWorkingDir_IsFileTracked_OngoingVerification) GetCapturedArguments() (logging.SimpleLogging, string, string)

+ type VerifierMockApplyRequirement struct

+ func (verifier *VerifierMockApplyRequirement) ValidateProject(_param0 string, _param1 models.ProjectCommandContext) *MockApplyRequirement_ValidateProject_OngoingVerification

type VerifierMockCommentBuilder

+ func (verifier *VerifierMockCommentBuilder) BuildVersionComment(repoRelDir string, workspace string, project string) *MockCommentBuilder_BuildVersionComment_OngoingVerification

type VerifierMockProjectCommandBuilder

+ func (verifier *VerifierMockProjectCommandBuilder) BuildVersionCommands(ctx *events.CommandContext, comment *events.CommentCommand) *MockProjectCommandBuilder_BuildVersionCommands_OngoingVerification

type VerifierMockProjectCommandRunner

+ func (verifier *VerifierMockProjectCommandRunner) Version(ctx models.ProjectCommandContext) *MockProjectCommandRunner_Version_OngoingVerification

type VerifierMockWorkingDir

+ func (verifier *VerifierMockWorkingDir) HasDiverged(log logging.SimpleLogging, cloneDir string) *MockWorkingDir_HasDiverged_OngoingVerification

+ func (verifier *VerifierMockWorkingDir) IsFileTracked(log logging.SimpleLogging, cloneDir string, filename string) *MockWorkingDir_IsFileTracked_OngoingVerification

Jun 30, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jun 24, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

type MockWorkingDir

+ func (mock *MockWorkingDir) HasDiverged(log logging.SimpleLogging, cloneDir string) bool

Apr 26, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockApplyCommandLocker struct

+ func NewMockApplyCommandLocker(options ...pegomock.Option) *MockApplyCommandLocker

+ func (mock *MockApplyCommandLocker) FailHandler() pegomock.FailHandler

+ func (mock *MockApplyCommandLocker) IsDisabled(ctx *events.CommandContext) bool

+ func (mock *MockApplyCommandLocker) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockApplyCommandLocker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockApplyCommandLocker

+ func (mock *MockApplyCommandLocker) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockApplyCommandLocker

+ func (mock *MockApplyCommandLocker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierMockApplyCommandLocker

+ func (mock *MockApplyCommandLocker) VerifyWasCalledOnce() *VerifierMockApplyCommandLocker

+ type MockApplyCommandLocker_IsDisabled_OngoingVerification struct

+ func (c *MockApplyCommandLocker_IsDisabled_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *MockApplyCommandLocker_IsDisabled_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type MockCommentBuilder struct

+ func NewMockCommentBuilder(options ...pegomock.Option) *MockCommentBuilder

+ func (mock *MockCommentBuilder) BuildApplyComment(repoRelDir string, workspace string, project string) string

+ func (mock *MockCommentBuilder) BuildPlanComment(repoRelDir string, workspace string, project string, commentArgs []string) string

+ func (mock *MockCommentBuilder) FailHandler() pegomock.FailHandler

+ func (mock *MockCommentBuilder) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockCommentBuilder) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockCommentBuilder

+ func (mock *MockCommentBuilder) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockCommentBuilder

+ func (mock *MockCommentBuilder) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, ...) *VerifierMockCommentBuilder

+ func (mock *MockCommentBuilder) VerifyWasCalledOnce() *VerifierMockCommentBuilder

+ type MockCommentBuilder_BuildApplyComment_OngoingVerification struct

+ func (c *MockCommentBuilder_BuildApplyComment_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string)

+ func (c *MockCommentBuilder_BuildApplyComment_OngoingVerification) GetCapturedArguments() (string, string, string)

+ type MockCommentBuilder_BuildPlanComment_OngoingVerification struct

+ func (c *MockCommentBuilder_BuildPlanComment_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 [][]string)

+ func (c *MockCommentBuilder_BuildPlanComment_OngoingVerification) GetCapturedArguments() (string, string, string, []string)

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) BuildApprovePoliciesCommands(ctx *events.CommandContext, comment *events.CommentCommand) ([]models.ProjectCommandContext, error)

+ type MockProjectCommandBuilder_BuildApprovePoliciesCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildApprovePoliciesCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *MockProjectCommandBuilder_BuildApprovePoliciesCommands_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

type MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) ApprovePolicies(ctx models.ProjectCommandContext) models.ProjectResult

+ func (mock *MockProjectCommandRunner) PolicyCheck(ctx models.ProjectCommandContext) models.ProjectResult

+ type MockProjectCommandRunner_ApprovePolicies_OngoingVerification struct

+ func (c *MockProjectCommandRunner_ApprovePolicies_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *MockProjectCommandRunner_ApprovePolicies_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

+ type MockProjectCommandRunner_PolicyCheck_OngoingVerification struct

+ func (c *MockProjectCommandRunner_PolicyCheck_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *MockProjectCommandRunner_PolicyCheck_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

+ type VerifierMockApplyCommandLocker struct

+ func (verifier *VerifierMockApplyCommandLocker) IsDisabled(ctx *events.CommandContext) *MockApplyCommandLocker_IsDisabled_OngoingVerification

+ type VerifierMockCommentBuilder struct

+ func (verifier *VerifierMockCommentBuilder) BuildApplyComment(repoRelDir string, workspace string, project string) *MockCommentBuilder_BuildApplyComment_OngoingVerification

+ func (verifier *VerifierMockCommentBuilder) BuildPlanComment(repoRelDir string, workspace string, project string, commentArgs []string) *MockCommentBuilder_BuildPlanComment_OngoingVerification

type VerifierMockProjectCommandBuilder

+ func (verifier *VerifierMockProjectCommandBuilder) BuildApprovePoliciesCommands(ctx *events.CommandContext, comment *events.CommentCommand) *MockProjectCommandBuilder_BuildApprovePoliciesCommands_OngoingVerification

type VerifierMockProjectCommandRunner

+ func (verifier *VerifierMockProjectCommandRunner) ApprovePolicies(ctx models.ProjectCommandContext) *MockProjectCommandRunner_ApprovePolicies_OngoingVerification

+ func (verifier *VerifierMockProjectCommandRunner) PolicyCheck(ctx models.ProjectCommandContext) *MockProjectCommandRunner_PolicyCheck_OngoingVerification

Feb 23, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Feb 8, 2021 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Dec 21, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockPreWorkflowHooksCommandRunner struct

+ func NewMockPreWorkflowHooksCommandRunner(options ...pegomock.Option) *MockPreWorkflowHooksCommandRunner

+ func (mock *MockPreWorkflowHooksCommandRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockPreWorkflowHooksCommandRunner) RunPreHooks(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, ...)

+ func (mock *MockPreWorkflowHooksCommandRunner) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockPreWorkflowHooksCommandRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockPreWorkflowHooksCommandRunner

+ func (mock *MockPreWorkflowHooksCommandRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockPreWorkflowHooksCommandRunner

+ func (mock *MockPreWorkflowHooksCommandRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierMockPreWorkflowHooksCommandRunner

+ func (mock *MockPreWorkflowHooksCommandRunner) VerifyWasCalledOnce() *VerifierMockPreWorkflowHooksCommandRunner

+ type MockPreWorkflowHooksCommandRunner_RunPreHooks_OngoingVerification struct

+ func (c *MockPreWorkflowHooksCommandRunner_RunPreHooks_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.Repo, _param2 []models.PullRequest, ...)

+ func (c *MockPreWorkflowHooksCommandRunner_RunPreHooks_OngoingVerification) GetCapturedArguments() (models.Repo, models.Repo, models.PullRequest, models.User)

+ type VerifierMockPreWorkflowHooksCommandRunner struct

+ func (verifier *VerifierMockPreWorkflowHooksCommandRunner) RunPreHooks(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, ...) *MockPreWorkflowHooksCommandRunner_RunPreHooks_OngoingVerification

Oct 23, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Aug 18, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jul 7, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockDeleteLockCommand struct

+ func NewMockDeleteLockCommand(options ...pegomock.Option) *MockDeleteLockCommand

+ func (mock *MockDeleteLockCommand) DeleteLock(id string) (*models.ProjectLock, error)

+ func (mock *MockDeleteLockCommand) DeleteLocksByPull(repoFullName string, pullNum int) error

+ func (mock *MockDeleteLockCommand) FailHandler() pegomock.FailHandler

+ func (mock *MockDeleteLockCommand) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockDeleteLockCommand) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockDeleteLockCommand

+ func (mock *MockDeleteLockCommand) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockDeleteLockCommand

+ func (mock *MockDeleteLockCommand) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierMockDeleteLockCommand

+ func (mock *MockDeleteLockCommand) VerifyWasCalledOnce() *VerifierMockDeleteLockCommand

+ type MockDeleteLockCommand_DeleteLock_OngoingVerification struct

+ func (c *MockDeleteLockCommand_DeleteLock_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockDeleteLockCommand_DeleteLock_OngoingVerification) GetCapturedArguments() string

+ type MockDeleteLockCommand_DeleteLocksByPull_OngoingVerification struct

+ func (c *MockDeleteLockCommand_DeleteLocksByPull_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int)

+ func (c *MockDeleteLockCommand_DeleteLocksByPull_OngoingVerification) GetCapturedArguments() (string, int)

+ type VerifierMockDeleteLockCommand struct

+ func (verifier *VerifierMockDeleteLockCommand) DeleteLock(id string) *MockDeleteLockCommand_DeleteLock_OngoingVerification

+ func (verifier *VerifierMockDeleteLockCommand) DeleteLocksByPull(repoFullName string, pullNum int) *MockDeleteLockCommand_DeleteLocksByPull_OngoingVerification

May 29, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 24, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jan 22, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jan 20, 2020 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Nov 27, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Oct 30, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Oct 28, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockAzureDevopsPullGetter struct

+ func NewMockAzureDevopsPullGetter(options ...pegomock.Option) *MockAzureDevopsPullGetter

+ func (mock *MockAzureDevopsPullGetter) FailHandler() pegomock.FailHandler

+ func (mock *MockAzureDevopsPullGetter) GetPullRequest(repo models.Repo, pullNum int) (*azuredevops.GitPullRequest, error)

+ func (mock *MockAzureDevopsPullGetter) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockAzureDevopsPullGetter) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockAzureDevopsPullGetter

+ func (mock *MockAzureDevopsPullGetter) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockAzureDevopsPullGetter

+ func (mock *MockAzureDevopsPullGetter) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierMockAzureDevopsPullGetter

+ func (mock *MockAzureDevopsPullGetter) VerifyWasCalledOnce() *VerifierMockAzureDevopsPullGetter

+ type MockAzureDevopsPullGetter_GetPullRequest_OngoingVerification struct

+ func (c *MockAzureDevopsPullGetter_GetPullRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []int)

+ func (c *MockAzureDevopsPullGetter_GetPullRequest_OngoingVerification) GetCapturedArguments() (models.Repo, int)

type MockEventParsing

+ func (mock *MockEventParsing) ParseAzureDevopsPull(adPull *azuredevops.GitPullRequest) (models.PullRequest, models.Repo, models.Repo, error)

+ func (mock *MockEventParsing) ParseAzureDevopsPullEvent(pullEvent azuredevops.Event) (models.PullRequest, models.PullRequestEventType, models.Repo, models.Repo, ...)

+ func (mock *MockEventParsing) ParseAzureDevopsRepo(adRepo *azuredevops.GitRepository) (models.Repo, error)

+ type MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []azuredevops.Event)

+ func (c *MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification) GetCapturedArguments() azuredevops.Event

+ type MockEventParsing_ParseAzureDevopsPull_OngoingVerification struct

+ func (c *MockEventParsing_ParseAzureDevopsPull_OngoingVerification) GetAllCapturedArguments() (_param0 []*azuredevops.GitPullRequest)

+ func (c *MockEventParsing_ParseAzureDevopsPull_OngoingVerification) GetCapturedArguments() *azuredevops.GitPullRequest

+ type MockEventParsing_ParseAzureDevopsRepo_OngoingVerification struct

+ func (c *MockEventParsing_ParseAzureDevopsRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []*azuredevops.GitRepository)

+ func (c *MockEventParsing_ParseAzureDevopsRepo_OngoingVerification) GetCapturedArguments() *azuredevops.GitRepository

+ type VerifierMockAzureDevopsPullGetter struct

+ func (verifier *VerifierMockAzureDevopsPullGetter) GetPullRequest(repo models.Repo, pullNum int) *MockAzureDevopsPullGetter_GetPullRequest_OngoingVerification

type VerifierMockEventParsing

+ func (verifier *VerifierMockEventParsing) ParseAzureDevopsPull(adPull *azuredevops.GitPullRequest) *MockEventParsing_ParseAzureDevopsPull_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseAzureDevopsPullEvent(pullEvent azuredevops.Event) *MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseAzureDevopsRepo(adRepo *azuredevops.GitRepository) *MockEventParsing_ParseAzureDevopsRepo_OngoingVerification

Aug 26, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockEnvStepRunner struct

+ func NewMockEnvStepRunner(options ...pegomock.Option) *MockEnvStepRunner

+ func (mock *MockEnvStepRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockEnvStepRunner) Run(ctx models.ProjectCommandContext, cmd string, value string, path string, ...) (string, error)

+ func (mock *MockEnvStepRunner) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockEnvStepRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockEnvStepRunner

+ func (mock *MockEnvStepRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockEnvStepRunner

+ func (mock *MockEnvStepRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierMockEnvStepRunner

+ func (mock *MockEnvStepRunner) VerifyWasCalledOnce() *VerifierMockEnvStepRunner

+ type MockEnvStepRunner_Run_OngoingVerification struct

+ func (c *MockEnvStepRunner_Run_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []string, _param2 []string, ...)

+ func (c *MockEnvStepRunner_Run_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, string, string, string, map[string]string)

+ type VerifierMockEnvStepRunner struct

+ func (verifier *VerifierMockEnvStepRunner) Run(ctx models.ProjectCommandContext, cmd string, value string, path string, ...) *MockEnvStepRunner_Run_OngoingVerification

Jul 12, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockCommandRunner_RunAutoplanCommand_OngoingVerification struct

+ func (c *MockCommandRunner_RunAutoplanCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.Repo, _param2 []models.PullRequest, ...)

+ func (c *MockCommandRunner_RunAutoplanCommand_OngoingVerification) GetCapturedArguments() (models.Repo, models.Repo, models.PullRequest, models.User)

+ type MockCommandRunner_RunCommentCommand_OngoingVerification struct

+ func (c *MockCommandRunner_RunCommentCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []*models.Repo, _param2 []*models.PullRequest, ...)

+ func (c *MockCommandRunner_RunCommentCommand_OngoingVerification) GetCapturedArguments() (models.Repo, *models.Repo, *models.PullRequest, models.User, int, ...)

+ type MockCommentParsing_Parse_OngoingVerification struct

+ func (c *MockCommentParsing_Parse_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []models.VCSHostType)

+ func (c *MockCommentParsing_Parse_OngoingVerification) GetCapturedArguments() (string, models.VCSHostType)

+ type MockCommitStatusUpdater_UpdateCombinedCount_OngoingVerification struct

+ func (c *MockCommitStatusUpdater_UpdateCombinedCount_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, ...)

+ func (c *MockCommitStatusUpdater_UpdateCombinedCount_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, models.CommitStatus, models.CommandName, int, ...)

+ type MockCommitStatusUpdater_UpdateCombined_OngoingVerification struct

+ func (c *MockCommitStatusUpdater_UpdateCombined_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, ...)

+ func (c *MockCommitStatusUpdater_UpdateCombined_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, models.CommitStatus, models.CommandName)

+ type MockCommitStatusUpdater_UpdateProject_OngoingVerification struct

+ func (c *MockCommitStatusUpdater_UpdateProject_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []models.CommandName, ...)

+ func (c *MockCommitStatusUpdater_UpdateProject_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, models.CommandName, models.CommitStatus, string)

+ type MockCustomStepRunner_Run_OngoingVerification struct

+ func (c *MockCustomStepRunner_Run_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []string, _param2 []string)

+ func (c *MockCustomStepRunner_Run_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, string, string)

+ type MockEventParsing_GetBitbucketCloudPullEventType_OngoingVerification struct

+ func (c *MockEventParsing_GetBitbucketCloudPullEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockEventParsing_GetBitbucketCloudPullEventType_OngoingVerification) GetCapturedArguments() string

+ type MockEventParsing_GetBitbucketServerPullEventType_OngoingVerification struct

+ func (c *MockEventParsing_GetBitbucketServerPullEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockEventParsing_GetBitbucketServerPullEventType_OngoingVerification) GetCapturedArguments() string

+ type MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification) GetCapturedArguments() []byte

+ type MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification) GetCapturedArguments() []byte

+ type MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification) GetCapturedArguments() []byte

+ type MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification) GetCapturedArguments() []byte

+ type MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.IssueCommentEvent)

+ func (c *MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification) GetCapturedArguments() *github.IssueCommentEvent

+ type MockEventParsing_ParseGithubPullEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGithubPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.PullRequestEvent)

+ func (c *MockEventParsing_ParseGithubPullEvent_OngoingVerification) GetCapturedArguments() *github.PullRequestEvent

+ type MockEventParsing_ParseGithubPull_OngoingVerification struct

+ func (c *MockEventParsing_ParseGithubPull_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.PullRequest)

+ func (c *MockEventParsing_ParseGithubPull_OngoingVerification) GetCapturedArguments() *github.PullRequest

+ type MockEventParsing_ParseGithubRepo_OngoingVerification struct

+ func (c *MockEventParsing_ParseGithubRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.Repository)

+ func (c *MockEventParsing_ParseGithubRepo_OngoingVerification) GetCapturedArguments() *github.Repository

+ type MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeCommentEvent)

+ func (c *MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeCommentEvent

+ type MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification struct

+ func (c *MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeEvent)

+ func (c *MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeEvent

+ type MockEventParsing_ParseGitlabMergeRequest_OngoingVerification struct

+ func (c *MockEventParsing_ParseGitlabMergeRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []*go_gitlab.MergeRequest, _param1 []models.Repo)

+ func (c *MockEventParsing_ParseGitlabMergeRequest_OngoingVerification) GetCapturedArguments() (*go_gitlab.MergeRequest, models.Repo)

+ type MockGithubPullGetter_GetPullRequest_OngoingVerification struct

+ func (c *MockGithubPullGetter_GetPullRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []int)

+ func (c *MockGithubPullGetter_GetPullRequest_OngoingVerification) GetCapturedArguments() (models.Repo, int)

+ type MockGitlabMergeRequestGetter_GetMergeRequest_OngoingVerification struct

+ func (c *MockGitlabMergeRequestGetter_GetMergeRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int)

+ func (c *MockGitlabMergeRequestGetter_GetMergeRequest_OngoingVerification) GetCapturedArguments() (string, int)

+ type MockLockURLGenerator_GenerateLockURL_OngoingVerification struct

+ func (c *MockLockURLGenerator_GenerateLockURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockLockURLGenerator_GenerateLockURL_OngoingVerification) GetCapturedArguments() string

+ type MockPendingPlanFinder_DeletePlans_OngoingVerification struct

+ func (c *MockPendingPlanFinder_DeletePlans_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockPendingPlanFinder_DeletePlans_OngoingVerification) GetCapturedArguments() string

+ type MockPendingPlanFinder_Find_OngoingVerification struct

+ func (c *MockPendingPlanFinder_Find_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *MockPendingPlanFinder_Find_OngoingVerification) GetCapturedArguments() string

+ type MockProjectCommandBuilder_BuildApplyCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildApplyCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *MockProjectCommandBuilder_BuildApplyCommands_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

+ type MockProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *MockProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type MockProjectCommandBuilder_BuildPlanCommands_OngoingVerification struct

+ func (c *MockProjectCommandBuilder_BuildPlanCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *MockProjectCommandBuilder_BuildPlanCommands_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

+ type MockProjectCommandRunner_Apply_OngoingVerification struct

+ func (c *MockProjectCommandRunner_Apply_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *MockProjectCommandRunner_Apply_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

+ type MockProjectCommandRunner_Plan_OngoingVerification struct

+ func (c *MockProjectCommandRunner_Plan_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *MockProjectCommandRunner_Plan_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

+ type MockProjectLocker_TryLock_OngoingVerification struct

+ func (c *MockProjectLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []models.PullRequest, ...)

+ func (c *MockProjectLocker_TryLock_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, models.PullRequest, models.User, string, models.Project)

+ type MockPullCleaner_CleanUpPull_OngoingVerification struct

+ func (c *MockPullCleaner_CleanUpPull_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *MockPullCleaner_CleanUpPull_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type MockStepRunner_Run_OngoingVerification struct

+ func (c *MockStepRunner_Run_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 [][]string, _param2 []string)

+ func (c *MockStepRunner_Run_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, []string, string)

+ type MockWebhooksSender_Send_OngoingVerification struct

+ func (c *MockWebhooksSender_Send_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []webhooks.ApplyResult)

+ func (c *MockWebhooksSender_Send_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, webhooks.ApplyResult)

+ type MockWorkingDirLocker_TryLockPull_OngoingVerification struct

+ func (c *MockWorkingDirLocker_TryLockPull_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int)

+ func (c *MockWorkingDirLocker_TryLockPull_OngoingVerification) GetCapturedArguments() (string, int)

+ type MockWorkingDirLocker_TryLock_OngoingVerification struct

+ func (c *MockWorkingDirLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int, _param2 []string)

+ func (c *MockWorkingDirLocker_TryLock_OngoingVerification) GetCapturedArguments() (string, int, string)

+ type MockWorkingDir_Clone_OngoingVerification struct

+ func (c *MockWorkingDir_Clone_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []models.Repo, _param2 []models.Repo, ...)

+ func (c *MockWorkingDir_Clone_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, models.Repo, models.Repo, models.PullRequest, string)

+ type MockWorkingDir_DeleteForWorkspace_OngoingVerification struct

+ func (c *MockWorkingDir_DeleteForWorkspace_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *MockWorkingDir_DeleteForWorkspace_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)

+ type MockWorkingDir_Delete_OngoingVerification struct

+ func (c *MockWorkingDir_Delete_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *MockWorkingDir_Delete_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type MockWorkingDir_GetPullDir_OngoingVerification struct

+ func (c *MockWorkingDir_GetPullDir_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *MockWorkingDir_GetPullDir_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type MockWorkingDir_GetWorkingDir_OngoingVerification struct

+ func (c *MockWorkingDir_GetWorkingDir_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *MockWorkingDir_GetWorkingDir_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)

+ type VerifierMockCommandRunner struct

+ func (verifier *VerifierMockCommandRunner) RunAutoplanCommand(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, ...) *MockCommandRunner_RunAutoplanCommand_OngoingVerification

+ func (verifier *VerifierMockCommandRunner) RunCommentCommand(baseRepo models.Repo, maybeHeadRepo *models.Repo, ...) *MockCommandRunner_RunCommentCommand_OngoingVerification

+ type VerifierMockCommentParsing struct

+ func (verifier *VerifierMockCommentParsing) Parse(comment string, vcsHost models.VCSHostType) *MockCommentParsing_Parse_OngoingVerification

+ type VerifierMockCommitStatusUpdater struct

+ func (verifier *VerifierMockCommitStatusUpdater) UpdateCombined(repo models.Repo, pull models.PullRequest, status models.CommitStatus, ...) *MockCommitStatusUpdater_UpdateCombined_OngoingVerification

+ func (verifier *VerifierMockCommitStatusUpdater) UpdateCombinedCount(repo models.Repo, pull models.PullRequest, status models.CommitStatus, ...) *MockCommitStatusUpdater_UpdateCombinedCount_OngoingVerification

+ func (verifier *VerifierMockCommitStatusUpdater) UpdateProject(ctx models.ProjectCommandContext, cmdName models.CommandName, ...) *MockCommitStatusUpdater_UpdateProject_OngoingVerification

+ type VerifierMockCustomStepRunner struct

+ func (verifier *VerifierMockCustomStepRunner) Run(ctx models.ProjectCommandContext, cmd string, path string) *MockCustomStepRunner_Run_OngoingVerification

+ type VerifierMockEventParsing struct

+ func (verifier *VerifierMockEventParsing) GetBitbucketCloudPullEventType(eventTypeHeader string) *MockEventParsing_GetBitbucketCloudPullEventType_OngoingVerification

+ func (verifier *VerifierMockEventParsing) GetBitbucketServerPullEventType(eventTypeHeader string) *MockEventParsing_GetBitbucketServerPullEventType_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseBitbucketCloudPullCommentEvent(body []byte) *MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseBitbucketCloudPullEvent(body []byte) *MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseBitbucketServerPullCommentEvent(body []byte) *MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseBitbucketServerPullEvent(body []byte) *MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGithubIssueCommentEvent(comment *github.IssueCommentEvent) *MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGithubPull(ghPull *github.PullRequest) *MockEventParsing_ParseGithubPull_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGithubPullEvent(pullEvent *github.PullRequestEvent) *MockEventParsing_ParseGithubPullEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGithubRepo(ghRepo *github.Repository) *MockEventParsing_ParseGithubRepo_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequest(mr *go_gitlab.MergeRequest, baseRepo models.Repo) *MockEventParsing_ParseGitlabMergeRequest_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequestCommentEvent(event go_gitlab.MergeCommentEvent) *MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification

+ func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequestEvent(event go_gitlab.MergeEvent) *MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification

+ type VerifierMockGithubPullGetter struct

+ func (verifier *VerifierMockGithubPullGetter) GetPullRequest(repo models.Repo, pullNum int) *MockGithubPullGetter_GetPullRequest_OngoingVerification

+ type VerifierMockGitlabMergeRequestGetter struct

+ func (verifier *VerifierMockGitlabMergeRequestGetter) GetMergeRequest(repoFullName string, pullNum int) *MockGitlabMergeRequestGetter_GetMergeRequest_OngoingVerification

+ type VerifierMockLockURLGenerator struct

+ func (verifier *VerifierMockLockURLGenerator) GenerateLockURL(lockID string) *MockLockURLGenerator_GenerateLockURL_OngoingVerification

+ type VerifierMockPendingPlanFinder struct

+ func (verifier *VerifierMockPendingPlanFinder) DeletePlans(pullDir string) *MockPendingPlanFinder_DeletePlans_OngoingVerification

+ func (verifier *VerifierMockPendingPlanFinder) Find(pullDir string) *MockPendingPlanFinder_Find_OngoingVerification

+ type VerifierMockProjectCommandBuilder struct

+ func (verifier *VerifierMockProjectCommandBuilder) BuildApplyCommands(ctx *events.CommandContext, comment *events.CommentCommand) *MockProjectCommandBuilder_BuildApplyCommands_OngoingVerification

+ func (verifier *VerifierMockProjectCommandBuilder) BuildAutoplanCommands(ctx *events.CommandContext) *MockProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification

+ func (verifier *VerifierMockProjectCommandBuilder) BuildPlanCommands(ctx *events.CommandContext, comment *events.CommentCommand) *MockProjectCommandBuilder_BuildPlanCommands_OngoingVerification

+ type VerifierMockProjectCommandRunner struct

+ func (verifier *VerifierMockProjectCommandRunner) Apply(ctx models.ProjectCommandContext) *MockProjectCommandRunner_Apply_OngoingVerification

+ func (verifier *VerifierMockProjectCommandRunner) Plan(ctx models.ProjectCommandContext) *MockProjectCommandRunner_Plan_OngoingVerification

+ type VerifierMockProjectLocker struct

+ func (verifier *VerifierMockProjectLocker) TryLock(log *logging.SimpleLogger, pull models.PullRequest, user models.User, ...) *MockProjectLocker_TryLock_OngoingVerification

+ type VerifierMockPullCleaner struct

+ func (verifier *VerifierMockPullCleaner) CleanUpPull(repo models.Repo, pull models.PullRequest) *MockPullCleaner_CleanUpPull_OngoingVerification

+ type VerifierMockStepRunner struct

+ func (verifier *VerifierMockStepRunner) Run(ctx models.ProjectCommandContext, extraArgs []string, path string) *MockStepRunner_Run_OngoingVerification

+ type VerifierMockWebhooksSender struct

+ func (verifier *VerifierMockWebhooksSender) Send(log *logging.SimpleLogger, res webhooks.ApplyResult) *MockWebhooksSender_Send_OngoingVerification

+ type VerifierMockWorkingDir struct

+ func (verifier *VerifierMockWorkingDir) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) *MockWorkingDir_Clone_OngoingVerification

+ func (verifier *VerifierMockWorkingDir) Delete(r models.Repo, p models.PullRequest) *MockWorkingDir_Delete_OngoingVerification

+ func (verifier *VerifierMockWorkingDir) DeleteForWorkspace(r models.Repo, p models.PullRequest, workspace string) *MockWorkingDir_DeleteForWorkspace_OngoingVerification

+ func (verifier *VerifierMockWorkingDir) GetPullDir(r models.Repo, p models.PullRequest) *MockWorkingDir_GetPullDir_OngoingVerification

+ func (verifier *VerifierMockWorkingDir) GetWorkingDir(r models.Repo, p models.PullRequest, workspace string) *MockWorkingDir_GetWorkingDir_OngoingVerification

+ type VerifierMockWorkingDirLocker struct

+ func (verifier *VerifierMockWorkingDirLocker) TryLock(repoFullName string, pullNum int, workspace string) *MockWorkingDirLocker_TryLock_OngoingVerification

+ func (verifier *VerifierMockWorkingDirLocker) TryLockPull(repoFullName string, pullNum int) *MockWorkingDirLocker_TryLockPull_OngoingVerification

Jun 12, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jun 3, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

May 23, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

May 7, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 11, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 3, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type CustomStepRunner_Run_OngoingVerification struct

+ func (c *CustomStepRunner_Run_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []string, _param2 []string)

+ func (c *CustomStepRunner_Run_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, string, string)

+ type MockCustomStepRunner struct

+ func NewMockCustomStepRunner(options ...pegomock.Option) *MockCustomStepRunner

+ func (mock *MockCustomStepRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockCustomStepRunner) Run(ctx models.ProjectCommandContext, cmd string, path string) (string, error)

+ func (mock *MockCustomStepRunner) SetFailHandler(fh pegomock.FailHandler)

+ func (mock *MockCustomStepRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierCustomStepRunner

+ func (mock *MockCustomStepRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierCustomStepRunner

+ func (mock *MockCustomStepRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierCustomStepRunner

+ func (mock *MockCustomStepRunner) VerifyWasCalledOnce() *VerifierCustomStepRunner

+ type VerifierCustomStepRunner struct

+ func (verifier *VerifierCustomStepRunner) Run(ctx models.ProjectCommandContext, cmd string, path string) *CustomStepRunner_Run_OngoingVerification

Mar 25, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 25, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

type MockCommandRunner

+ func (mock *MockCommandRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockCommandRunner) SetFailHandler(fh pegomock.FailHandler)

type MockCommentParsing

+ func (mock *MockCommentParsing) FailHandler() pegomock.FailHandler

+ func (mock *MockCommentParsing) SetFailHandler(fh pegomock.FailHandler)

type MockCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) FailHandler() pegomock.FailHandler

+ func (mock *MockCommitStatusUpdater) SetFailHandler(fh pegomock.FailHandler)

type MockEventParsing

+ func (mock *MockEventParsing) FailHandler() pegomock.FailHandler

+ func (mock *MockEventParsing) SetFailHandler(fh pegomock.FailHandler)

type MockGithubPullGetter

+ func (mock *MockGithubPullGetter) FailHandler() pegomock.FailHandler

+ func (mock *MockGithubPullGetter) SetFailHandler(fh pegomock.FailHandler)

type MockGitlabMergeRequestGetter

+ func (mock *MockGitlabMergeRequestGetter) FailHandler() pegomock.FailHandler

+ func (mock *MockGitlabMergeRequestGetter) SetFailHandler(fh pegomock.FailHandler)

type MockLockURLGenerator

+ func (mock *MockLockURLGenerator) FailHandler() pegomock.FailHandler

+ func (mock *MockLockURLGenerator) SetFailHandler(fh pegomock.FailHandler)

type MockPendingPlanFinder

+ func (mock *MockPendingPlanFinder) FailHandler() pegomock.FailHandler

+ func (mock *MockPendingPlanFinder) SetFailHandler(fh pegomock.FailHandler)

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) FailHandler() pegomock.FailHandler

+ func (mock *MockProjectCommandBuilder) SetFailHandler(fh pegomock.FailHandler)

type MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockProjectCommandRunner) SetFailHandler(fh pegomock.FailHandler)

type MockProjectLocker

+ func (mock *MockProjectLocker) FailHandler() pegomock.FailHandler

+ func (mock *MockProjectLocker) SetFailHandler(fh pegomock.FailHandler)

type MockPullCleaner

+ func (mock *MockPullCleaner) FailHandler() pegomock.FailHandler

+ func (mock *MockPullCleaner) SetFailHandler(fh pegomock.FailHandler)

type MockStepRunner

+ func (mock *MockStepRunner) FailHandler() pegomock.FailHandler

+ func (mock *MockStepRunner) SetFailHandler(fh pegomock.FailHandler)

type MockWebhooksSender

+ func (mock *MockWebhooksSender) FailHandler() pegomock.FailHandler

+ func (mock *MockWebhooksSender) SetFailHandler(fh pegomock.FailHandler)

type MockWorkingDir

+ func (mock *MockWorkingDir) FailHandler() pegomock.FailHandler

+ func (mock *MockWorkingDir) SetFailHandler(fh pegomock.FailHandler)

type MockWorkingDirLocker

+ func (mock *MockWorkingDirLocker) FailHandler() pegomock.FailHandler

+ func (mock *MockWorkingDirLocker) SetFailHandler(fh pegomock.FailHandler)

Mar 13, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 7, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type CommitStatusUpdater_UpdateCombinedCount_OngoingVerification struct

+ func (c *CommitStatusUpdater_UpdateCombinedCount_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, ...)

+ func (c *CommitStatusUpdater_UpdateCombinedCount_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, models.CommitStatus, models.CommandName, int, ...)

+ type CommitStatusUpdater_UpdateCombined_OngoingVerification struct

+ func (c *CommitStatusUpdater_UpdateCombined_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, ...)

+ func (c *CommitStatusUpdater_UpdateCombined_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, models.CommitStatus, models.CommandName)

+ type CommitStatusUpdater_UpdateProject_OngoingVerification struct

+ func (c *CommitStatusUpdater_UpdateProject_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 []models.CommandName, ...)

+ func (c *CommitStatusUpdater_UpdateProject_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, models.CommandName, models.CommitStatus, string)

type MockCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) UpdateCombined(repo models.Repo, pull models.PullRequest, status models.CommitStatus, ...) error

+ func (mock *MockCommitStatusUpdater) UpdateCombinedCount(repo models.Repo, pull models.PullRequest, status models.CommitStatus, ...) error

+ func (mock *MockCommitStatusUpdater) UpdateProject(ctx models.ProjectCommandContext, cmdName models.CommandName, ...) error

type VerifierCommitStatusUpdater

+ func (verifier *VerifierCommitStatusUpdater) UpdateCombined(repo models.Repo, pull models.PullRequest, status models.CommitStatus, ...) *CommitStatusUpdater_UpdateCombined_OngoingVerification

+ func (verifier *VerifierCommitStatusUpdater) UpdateCombinedCount(repo models.Repo, pull models.PullRequest, status models.CommitStatus, ...) *CommitStatusUpdater_UpdateCombinedCount_OngoingVerification

+ func (verifier *VerifierCommitStatusUpdater) UpdateProject(ctx models.ProjectCommandContext, cmdName models.CommandName, ...) *CommitStatusUpdater_UpdateProject_OngoingVerification

Feb 11, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Feb 7, 2019 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockPendingPlanFinder struct

+ func NewMockPendingPlanFinder() *MockPendingPlanFinder

+ func (mock *MockPendingPlanFinder) DeletePlans(pullDir string) error

+ func (mock *MockPendingPlanFinder) Find(pullDir string) ([]events.PendingPlan, error)

+ func (mock *MockPendingPlanFinder) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierPendingPlanFinder

+ func (mock *MockPendingPlanFinder) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierPendingPlanFinder

+ func (mock *MockPendingPlanFinder) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierPendingPlanFinder

+ func (mock *MockPendingPlanFinder) VerifyWasCalledOnce() *VerifierPendingPlanFinder

+ type PendingPlanFinder_DeletePlans_OngoingVerification struct

+ func (c *PendingPlanFinder_DeletePlans_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *PendingPlanFinder_DeletePlans_OngoingVerification) GetCapturedArguments() string

+ type PendingPlanFinder_Find_OngoingVerification struct

+ func (c *PendingPlanFinder_Find_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *PendingPlanFinder_Find_OngoingVerification) GetCapturedArguments() string

+ type VerifierPendingPlanFinder struct

+ func (verifier *VerifierPendingPlanFinder) DeletePlans(pullDir string) *PendingPlanFinder_DeletePlans_OngoingVerification

+ func (verifier *VerifierPendingPlanFinder) Find(pullDir string) *PendingPlanFinder_Find_OngoingVerification

Dec 20, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type EventParsing_GetBitbucketCloudPullEventType_OngoingVerification struct

+ func (c *EventParsing_GetBitbucketCloudPullEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *EventParsing_GetBitbucketCloudPullEventType_OngoingVerification) GetCapturedArguments() string

+ type EventParsing_GetBitbucketServerPullEventType_OngoingVerification struct

+ func (c *EventParsing_GetBitbucketServerPullEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *EventParsing_GetBitbucketServerPullEventType_OngoingVerification) GetCapturedArguments() string

+ type EventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *EventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification) GetCapturedArguments() []byte

+ type EventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *EventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification) GetCapturedArguments() []byte

+ type EventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeCommentEvent)

+ func (c *EventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeCommentEvent

+ type EventParsing_ParseGitlabMergeRequestEvent_OngoingVerification struct

+ func (c *EventParsing_ParseGitlabMergeRequestEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeEvent)

+ func (c *EventParsing_ParseGitlabMergeRequestEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeEvent

type MockCommandRunner

+ func (mock *MockCommandRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierCommandRunner

type MockCommentParsing

+ func (mock *MockCommentParsing) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierCommentParsing

type MockCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierCommitStatusUpdater

type MockEventParsing

+ func (mock *MockEventParsing) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierEventParsing

type MockGithubPullGetter

+ func (mock *MockGithubPullGetter) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierGithubPullGetter

type MockGitlabMergeRequestGetter

+ func (mock *MockGitlabMergeRequestGetter) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierGitlabMergeRequestGetter

type MockLockURLGenerator

+ func (mock *MockLockURLGenerator) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierLockURLGenerator

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierProjectCommandBuilder

type MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierProjectCommandRunner

type MockProjectLocker

+ func (mock *MockProjectLocker) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierProjectLocker

type MockPullCleaner

+ func (mock *MockPullCleaner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierPullCleaner

type MockStepRunner

+ func (mock *MockStepRunner) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierStepRunner

type MockWebhooksSender

+ func (mock *MockWebhooksSender) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierWebhooksSender

type MockWorkingDir

+ func (mock *MockWorkingDir) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierWorkingDir

type MockWorkingDirLocker

+ func (mock *MockWorkingDirLocker) TryLockPull(repoFullName string, pullNum int) (func(), error)

+ func (mock *MockWorkingDirLocker) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierWorkingDirLocker

type VerifierEventParsing

+ func (verifier *VerifierEventParsing) GetBitbucketCloudPullEventType(eventTypeHeader string) *EventParsing_GetBitbucketCloudPullEventType_OngoingVerification

+ func (verifier *VerifierEventParsing) GetBitbucketServerPullEventType(eventTypeHeader string) *EventParsing_GetBitbucketServerPullEventType_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGitlabMergeRequestCommentEvent(event go_gitlab.MergeCommentEvent) *EventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGitlabMergeRequestEvent(event go_gitlab.MergeEvent) *EventParsing_ParseGitlabMergeRequestEvent_OngoingVerification

type VerifierWorkingDirLocker

+ func (verifier *VerifierWorkingDirLocker) TryLockPull(repoFullName string, pullNum int) *WorkingDirLocker_TryLockPull_OngoingVerification

+ type WorkingDirLocker_TryLockPull_OngoingVerification struct

+ func (c *WorkingDirLocker_TryLockPull_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int)

+ func (c *WorkingDirLocker_TryLockPull_OngoingVerification) GetCapturedArguments() (string, int)

Nov 30, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Oct 30, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Sep 28, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Sep 27, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Sep 13, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

type MockEventParsing

+ func (mock *MockEventParsing) GetBitbucketCloudPullEventType(eventTypeHeader string) models.PullRequestEventType

+ func (mock *MockEventParsing) GetBitbucketServerPullEventType(eventTypeHeader string) models.PullRequestEventType

+ func (mock *MockEventParsing) ParseBitbucketCloudPullCommentEvent(body []byte) (models.PullRequest, models.Repo, models.Repo, models.User, string, error)

+ func (mock *MockEventParsing) ParseBitbucketServerPullCommentEvent(body []byte) (models.PullRequest, models.Repo, models.Repo, models.User, string, error)

+ func (mock *MockEventParsing) ParseGitlabMergeRequestCommentEvent(event go_gitlab.MergeCommentEvent) (models.Repo, models.Repo, models.User, error)

+ func (mock *MockEventParsing) ParseGitlabMergeRequestEvent(event go_gitlab.MergeEvent) (models.PullRequest, models.PullRequestEventType, models.Repo, models.Repo, ...)

type VerifierEventParsing

+ func (verifier *VerifierEventParsing) ParseBitbucketCloudPullCommentEvent(body []byte) *EventParsing_ParseBitbucketCloudCommentEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseBitbucketServerPullCommentEvent(body []byte) *EventParsing_ParseBitbucketServerCommentEvent_OngoingVerification

Aug 24, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Aug 18, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Aug 10, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

type MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) BuildApplyCommands(ctx *events.CommandContext, commentCommand *events.CommentCommand) ([]models.ProjectCommandContext, error)

+ func (mock *MockProjectCommandBuilder) BuildPlanCommands(ctx *events.CommandContext, commentCommand *events.CommentCommand) ([]models.ProjectCommandContext, error)

type MockWorkingDir

+ func (mock *MockWorkingDir) GetPullDir(r models.Repo, p models.PullRequest) (string, error)

+ type ProjectCommandBuilder_BuildApplyCommands_OngoingVerification struct

+ func (c *ProjectCommandBuilder_BuildApplyCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *ProjectCommandBuilder_BuildApplyCommands_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

+ type ProjectCommandBuilder_BuildPlanCommands_OngoingVerification struct

+ func (c *ProjectCommandBuilder_BuildPlanCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *ProjectCommandBuilder_BuildPlanCommands_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

type VerifierProjectCommandBuilder

+ func (verifier *VerifierProjectCommandBuilder) BuildApplyCommands(ctx *events.CommandContext, commentCommand *events.CommentCommand) *ProjectCommandBuilder_BuildApplyCommands_OngoingVerification

+ func (verifier *VerifierProjectCommandBuilder) BuildPlanCommands(ctx *events.CommandContext, commentCommand *events.CommentCommand) *ProjectCommandBuilder_BuildPlanCommands_OngoingVerification

type VerifierWorkingDir

+ func (verifier *VerifierWorkingDir) GetPullDir(r models.Repo, p models.PullRequest) *WorkingDir_GetPullDir_OngoingVerification

+ type WorkingDir_GetPullDir_OngoingVerification struct

+ func (c *WorkingDir_GetPullDir_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *WorkingDir_GetPullDir_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

Jul 25, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type EventParsing_GetBitbucketCloudEventType_OngoingVerification struct

+ func (c *EventParsing_GetBitbucketCloudEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *EventParsing_GetBitbucketCloudEventType_OngoingVerification) GetCapturedArguments() string

+ type EventParsing_GetBitbucketServerEventType_OngoingVerification struct

+ func (c *EventParsing_GetBitbucketServerEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *EventParsing_GetBitbucketServerEventType_OngoingVerification) GetCapturedArguments() string

+ type EventParsing_ParseBitbucketServerCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseBitbucketServerCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *EventParsing_ParseBitbucketServerCommentEvent_OngoingVerification) GetCapturedArguments() []byte

+ type EventParsing_ParseBitbucketServerPullEvent_OngoingVerification struct

+ func (c *EventParsing_ParseBitbucketServerPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *EventParsing_ParseBitbucketServerPullEvent_OngoingVerification) GetCapturedArguments() []byte

type MockEventParsing

+ func (mock *MockEventParsing) GetBitbucketCloudEventType(eventTypeHeader string) models.PullRequestEventType

+ func (mock *MockEventParsing) GetBitbucketServerEventType(eventTypeHeader string) models.PullRequestEventType

+ func (mock *MockEventParsing) ParseBitbucketServerCommentEvent(body []byte) (models.PullRequest, models.Repo, models.Repo, models.User, string, error)

+ func (mock *MockEventParsing) ParseBitbucketServerPullEvent(body []byte) (models.PullRequest, models.Repo, models.Repo, models.User, error)

type VerifierEventParsing

+ func (verifier *VerifierEventParsing) GetBitbucketCloudEventType(eventTypeHeader string) *EventParsing_GetBitbucketCloudEventType_OngoingVerification

+ func (verifier *VerifierEventParsing) GetBitbucketServerEventType(eventTypeHeader string) *EventParsing_GetBitbucketServerEventType_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseBitbucketServerCommentEvent(body []byte) *EventParsing_ParseBitbucketServerCommentEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseBitbucketServerPullEvent(body []byte) *EventParsing_ParseBitbucketServerPullEvent_OngoingVerification

Jul 23, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type EventParsing_GetBitbucketEventType_OngoingVerification struct

+ func (c *EventParsing_GetBitbucketEventType_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *EventParsing_GetBitbucketEventType_OngoingVerification) GetCapturedArguments() string

+ type EventParsing_ParseBitbucketCloudCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseBitbucketCloudCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *EventParsing_ParseBitbucketCloudCommentEvent_OngoingVerification) GetCapturedArguments() []byte

+ type EventParsing_ParseBitbucketCloudPullEvent_OngoingVerification struct

+ func (c *EventParsing_ParseBitbucketCloudPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 [][]byte)

+ func (c *EventParsing_ParseBitbucketCloudPullEvent_OngoingVerification) GetCapturedArguments() []byte

type MockEventParsing

+ func (mock *MockEventParsing) GetBitbucketEventType(eventTypeHeader string) models.PullRequestEventType

+ func (mock *MockEventParsing) ParseBitbucketCloudCommentEvent(body []byte) (models.PullRequest, models.Repo, models.Repo, models.User, string, error)

+ func (mock *MockEventParsing) ParseBitbucketCloudPullEvent(body []byte) (models.PullRequest, models.Repo, models.Repo, models.User, error)

type VerifierEventParsing

+ func (verifier *VerifierEventParsing) GetBitbucketEventType(eventTypeHeader string) *EventParsing_GetBitbucketEventType_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseBitbucketCloudCommentEvent(body []byte) *EventParsing_ParseBitbucketCloudCommentEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseBitbucketCloudPullEvent(body []byte) *EventParsing_ParseBitbucketCloudPullEvent_OngoingVerification

Jul 16, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jul 10, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Jul 4, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type CommandRunner_RunAutoplanCommand_OngoingVerification struct

+ func (c *CommandRunner_RunAutoplanCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.Repo, _param2 []models.PullRequest, ...)

+ func (c *CommandRunner_RunAutoplanCommand_OngoingVerification) GetCapturedArguments() (models.Repo, models.Repo, models.PullRequest, models.User)

+ type CommandRunner_RunCommentCommand_OngoingVerification struct

+ func (c *CommandRunner_RunCommentCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []*models.Repo, _param2 []models.User, ...)

+ func (c *CommandRunner_RunCommentCommand_OngoingVerification) GetCapturedArguments() (models.Repo, *models.Repo, models.User, int, *events.CommentCommand)

+ type EventParsing_ParseGithubPullEvent_OngoingVerification struct

+ func (c *EventParsing_ParseGithubPullEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.PullRequestEvent)

+ func (c *EventParsing_ParseGithubPullEvent_OngoingVerification) GetCapturedArguments() *github.PullRequestEvent

+ type LockURLGenerator_GenerateLockURL_OngoingVerification struct

+ func (c *LockURLGenerator_GenerateLockURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *LockURLGenerator_GenerateLockURL_OngoingVerification) GetCapturedArguments() string

type MockCommandRunner

+ func (mock *MockCommandRunner) RunAutoplanCommand(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, ...)

+ func (mock *MockCommandRunner) RunCommentCommand(baseRepo models.Repo, maybeHeadRepo *models.Repo, user models.User, ...)

type MockEventParsing

+ func (mock *MockEventParsing) ParseGithubPullEvent(pullEvent *github.PullRequestEvent) (models.PullRequest, models.Repo, models.Repo, models.User, error)

type MockLockURLGenerator

+ func (mock *MockLockURLGenerator) GenerateLockURL(lockID string) string

+ type MockProjectCommandBuilder struct

+ func NewMockProjectCommandBuilder() *MockProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) BuildApplyCommand(ctx *events.CommandContext, commentCommand *events.CommentCommand) (models.ProjectCommandContext, error)

+ func (mock *MockProjectCommandBuilder) BuildAutoplanCommands(ctx *events.CommandContext) ([]models.ProjectCommandContext, error)

+ func (mock *MockProjectCommandBuilder) BuildPlanCommand(ctx *events.CommandContext, commentCommand *events.CommentCommand) (models.ProjectCommandContext, error)

+ func (mock *MockProjectCommandBuilder) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierProjectCommandBuilder

+ func (mock *MockProjectCommandBuilder) VerifyWasCalledOnce() *VerifierProjectCommandBuilder

+ type MockProjectCommandRunner struct

+ func NewMockProjectCommandRunner() *MockProjectCommandRunner

+ func (mock *MockProjectCommandRunner) Apply(ctx models.ProjectCommandContext) events.ProjectCommandResult

+ func (mock *MockProjectCommandRunner) Plan(ctx models.ProjectCommandContext) events.ProjectCommandResult

+ func (mock *MockProjectCommandRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectCommandRunner

+ func (mock *MockProjectCommandRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierProjectCommandRunner

+ func (mock *MockProjectCommandRunner) VerifyWasCalledOnce() *VerifierProjectCommandRunner

+ type MockProjectLocker struct

+ func NewMockProjectLocker() *MockProjectLocker

+ func (mock *MockProjectLocker) TryLock(log *logging.SimpleLogger, pull models.PullRequest, user models.User, ...) (*events.TryLockResponse, error)

+ func (mock *MockProjectLocker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectLocker

+ func (mock *MockProjectLocker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierProjectLocker

+ func (mock *MockProjectLocker) VerifyWasCalledOnce() *VerifierProjectLocker

+ type MockStepRunner struct

+ func NewMockStepRunner() *MockStepRunner

+ func (mock *MockStepRunner) Run(ctx models.ProjectCommandContext, extraArgs []string, path string) (string, error)

+ func (mock *MockStepRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierStepRunner

+ func (mock *MockStepRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierStepRunner

+ func (mock *MockStepRunner) VerifyWasCalledOnce() *VerifierStepRunner

+ type MockWebhooksSender struct

+ func NewMockWebhooksSender() *MockWebhooksSender

+ func (mock *MockWebhooksSender) Send(log *logging.SimpleLogger, res webhooks.ApplyResult) error

+ func (mock *MockWebhooksSender) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierWebhooksSender

+ func (mock *MockWebhooksSender) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierWebhooksSender

+ func (mock *MockWebhooksSender) VerifyWasCalledOnce() *VerifierWebhooksSender

+ type MockWorkingDir struct

+ func NewMockWorkingDir() *MockWorkingDir

+ func (mock *MockWorkingDir) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) (string, error)

+ func (mock *MockWorkingDir) Delete(r models.Repo, p models.PullRequest) error

+ func (mock *MockWorkingDir) DeleteForWorkspace(r models.Repo, p models.PullRequest, workspace string) error

+ func (mock *MockWorkingDir) GetWorkingDir(r models.Repo, p models.PullRequest, workspace string) (string, error)

+ func (mock *MockWorkingDir) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierWorkingDir

+ func (mock *MockWorkingDir) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierWorkingDir

+ func (mock *MockWorkingDir) VerifyWasCalledOnce() *VerifierWorkingDir

+ type MockWorkingDirLocker struct

+ func NewMockWorkingDirLocker() *MockWorkingDirLocker

+ func (mock *MockWorkingDirLocker) TryLock(repoFullName string, workspace string, pullNum int) (func(), error)

+ func (mock *MockWorkingDirLocker) Unlock(repoFullName string, workspace string, pullNum int)

+ func (mock *MockWorkingDirLocker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierWorkingDirLocker

+ func (mock *MockWorkingDirLocker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierWorkingDirLocker

+ func (mock *MockWorkingDirLocker) VerifyWasCalledOnce() *VerifierWorkingDirLocker

+ type ProjectCommandBuilder_BuildApplyCommand_OngoingVerification struct

+ func (c *ProjectCommandBuilder_BuildApplyCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *ProjectCommandBuilder_BuildApplyCommand_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

+ type ProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification struct

+ func (c *ProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *ProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type ProjectCommandBuilder_BuildPlanCommand_OngoingVerification struct

+ func (c *ProjectCommandBuilder_BuildPlanCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []*events.CommentCommand)

+ func (c *ProjectCommandBuilder_BuildPlanCommand_OngoingVerification) GetCapturedArguments() (*events.CommandContext, *events.CommentCommand)

+ type ProjectCommandRunner_Apply_OngoingVerification struct

+ func (c *ProjectCommandRunner_Apply_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *ProjectCommandRunner_Apply_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

+ type ProjectCommandRunner_Plan_OngoingVerification struct

+ func (c *ProjectCommandRunner_Plan_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext)

+ func (c *ProjectCommandRunner_Plan_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext

+ type ProjectLocker_TryLock_OngoingVerification struct

+ func (c *ProjectLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []models.PullRequest, ...)

+ func (c *ProjectLocker_TryLock_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, models.PullRequest, models.User, string, models.Project)

+ type StepRunner_Run_OngoingVerification struct

+ func (c *StepRunner_Run_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext, _param1 [][]string, _param2 []string)

+ func (c *StepRunner_Run_OngoingVerification) GetCapturedArguments() (models.ProjectCommandContext, []string, string)

type VerifierCommandRunner

+ func (verifier *VerifierCommandRunner) RunAutoplanCommand(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, ...) *CommandRunner_RunAutoplanCommand_OngoingVerification

+ func (verifier *VerifierCommandRunner) RunCommentCommand(baseRepo models.Repo, maybeHeadRepo *models.Repo, user models.User, ...) *CommandRunner_RunCommentCommand_OngoingVerification

type VerifierEventParsing

+ func (verifier *VerifierEventParsing) ParseGithubPullEvent(pullEvent *github.PullRequestEvent) *EventParsing_ParseGithubPullEvent_OngoingVerification

type VerifierLockURLGenerator

+ func (verifier *VerifierLockURLGenerator) GenerateLockURL(lockID string) *LockURLGenerator_GenerateLockURL_OngoingVerification

+ type VerifierProjectCommandBuilder struct

+ func (verifier *VerifierProjectCommandBuilder) BuildApplyCommand(ctx *events.CommandContext, commentCommand *events.CommentCommand) *ProjectCommandBuilder_BuildApplyCommand_OngoingVerification

+ func (verifier *VerifierProjectCommandBuilder) BuildAutoplanCommands(ctx *events.CommandContext) *ProjectCommandBuilder_BuildAutoplanCommands_OngoingVerification

+ func (verifier *VerifierProjectCommandBuilder) BuildPlanCommand(ctx *events.CommandContext, commentCommand *events.CommentCommand) *ProjectCommandBuilder_BuildPlanCommand_OngoingVerification

+ type VerifierProjectCommandRunner struct

+ func (verifier *VerifierProjectCommandRunner) Apply(ctx models.ProjectCommandContext) *ProjectCommandRunner_Apply_OngoingVerification

+ func (verifier *VerifierProjectCommandRunner) Plan(ctx models.ProjectCommandContext) *ProjectCommandRunner_Plan_OngoingVerification

+ type VerifierProjectLocker struct

+ func (verifier *VerifierProjectLocker) TryLock(log *logging.SimpleLogger, pull models.PullRequest, user models.User, ...) *ProjectLocker_TryLock_OngoingVerification

+ type VerifierStepRunner struct

+ func (verifier *VerifierStepRunner) Run(ctx models.ProjectCommandContext, extraArgs []string, path string) *StepRunner_Run_OngoingVerification

+ type VerifierWebhooksSender struct

+ func (verifier *VerifierWebhooksSender) Send(log *logging.SimpleLogger, res webhooks.ApplyResult) *WebhooksSender_Send_OngoingVerification

+ type VerifierWorkingDir struct

+ func (verifier *VerifierWorkingDir) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) *WorkingDir_Clone_OngoingVerification

+ func (verifier *VerifierWorkingDir) Delete(r models.Repo, p models.PullRequest) *WorkingDir_Delete_OngoingVerification

+ func (verifier *VerifierWorkingDir) DeleteForWorkspace(r models.Repo, p models.PullRequest, workspace string) *WorkingDir_DeleteForWorkspace_OngoingVerification

+ func (verifier *VerifierWorkingDir) GetWorkingDir(r models.Repo, p models.PullRequest, workspace string) *WorkingDir_GetWorkingDir_OngoingVerification

+ type VerifierWorkingDirLocker struct

+ func (verifier *VerifierWorkingDirLocker) TryLock(repoFullName string, workspace string, pullNum int) *WorkingDirLocker_TryLock_OngoingVerification

+ func (verifier *VerifierWorkingDirLocker) Unlock(repoFullName string, workspace string, pullNum int) *WorkingDirLocker_Unlock_OngoingVerification

+ type WebhooksSender_Send_OngoingVerification struct

+ func (c *WebhooksSender_Send_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []webhooks.ApplyResult)

+ func (c *WebhooksSender_Send_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, webhooks.ApplyResult)

+ type WorkingDirLocker_TryLock_OngoingVerification struct

+ func (c *WorkingDirLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *WorkingDirLocker_TryLock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type WorkingDirLocker_Unlock_OngoingVerification struct

+ func (c *WorkingDirLocker_Unlock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *WorkingDirLocker_Unlock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type WorkingDir_Clone_OngoingVerification struct

+ func (c *WorkingDir_Clone_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []models.Repo, _param2 []models.Repo, ...)

+ func (c *WorkingDir_Clone_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, models.Repo, models.Repo, models.PullRequest, string)

+ type WorkingDir_DeleteForWorkspace_OngoingVerification struct

+ func (c *WorkingDir_DeleteForWorkspace_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *WorkingDir_DeleteForWorkspace_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)

+ type WorkingDir_Delete_OngoingVerification struct

+ func (c *WorkingDir_Delete_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *WorkingDir_Delete_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type WorkingDir_GetWorkingDir_OngoingVerification struct

+ func (c *WorkingDir_GetWorkingDir_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *WorkingDir_GetWorkingDir_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)

Aug 21, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

May 30, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 26, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 16, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Apr 9, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 29, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 23, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 20, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 14, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 11, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Mar 6, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Feb 28, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type CommentParsing_Parse_OngoingVerification struct

+ func (c *CommentParsing_Parse_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []vcs.Host)

+ func (c *CommentParsing_Parse_OngoingVerification) GetCapturedArguments() (string, vcs.Host)

+ type MockCommentParsing struct

+ func NewMockCommentParsing() *MockCommentParsing

+ func (mock *MockCommentParsing) Parse(comment string, vcsHost vcs.Host) events.CommentParseResult

+ func (mock *MockCommentParsing) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierCommentParsing

+ func (mock *MockCommentParsing) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierCommentParsing

+ func (mock *MockCommentParsing) VerifyWasCalledOnce() *VerifierCommentParsing

type MockProjectFinder

+ func (mock *MockProjectFinder) DetermineProjects(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string, ...) []models.Project

+ type ProjectFinder_DetermineProjects_OngoingVerification struct

+ func (c *ProjectFinder_DetermineProjects_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 [][]string, _param2 []string, ...)

+ func (c *ProjectFinder_DetermineProjects_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, []string, string, string)

+ type VerifierCommentParsing struct

+ func (verifier *VerifierCommentParsing) Parse(comment string, vcsHost vcs.Host) *CommentParsing_Parse_OngoingVerification

type VerifierProjectFinder

+ func (verifier *VerifierProjectFinder) DetermineProjects(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string, ...) *ProjectFinder_DetermineProjects_OngoingVerification

Jan 23, 2018 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Dec 22, 2017 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Dec 18, 2017 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type AtlantisWorkspaceLocker_TryLock_OngoingVerification struct

+ func (c *AtlantisWorkspaceLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *AtlantisWorkspaceLocker_TryLock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type AtlantisWorkspaceLocker_Unlock_OngoingVerification struct

+ func (c *AtlantisWorkspaceLocker_Unlock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *AtlantisWorkspaceLocker_Unlock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type AtlantisWorkspace_Clone_OngoingVerification struct

+ func (c *AtlantisWorkspace_Clone_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []models.Repo, _param2 []models.Repo, ...)

+ func (c *AtlantisWorkspace_Clone_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, models.Repo, models.Repo, models.PullRequest, string)

+ type AtlantisWorkspace_Delete_OngoingVerification struct

+ func (c *AtlantisWorkspace_Delete_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *AtlantisWorkspace_Delete_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type AtlantisWorkspace_GetWorkspace_OngoingVerification struct

+ func (c *AtlantisWorkspace_GetWorkspace_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *AtlantisWorkspace_GetWorkspace_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)

+ type MockAtlantisWorkspace struct

+ func NewMockAtlantisWorkspace() *MockAtlantisWorkspace

+ func (mock *MockAtlantisWorkspace) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) (string, error)

+ func (mock *MockAtlantisWorkspace) Delete(r models.Repo, p models.PullRequest) error

+ func (mock *MockAtlantisWorkspace) GetWorkspace(r models.Repo, p models.PullRequest, workspace string) (string, error)

+ func (mock *MockAtlantisWorkspace) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierAtlantisWorkspace

+ func (mock *MockAtlantisWorkspace) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierAtlantisWorkspace

+ func (mock *MockAtlantisWorkspace) VerifyWasCalledOnce() *VerifierAtlantisWorkspace

+ type MockAtlantisWorkspaceLocker struct

+ func NewMockAtlantisWorkspaceLocker() *MockAtlantisWorkspaceLocker

+ func (mock *MockAtlantisWorkspaceLocker) TryLock(repoFullName string, workspace string, pullNum int) bool

+ func (mock *MockAtlantisWorkspaceLocker) Unlock(repoFullName string, workspace string, pullNum int)

+ func (mock *MockAtlantisWorkspaceLocker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierAtlantisWorkspaceLocker

+ func (mock *MockAtlantisWorkspaceLocker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierAtlantisWorkspaceLocker

+ func (mock *MockAtlantisWorkspaceLocker) VerifyWasCalledOnce() *VerifierAtlantisWorkspaceLocker

+ type VerifierAtlantisWorkspace struct

+ func (verifier *VerifierAtlantisWorkspace) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) *AtlantisWorkspace_Clone_OngoingVerification

+ func (verifier *VerifierAtlantisWorkspace) Delete(r models.Repo, p models.PullRequest) *AtlantisWorkspace_Delete_OngoingVerification

+ func (verifier *VerifierAtlantisWorkspace) GetWorkspace(r models.Repo, p models.PullRequest, workspace string) *AtlantisWorkspace_GetWorkspace_OngoingVerification

+ type VerifierAtlantisWorkspaceLocker struct

+ func (verifier *VerifierAtlantisWorkspaceLocker) TryLock(repoFullName string, workspace string, pullNum int) *AtlantisWorkspaceLocker_TryLock_OngoingVerification

+ func (verifier *VerifierAtlantisWorkspaceLocker) Unlock(repoFullName string, workspace string, pullNum int) *AtlantisWorkspaceLocker_Unlock_OngoingVerification

Dec 4, 2017 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type MockProjectFinder struct

+ func NewMockProjectFinder() *MockProjectFinder

+ func (mock *MockProjectFinder) FindModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) []models.Project

+ func (mock *MockProjectFinder) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectFinder

+ func (mock *MockProjectFinder) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierProjectFinder

+ func (mock *MockProjectFinder) VerifyWasCalledOnce() *VerifierProjectFinder

+ type MockWorkspaceLocker struct

+ func NewMockWorkspaceLocker() *MockWorkspaceLocker

+ func (mock *MockWorkspaceLocker) TryLock(repoFullName string, env string, pullNum int) bool

+ func (mock *MockWorkspaceLocker) Unlock(repoFullName string, env string, pullNum int)

+ func (mock *MockWorkspaceLocker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierWorkspaceLocker

+ func (mock *MockWorkspaceLocker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierWorkspaceLocker

+ func (mock *MockWorkspaceLocker) VerifyWasCalledOnce() *VerifierWorkspaceLocker

+ type ProjectFinder_FindModified_OngoingVerification struct

+ func (c *ProjectFinder_FindModified_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 [][]string, _param2 []string)

+ func (c *ProjectFinder_FindModified_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, []string, string)

+ type VerifierProjectFinder struct

+ func (verifier *VerifierProjectFinder) FindModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) *ProjectFinder_FindModified_OngoingVerification

+ type VerifierWorkspaceLocker struct

+ func (verifier *VerifierWorkspaceLocker) TryLock(repoFullName string, env string, pullNum int) *WorkspaceLocker_TryLock_OngoingVerification

+ func (verifier *VerifierWorkspaceLocker) Unlock(repoFullName string, env string, pullNum int) *WorkspaceLocker_Unlock_OngoingVerification

+ type WorkspaceLocker_TryLock_OngoingVerification struct

+ func (c *WorkspaceLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *WorkspaceLocker_TryLock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type WorkspaceLocker_Unlock_OngoingVerification struct

+ func (c *WorkspaceLocker_Unlock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *WorkspaceLocker_Unlock_OngoingVerification) GetCapturedArguments() (string, string, int)

Nov 17, 2017 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type CommitStatusUpdater_UpdateProjectResult_OngoingVerification struct

+ func (c *CommitStatusUpdater_UpdateProjectResult_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []events.CommandResponse)

+ func (c *CommitStatusUpdater_UpdateProjectResult_OngoingVerification) GetCapturedArguments() (*events.CommandContext, events.CommandResponse)

+ type CommitStatusUpdater_Update_OngoingVerification struct

+ func (c *CommitStatusUpdater_Update_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, ...)

+ func (c *CommitStatusUpdater_Update_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, vcs.CommitStatus, *events.Command, vcs.Host)

+ type EventParsing_ParseGithubIssueCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseGithubIssueCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.IssueCommentEvent)

+ func (c *EventParsing_ParseGithubIssueCommentEvent_OngoingVerification) GetCapturedArguments() *github.IssueCommentEvent

+ type EventParsing_ParseGithubPull_OngoingVerification struct

+ func (c *EventParsing_ParseGithubPull_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.PullRequest)

+ func (c *EventParsing_ParseGithubPull_OngoingVerification) GetCapturedArguments() *github.PullRequest

+ type EventParsing_ParseGithubRepo_OngoingVerification struct

+ func (c *EventParsing_ParseGithubRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.Repository)

+ func (c *EventParsing_ParseGithubRepo_OngoingVerification) GetCapturedArguments() *github.Repository

+ type EventParsing_ParseGitlabMergeCommentEvent_OngoingVerification struct

+ func (c *EventParsing_ParseGitlabMergeCommentEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeCommentEvent)

+ func (c *EventParsing_ParseGitlabMergeCommentEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeCommentEvent

+ type EventParsing_ParseGitlabMergeEvent_OngoingVerification struct

+ func (c *EventParsing_ParseGitlabMergeEvent_OngoingVerification) GetAllCapturedArguments() (_param0 []go_gitlab.MergeEvent)

+ func (c *EventParsing_ParseGitlabMergeEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeEvent

+ type EventParsing_ParseGitlabMergeRequest_OngoingVerification struct

+ func (c *EventParsing_ParseGitlabMergeRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []*go_gitlab.MergeRequest)

+ func (c *EventParsing_ParseGitlabMergeRequest_OngoingVerification) GetCapturedArguments() *go_gitlab.MergeRequest

+ type GithubPullGetter_GetPullRequest_OngoingVerification struct

+ func (c *GithubPullGetter_GetPullRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []int)

+ func (c *GithubPullGetter_GetPullRequest_OngoingVerification) GetCapturedArguments() (models.Repo, int)

+ type GitlabMergeRequestGetter_GetMergeRequest_OngoingVerification struct

+ func (c *GitlabMergeRequestGetter_GetMergeRequest_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int)

+ func (c *GitlabMergeRequestGetter_GetMergeRequest_OngoingVerification) GetCapturedArguments() (string, int)

+ type MockCommitStatusUpdater struct

+ func NewMockCommitStatusUpdater() *MockCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, ...) error

+ func (mock *MockCommitStatusUpdater) UpdateProjectResult(ctx *events.CommandContext, res events.CommandResponse) error

+ func (mock *MockCommitStatusUpdater) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierCommitStatusUpdater

+ func (mock *MockCommitStatusUpdater) VerifyWasCalledOnce() *VerifierCommitStatusUpdater

type MockEventParsing

+ func (mock *MockEventParsing) ParseGithubIssueCommentEvent(comment *github.IssueCommentEvent) (models.Repo, models.User, int, error)

+ func (mock *MockEventParsing) ParseGithubPull(pull *github.PullRequest) (models.PullRequest, models.Repo, error)

+ func (mock *MockEventParsing) ParseGithubRepo(ghRepo *github.Repository) (models.Repo, error)

+ func (mock *MockEventParsing) ParseGitlabMergeCommentEvent(event go_gitlab.MergeCommentEvent) (models.Repo, models.Repo, models.User)

+ func (mock *MockEventParsing) ParseGitlabMergeEvent(event go_gitlab.MergeEvent) (models.PullRequest, models.Repo)

+ func (mock *MockEventParsing) ParseGitlabMergeRequest(mr *go_gitlab.MergeRequest) models.PullRequest

+ type MockGithubPullGetter struct

+ func NewMockGithubPullGetter() *MockGithubPullGetter

+ func (mock *MockGithubPullGetter) GetPullRequest(repo models.Repo, pullNum int) (*github.PullRequest, error)

+ func (mock *MockGithubPullGetter) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierGithubPullGetter

+ func (mock *MockGithubPullGetter) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierGithubPullGetter

+ func (mock *MockGithubPullGetter) VerifyWasCalledOnce() *VerifierGithubPullGetter

+ type MockGitlabMergeRequestGetter struct

+ func NewMockGitlabMergeRequestGetter() *MockGitlabMergeRequestGetter

+ func (mock *MockGitlabMergeRequestGetter) GetMergeRequest(repoFullName string, pullNum int) (*go_gitlab.MergeRequest, error)

+ func (mock *MockGitlabMergeRequestGetter) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierGitlabMergeRequestGetter

+ func (mock *MockGitlabMergeRequestGetter) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierGitlabMergeRequestGetter

+ func (mock *MockGitlabMergeRequestGetter) VerifyWasCalledOnce() *VerifierGitlabMergeRequestGetter

type MockModifiedProjectFinder

+ func (mock *MockModifiedProjectFinder) FindModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) []models.Project

+ type ModifiedProjectFinder_FindModified_OngoingVerification struct

+ func (c *ModifiedProjectFinder_FindModified_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 [][]string, _param2 []string)

+ func (c *ModifiedProjectFinder_FindModified_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, []string, string)

+ type VerifierCommitStatusUpdater struct

+ func (verifier *VerifierCommitStatusUpdater) Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, ...) *CommitStatusUpdater_Update_OngoingVerification

+ func (verifier *VerifierCommitStatusUpdater) UpdateProjectResult(ctx *events.CommandContext, res events.CommandResponse) *CommitStatusUpdater_UpdateProjectResult_OngoingVerification

type VerifierEventParsing

+ func (verifier *VerifierEventParsing) ParseGithubIssueCommentEvent(comment *github.IssueCommentEvent) *EventParsing_ParseGithubIssueCommentEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGithubPull(pull *github.PullRequest) *EventParsing_ParseGithubPull_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGithubRepo(ghRepo *github.Repository) *EventParsing_ParseGithubRepo_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGitlabMergeCommentEvent(event go_gitlab.MergeCommentEvent) *EventParsing_ParseGitlabMergeCommentEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGitlabMergeEvent(event go_gitlab.MergeEvent) *EventParsing_ParseGitlabMergeEvent_OngoingVerification

+ func (verifier *VerifierEventParsing) ParseGitlabMergeRequest(mr *go_gitlab.MergeRequest) *EventParsing_ParseGitlabMergeRequest_OngoingVerification

+ type VerifierGithubPullGetter struct

+ func (verifier *VerifierGithubPullGetter) GetPullRequest(repo models.Repo, pullNum int) *GithubPullGetter_GetPullRequest_OngoingVerification

+ type VerifierGitlabMergeRequestGetter struct

+ func (verifier *VerifierGitlabMergeRequestGetter) GetMergeRequest(repoFullName string, pullNum int) *GitlabMergeRequestGetter_GetMergeRequest_OngoingVerification

type VerifierModifiedProjectFinder

+ func (verifier *VerifierModifiedProjectFinder) FindModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) *ModifiedProjectFinder_FindModified_OngoingVerification

Nov 16, 2017 GO-2022-0534

  GO-2022-0534: Timing attack in github.com/runatlantis/atlantis

Changes in this version

+ type CommandRunner_ExecuteCommand_OngoingVerification struct

+ func (c *CommandRunner_ExecuteCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *CommandRunner_ExecuteCommand_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type EnvLocker_TryLock_OngoingVerification struct

+ func (c *EnvLocker_TryLock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *EnvLocker_TryLock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type EnvLocker_Unlock_OngoingVerification struct

+ func (c *EnvLocker_Unlock_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int)

+ func (c *EnvLocker_Unlock_OngoingVerification) GetCapturedArguments() (string, string, int)

+ type EventParsing_DetermineCommand_OngoingVerification struct

+ func (c *EventParsing_DetermineCommand_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.IssueCommentEvent)

+ func (c *EventParsing_DetermineCommand_OngoingVerification) GetCapturedArguments() *github.IssueCommentEvent

+ type EventParsing_ExtractCommentData_OngoingVerification struct

+ func (c *EventParsing_ExtractCommentData_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.IssueCommentEvent)

+ func (c *EventParsing_ExtractCommentData_OngoingVerification) GetCapturedArguments() *github.IssueCommentEvent

+ type EventParsing_ExtractPullData_OngoingVerification struct

+ func (c *EventParsing_ExtractPullData_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.PullRequest)

+ func (c *EventParsing_ExtractPullData_OngoingVerification) GetCapturedArguments() *github.PullRequest

+ type EventParsing_ExtractRepoData_OngoingVerification struct

+ func (c *EventParsing_ExtractRepoData_OngoingVerification) GetAllCapturedArguments() (_param0 []*github.Repository)

+ func (c *EventParsing_ExtractRepoData_OngoingVerification) GetCapturedArguments() *github.Repository

+ type Executor_Execute_OngoingVerification struct

+ func (c *Executor_Execute_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *Executor_Execute_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type GHStatusUpdater_UpdateProjectResult_OngoingVerification struct

+ func (c *GHStatusUpdater_UpdateProjectResult_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []events.CommandResponse)

+ func (c *GHStatusUpdater_UpdateProjectResult_OngoingVerification) GetCapturedArguments() (*events.CommandContext, events.CommandResponse)

+ type GHStatusUpdater_Update_OngoingVerification struct

+ func (c *GHStatusUpdater_Update_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []events.Status, ...)

+ func (c *GHStatusUpdater_Update_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, events.Status, *events.Command)

+ type LockURLGenerator_SetLockURL_OngoingVerification struct

+ func (c *LockURLGenerator_SetLockURL_OngoingVerification) GetAllCapturedArguments() (_param0 []func(string) string)

+ func (c *LockURLGenerator_SetLockURL_OngoingVerification) GetCapturedArguments() func(string) string

+ type MockCommandRunner struct

+ func NewMockCommandRunner() *MockCommandRunner

+ func (mock *MockCommandRunner) ExecuteCommand(ctx *events.CommandContext)

+ func (mock *MockCommandRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierCommandRunner

+ func (mock *MockCommandRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierCommandRunner

+ func (mock *MockCommandRunner) VerifyWasCalledOnce() *VerifierCommandRunner

+ type MockEnvLocker struct

+ func NewMockEnvLocker() *MockEnvLocker

+ func (mock *MockEnvLocker) TryLock(repoFullName string, env string, pullNum int) bool

+ func (mock *MockEnvLocker) Unlock(repoFullName string, env string, pullNum int)

+ func (mock *MockEnvLocker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierEnvLocker

+ func (mock *MockEnvLocker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierEnvLocker

+ func (mock *MockEnvLocker) VerifyWasCalledOnce() *VerifierEnvLocker

+ type MockEventParsing struct

+ func NewMockEventParsing() *MockEventParsing

+ func (mock *MockEventParsing) DetermineCommand(comment *github.IssueCommentEvent) (*events.Command, error)

+ func (mock *MockEventParsing) ExtractCommentData(comment *github.IssueCommentEvent) (models.Repo, models.User, models.PullRequest, error)

+ func (mock *MockEventParsing) ExtractPullData(pull *github.PullRequest) (models.PullRequest, models.Repo, error)

+ func (mock *MockEventParsing) ExtractRepoData(ghRepo *github.Repository) (models.Repo, error)

+ func (mock *MockEventParsing) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierEventParsing

+ func (mock *MockEventParsing) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierEventParsing

+ func (mock *MockEventParsing) VerifyWasCalledOnce() *VerifierEventParsing

+ type MockExecutor struct

+ func NewMockExecutor() *MockExecutor

+ func (mock *MockExecutor) Execute(ctx *events.CommandContext) events.CommandResponse

+ func (mock *MockExecutor) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierExecutor

+ func (mock *MockExecutor) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierExecutor

+ func (mock *MockExecutor) VerifyWasCalledOnce() *VerifierExecutor

+ type MockGHStatusUpdater struct

+ func NewMockGHStatusUpdater() *MockGHStatusUpdater

+ func (mock *MockGHStatusUpdater) Update(repo models.Repo, pull models.PullRequest, status events.Status, ...) error

+ func (mock *MockGHStatusUpdater) UpdateProjectResult(ctx *events.CommandContext, res events.CommandResponse) error

+ func (mock *MockGHStatusUpdater) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierGHStatusUpdater

+ func (mock *MockGHStatusUpdater) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierGHStatusUpdater

+ func (mock *MockGHStatusUpdater) VerifyWasCalledOnce() *VerifierGHStatusUpdater

+ type MockLockURLGenerator struct

+ func NewMockLockURLGenerator() *MockLockURLGenerator

+ func (mock *MockLockURLGenerator) SetLockURL(_param0 func(string) string)

+ func (mock *MockLockURLGenerator) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierLockURLGenerator

+ func (mock *MockLockURLGenerator) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierLockURLGenerator

+ func (mock *MockLockURLGenerator) VerifyWasCalledOnce() *VerifierLockURLGenerator

+ type MockModifiedProjectFinder struct

+ func NewMockModifiedProjectFinder() *MockModifiedProjectFinder

+ func (mock *MockModifiedProjectFinder) GetModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) []models.Project

+ func (mock *MockModifiedProjectFinder) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierModifiedProjectFinder

+ func (mock *MockModifiedProjectFinder) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierModifiedProjectFinder

+ func (mock *MockModifiedProjectFinder) VerifyWasCalledOnce() *VerifierModifiedProjectFinder

+ type MockPlanner struct

+ func NewMockPlanner() *MockPlanner

+ func (mock *MockPlanner) Execute(ctx *events.CommandContext) events.CommandResponse

+ func (mock *MockPlanner) SetLockURL(_param0 func(string) string)

+ func (mock *MockPlanner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierPlanner

+ func (mock *MockPlanner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierPlanner

+ func (mock *MockPlanner) VerifyWasCalledOnce() *VerifierPlanner

+ type MockProjectConfigReader struct

+ func NewMockProjectConfigReader() *MockProjectConfigReader

+ func (mock *MockProjectConfigReader) Exists(projectPath string) bool

+ func (mock *MockProjectConfigReader) Read(projectPath string) (events.ProjectConfig, error)

+ func (mock *MockProjectConfigReader) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectConfigReader

+ func (mock *MockProjectConfigReader) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierProjectConfigReader

+ func (mock *MockProjectConfigReader) VerifyWasCalledOnce() *VerifierProjectConfigReader

+ type MockProjectPreExecutor struct

+ func NewMockProjectPreExecutor() *MockProjectPreExecutor

+ func (mock *MockProjectPreExecutor) Execute(ctx *events.CommandContext, repoDir string, project models.Project) events.PreExecuteResult

+ func (mock *MockProjectPreExecutor) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectPreExecutor

+ func (mock *MockProjectPreExecutor) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierProjectPreExecutor

+ func (mock *MockProjectPreExecutor) VerifyWasCalledOnce() *VerifierProjectPreExecutor

+ type MockPullCleaner struct

+ func NewMockPullCleaner() *MockPullCleaner

+ func (mock *MockPullCleaner) CleanUpPull(repo models.Repo, pull models.PullRequest) error

+ func (mock *MockPullCleaner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierPullCleaner

+ func (mock *MockPullCleaner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierPullCleaner

+ func (mock *MockPullCleaner) VerifyWasCalledOnce() *VerifierPullCleaner

+ type MockWorkspace struct

+ func NewMockWorkspace() *MockWorkspace

+ func (mock *MockWorkspace) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) (string, error)

+ func (mock *MockWorkspace) Delete(r models.Repo, p models.PullRequest) error

+ func (mock *MockWorkspace) GetWorkspace(r models.Repo, p models.PullRequest, env string) (string, error)

+ func (mock *MockWorkspace) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierWorkspace

+ func (mock *MockWorkspace) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, ...) *VerifierWorkspace

+ func (mock *MockWorkspace) VerifyWasCalledOnce() *VerifierWorkspace

+ type ModifiedProjectFinder_GetModified_OngoingVerification struct

+ func (c *ModifiedProjectFinder_GetModified_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 [][]string, _param2 []string)

+ func (c *ModifiedProjectFinder_GetModified_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, []string, string)

+ type Planner_Execute_OngoingVerification struct

+ func (c *Planner_Execute_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext)

+ func (c *Planner_Execute_OngoingVerification) GetCapturedArguments() *events.CommandContext

+ type Planner_SetLockURL_OngoingVerification struct

+ func (c *Planner_SetLockURL_OngoingVerification) GetAllCapturedArguments() (_param0 []func(string) string)

+ func (c *Planner_SetLockURL_OngoingVerification) GetCapturedArguments() func(string) string

+ type ProjectConfigReader_Exists_OngoingVerification struct

+ func (c *ProjectConfigReader_Exists_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *ProjectConfigReader_Exists_OngoingVerification) GetCapturedArguments() string

+ type ProjectConfigReader_Read_OngoingVerification struct

+ func (c *ProjectConfigReader_Read_OngoingVerification) GetAllCapturedArguments() (_param0 []string)

+ func (c *ProjectConfigReader_Read_OngoingVerification) GetCapturedArguments() string

+ type ProjectPreExecutor_Execute_OngoingVerification struct

+ func (c *ProjectPreExecutor_Execute_OngoingVerification) GetAllCapturedArguments() (_param0 []*events.CommandContext, _param1 []string, _param2 []models.Project)

+ func (c *ProjectPreExecutor_Execute_OngoingVerification) GetCapturedArguments() (*events.CommandContext, string, models.Project)

+ type PullCleaner_CleanUpPull_OngoingVerification struct

+ func (c *PullCleaner_CleanUpPull_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *PullCleaner_CleanUpPull_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type VerifierCommandRunner struct

+ func (verifier *VerifierCommandRunner) ExecuteCommand(ctx *events.CommandContext) *CommandRunner_ExecuteCommand_OngoingVerification

+ type VerifierEnvLocker struct

+ func (verifier *VerifierEnvLocker) TryLock(repoFullName string, env string, pullNum int) *EnvLocker_TryLock_OngoingVerification

+ func (verifier *VerifierEnvLocker) Unlock(repoFullName string, env string, pullNum int) *EnvLocker_Unlock_OngoingVerification

+ type VerifierEventParsing struct

+ func (verifier *VerifierEventParsing) DetermineCommand(comment *github.IssueCommentEvent) *EventParsing_DetermineCommand_OngoingVerification

+ func (verifier *VerifierEventParsing) ExtractCommentData(comment *github.IssueCommentEvent) *EventParsing_ExtractCommentData_OngoingVerification

+ func (verifier *VerifierEventParsing) ExtractPullData(pull *github.PullRequest) *EventParsing_ExtractPullData_OngoingVerification

+ func (verifier *VerifierEventParsing) ExtractRepoData(ghRepo *github.Repository) *EventParsing_ExtractRepoData_OngoingVerification

+ type VerifierExecutor struct

+ func (verifier *VerifierExecutor) Execute(ctx *events.CommandContext) *Executor_Execute_OngoingVerification

+ type VerifierGHStatusUpdater struct

+ func (verifier *VerifierGHStatusUpdater) Update(repo models.Repo, pull models.PullRequest, status events.Status, ...) *GHStatusUpdater_Update_OngoingVerification

+ func (verifier *VerifierGHStatusUpdater) UpdateProjectResult(ctx *events.CommandContext, res events.CommandResponse) *GHStatusUpdater_UpdateProjectResult_OngoingVerification

+ type VerifierLockURLGenerator struct

+ func (verifier *VerifierLockURLGenerator) SetLockURL(_param0 func(string) string) *LockURLGenerator_SetLockURL_OngoingVerification

+ type VerifierModifiedProjectFinder struct

+ func (verifier *VerifierModifiedProjectFinder) GetModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) *ModifiedProjectFinder_GetModified_OngoingVerification

+ type VerifierPlanner struct

+ func (verifier *VerifierPlanner) Execute(ctx *events.CommandContext) *Planner_Execute_OngoingVerification

+ func (verifier *VerifierPlanner) SetLockURL(_param0 func(string) string) *Planner_SetLockURL_OngoingVerification

+ type VerifierProjectConfigReader struct

+ func (verifier *VerifierProjectConfigReader) Exists(projectPath string) *ProjectConfigReader_Exists_OngoingVerification

+ func (verifier *VerifierProjectConfigReader) Read(projectPath string) *ProjectConfigReader_Read_OngoingVerification

+ type VerifierProjectPreExecutor struct

+ func (verifier *VerifierProjectPreExecutor) Execute(ctx *events.CommandContext, repoDir string, project models.Project) *ProjectPreExecutor_Execute_OngoingVerification

+ type VerifierPullCleaner struct

+ func (verifier *VerifierPullCleaner) CleanUpPull(repo models.Repo, pull models.PullRequest) *PullCleaner_CleanUpPull_OngoingVerification

+ type VerifierWorkspace struct

+ func (verifier *VerifierWorkspace) Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, ...) *Workspace_Clone_OngoingVerification

+ func (verifier *VerifierWorkspace) Delete(r models.Repo, p models.PullRequest) *Workspace_Delete_OngoingVerification

+ func (verifier *VerifierWorkspace) GetWorkspace(r models.Repo, p models.PullRequest, env string) *Workspace_GetWorkspace_OngoingVerification

+ type Workspace_Clone_OngoingVerification struct

+ func (c *Workspace_Clone_OngoingVerification) GetAllCapturedArguments() (_param0 []*logging.SimpleLogger, _param1 []models.Repo, _param2 []models.Repo, ...)

+ func (c *Workspace_Clone_OngoingVerification) GetCapturedArguments() (*logging.SimpleLogger, models.Repo, models.Repo, models.PullRequest, string)

+ type Workspace_Delete_OngoingVerification struct

+ func (c *Workspace_Delete_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest)

+ func (c *Workspace_Delete_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest)

+ type Workspace_GetWorkspace_OngoingVerification struct

+ func (c *Workspace_GetWorkspace_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest, _param2 []string)

+ func (c *Workspace_GetWorkspace_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest, string)