From b9069351103b5fbfdfad07c9b471ce7264ad92c0 Mon Sep 17 00:00:00 2001 From: "Chang, Hui-Tang" Date: Mon, 20 Jan 2025 11:38:35 +0800 Subject: [PATCH] feat(pipeline): implement template --- config/config.yaml | 2 +- .../app_public_service_server_mock.gen.go | 11207 ++++++++++---- pkg/datamodel/datamodel.go | 5 + pkg/db/migration/000040_template.down.sql | 8 + pkg/db/migration/000040_template.up.sql | 15 + pkg/errors/errors.go | 3 + pkg/handler/pipeline.go | 6 + pkg/middleware/interceptor.go | 3 +- pkg/mock/repository_mock.gen.go | 12348 ++++++++-------- pkg/repository/repository.go | 25 +- pkg/service/main.go | 4 +- pkg/service/pipeline.go | 216 +- pkg/worker/workflow.go | 2 +- 13 files changed, 14877 insertions(+), 8967 deletions(-) create mode 100644 pkg/db/migration/000040_template.down.sql create mode 100644 pkg/db/migration/000040_template.up.sql diff --git a/config/config.yaml b/config/config.yaml index d98987169..6a5fe7ced 100644 --- a/config/config.yaml +++ b/config/config.yaml @@ -26,7 +26,7 @@ database: host: pg-sql port: 5432 name: pipeline - version: 39 + version: 40 timezone: Etc/UTC pool: idleconnections: 5 diff --git a/pkg/component/internal/mock/app_public_service_server_mock.gen.go b/pkg/component/internal/mock/app_public_service_server_mock.gen.go index ce6526bfc..0fe75bf6e 100644 --- a/pkg/component/internal/mock/app_public_service_server_mock.gen.go +++ b/pkg/component/internal/mock/app_public_service_server_mock.gen.go @@ -59,6 +59,13 @@ type AppPublicServiceServerMock struct { beforeCreateMessageCounter uint64 CreateMessageMock mAppPublicServiceServerMockCreateMessage + funcCreateTable func(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest) (cp2 *mm_appv1alpha.CreateTableResponse, err error) + funcCreateTableOrigin string + inspectFuncCreateTable func(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest) + afterCreateTableCounter uint64 + beforeCreateTableCounter uint64 + CreateTableMock mAppPublicServiceServerMockCreateTable + funcDeleteAgent func(ctx context.Context, dp1 *mm_appv1alpha.DeleteAgentRequest) (dp2 *mm_appv1alpha.DeleteAgentResponse, err error) funcDeleteAgentOrigin string inspectFuncDeleteAgent func(ctx context.Context, dp1 *mm_appv1alpha.DeleteAgentRequest) @@ -94,6 +101,41 @@ type AppPublicServiceServerMock struct { beforeDeleteMessageCounter uint64 DeleteMessageMock mAppPublicServiceServerMockDeleteMessage + funcDeleteRow func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest) (dp2 *mm_appv1alpha.DeleteRowResponse, err error) + funcDeleteRowOrigin string + inspectFuncDeleteRow func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest) + afterDeleteRowCounter uint64 + beforeDeleteRowCounter uint64 + DeleteRowMock mAppPublicServiceServerMockDeleteRow + + funcDeleteRows func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest) (dp2 *mm_appv1alpha.DeleteRowsResponse, err error) + funcDeleteRowsOrigin string + inspectFuncDeleteRows func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest) + afterDeleteRowsCounter uint64 + beforeDeleteRowsCounter uint64 + DeleteRowsMock mAppPublicServiceServerMockDeleteRows + + funcDeleteTable func(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest) (dp2 *mm_appv1alpha.DeleteTableResponse, err error) + funcDeleteTableOrigin string + inspectFuncDeleteTable func(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest) + afterDeleteTableCounter uint64 + beforeDeleteTableCounter uint64 + DeleteTableMock mAppPublicServiceServerMockDeleteTable + + funcExport func(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest) (ep2 *mm_appv1alpha.ExportResponse, err error) + funcExportOrigin string + inspectFuncExport func(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest) + afterExportCounter uint64 + beforeExportCounter uint64 + ExportMock mAppPublicServiceServerMockExport + + funcGetColumnDefinitions func(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) (gp2 *mm_appv1alpha.GetColumnDefinitionsResponse, err error) + funcGetColumnDefinitionsOrigin string + inspectFuncGetColumnDefinitions func(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) + afterGetColumnDefinitionsCounter uint64 + beforeGetColumnDefinitionsCounter uint64 + GetColumnDefinitionsMock mAppPublicServiceServerMockGetColumnDefinitions + funcGetPlaygroundConversation func(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) (gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) funcGetPlaygroundConversationOrigin string inspectFuncGetPlaygroundConversation func(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) @@ -101,6 +143,27 @@ type AppPublicServiceServerMock struct { beforeGetPlaygroundConversationCounter uint64 GetPlaygroundConversationMock mAppPublicServiceServerMockGetPlaygroundConversation + funcGetTable func(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest) (gp2 *mm_appv1alpha.GetTableResponse, err error) + funcGetTableOrigin string + inspectFuncGetTable func(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest) + afterGetTableCounter uint64 + beforeGetTableCounter uint64 + GetTableMock mAppPublicServiceServerMockGetTable + + funcGetTableEvents func(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) (err error) + funcGetTableEventsOrigin string + inspectFuncGetTableEvents func(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) + afterGetTableEventsCounter uint64 + beforeGetTableEventsCounter uint64 + GetTableEventsMock mAppPublicServiceServerMockGetTableEvents + + funcInsertRow func(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest) (ip2 *mm_appv1alpha.InsertRowResponse, err error) + funcInsertRowOrigin string + inspectFuncInsertRow func(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest) + afterInsertRowCounter uint64 + beforeInsertRowCounter uint64 + InsertRowMock mAppPublicServiceServerMockInsertRow + funcListAgents func(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) (lp2 *mm_appv1alpha.ListAgentsResponse, err error) funcListAgentsOrigin string inspectFuncListAgents func(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) @@ -143,6 +206,20 @@ type AppPublicServiceServerMock struct { beforeListMessagesCounter uint64 ListMessagesMock mAppPublicServiceServerMockListMessages + funcListRows func(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest) (lp2 *mm_appv1alpha.ListRowsResponse, err error) + funcListRowsOrigin string + inspectFuncListRows func(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest) + afterListRowsCounter uint64 + beforeListRowsCounter uint64 + ListRowsMock mAppPublicServiceServerMockListRows + + funcListTables func(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest) (lp2 *mm_appv1alpha.ListTablesResponse, err error) + funcListTablesOrigin string + inspectFuncListTables func(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest) + afterListTablesCounter uint64 + beforeListTablesCounter uint64 + ListTablesMock mAppPublicServiceServerMockListTables + funcListTools func(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) (lp2 *mm_appv1alpha.ListToolsResponse, err error) funcListToolsOrigin string inspectFuncListTools func(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) @@ -157,6 +234,13 @@ type AppPublicServiceServerMock struct { beforeLivenessCounter uint64 LivenessMock mAppPublicServiceServerMockLiveness + funcMoveRows func(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest) (mp2 *mm_appv1alpha.MoveRowsResponse, err error) + funcMoveRowsOrigin string + inspectFuncMoveRows func(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest) + afterMoveRowsCounter uint64 + beforeMoveRowsCounter uint64 + MoveRowsMock mAppPublicServiceServerMockMoveRows + funcReadiness func(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) (rp2 *mm_appv1alpha.ReadinessResponse, err error) funcReadinessOrigin string inspectFuncReadiness func(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) @@ -192,6 +276,13 @@ type AppPublicServiceServerMock struct { beforeUpdateChatCounter uint64 UpdateChatMock mAppPublicServiceServerMockUpdateChat + funcUpdateColumnDefinitions func(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) (up2 *mm_appv1alpha.UpdateColumnDefinitionsResponse, err error) + funcUpdateColumnDefinitionsOrigin string + inspectFuncUpdateColumnDefinitions func(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) + afterUpdateColumnDefinitionsCounter uint64 + beforeUpdateColumnDefinitionsCounter uint64 + UpdateColumnDefinitionsMock mAppPublicServiceServerMockUpdateColumnDefinitions + funcUpdateConversation func(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) (up2 *mm_appv1alpha.UpdateConversationResponse, err error) funcUpdateConversationOrigin string inspectFuncUpdateConversation func(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) @@ -205,6 +296,27 @@ type AppPublicServiceServerMock struct { afterUpdateMessageCounter uint64 beforeUpdateMessageCounter uint64 UpdateMessageMock mAppPublicServiceServerMockUpdateMessage + + funcUpdateRow func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest) (up2 *mm_appv1alpha.UpdateRowResponse, err error) + funcUpdateRowOrigin string + inspectFuncUpdateRow func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest) + afterUpdateRowCounter uint64 + beforeUpdateRowCounter uint64 + UpdateRowMock mAppPublicServiceServerMockUpdateRow + + funcUpdateRows func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest) (up2 *mm_appv1alpha.UpdateRowsResponse, err error) + funcUpdateRowsOrigin string + inspectFuncUpdateRows func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest) + afterUpdateRowsCounter uint64 + beforeUpdateRowsCounter uint64 + UpdateRowsMock mAppPublicServiceServerMockUpdateRows + + funcUpdateTable func(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest) (up2 *mm_appv1alpha.UpdateTableResponse, err error) + funcUpdateTableOrigin string + inspectFuncUpdateTable func(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest) + afterUpdateTableCounter uint64 + beforeUpdateTableCounter uint64 + UpdateTableMock mAppPublicServiceServerMockUpdateTable } // NewAppPublicServiceServerMock returns a mock for mm_appv1alpha.AppPublicServiceServer @@ -233,6 +345,9 @@ func NewAppPublicServiceServerMock(t minimock.Tester) *AppPublicServiceServerMoc m.CreateMessageMock = mAppPublicServiceServerMockCreateMessage{mock: m} m.CreateMessageMock.callArgs = []*AppPublicServiceServerMockCreateMessageParams{} + m.CreateTableMock = mAppPublicServiceServerMockCreateTable{mock: m} + m.CreateTableMock.callArgs = []*AppPublicServiceServerMockCreateTableParams{} + m.DeleteAgentMock = mAppPublicServiceServerMockDeleteAgent{mock: m} m.DeleteAgentMock.callArgs = []*AppPublicServiceServerMockDeleteAgentParams{} @@ -248,9 +363,33 @@ func NewAppPublicServiceServerMock(t minimock.Tester) *AppPublicServiceServerMoc m.DeleteMessageMock = mAppPublicServiceServerMockDeleteMessage{mock: m} m.DeleteMessageMock.callArgs = []*AppPublicServiceServerMockDeleteMessageParams{} + m.DeleteRowMock = mAppPublicServiceServerMockDeleteRow{mock: m} + m.DeleteRowMock.callArgs = []*AppPublicServiceServerMockDeleteRowParams{} + + m.DeleteRowsMock = mAppPublicServiceServerMockDeleteRows{mock: m} + m.DeleteRowsMock.callArgs = []*AppPublicServiceServerMockDeleteRowsParams{} + + m.DeleteTableMock = mAppPublicServiceServerMockDeleteTable{mock: m} + m.DeleteTableMock.callArgs = []*AppPublicServiceServerMockDeleteTableParams{} + + m.ExportMock = mAppPublicServiceServerMockExport{mock: m} + m.ExportMock.callArgs = []*AppPublicServiceServerMockExportParams{} + + m.GetColumnDefinitionsMock = mAppPublicServiceServerMockGetColumnDefinitions{mock: m} + m.GetColumnDefinitionsMock.callArgs = []*AppPublicServiceServerMockGetColumnDefinitionsParams{} + m.GetPlaygroundConversationMock = mAppPublicServiceServerMockGetPlaygroundConversation{mock: m} m.GetPlaygroundConversationMock.callArgs = []*AppPublicServiceServerMockGetPlaygroundConversationParams{} + m.GetTableMock = mAppPublicServiceServerMockGetTable{mock: m} + m.GetTableMock.callArgs = []*AppPublicServiceServerMockGetTableParams{} + + m.GetTableEventsMock = mAppPublicServiceServerMockGetTableEvents{mock: m} + m.GetTableEventsMock.callArgs = []*AppPublicServiceServerMockGetTableEventsParams{} + + m.InsertRowMock = mAppPublicServiceServerMockInsertRow{mock: m} + m.InsertRowMock.callArgs = []*AppPublicServiceServerMockInsertRowParams{} + m.ListAgentsMock = mAppPublicServiceServerMockListAgents{mock: m} m.ListAgentsMock.callArgs = []*AppPublicServiceServerMockListAgentsParams{} @@ -269,12 +408,21 @@ func NewAppPublicServiceServerMock(t minimock.Tester) *AppPublicServiceServerMoc m.ListMessagesMock = mAppPublicServiceServerMockListMessages{mock: m} m.ListMessagesMock.callArgs = []*AppPublicServiceServerMockListMessagesParams{} + m.ListRowsMock = mAppPublicServiceServerMockListRows{mock: m} + m.ListRowsMock.callArgs = []*AppPublicServiceServerMockListRowsParams{} + + m.ListTablesMock = mAppPublicServiceServerMockListTables{mock: m} + m.ListTablesMock.callArgs = []*AppPublicServiceServerMockListTablesParams{} + m.ListToolsMock = mAppPublicServiceServerMockListTools{mock: m} m.ListToolsMock.callArgs = []*AppPublicServiceServerMockListToolsParams{} m.LivenessMock = mAppPublicServiceServerMockLiveness{mock: m} m.LivenessMock.callArgs = []*AppPublicServiceServerMockLivenessParams{} + m.MoveRowsMock = mAppPublicServiceServerMockMoveRows{mock: m} + m.MoveRowsMock.callArgs = []*AppPublicServiceServerMockMoveRowsParams{} + m.ReadinessMock = mAppPublicServiceServerMockReadiness{mock: m} m.ReadinessMock.callArgs = []*AppPublicServiceServerMockReadinessParams{} @@ -290,12 +438,24 @@ func NewAppPublicServiceServerMock(t minimock.Tester) *AppPublicServiceServerMoc m.UpdateChatMock = mAppPublicServiceServerMockUpdateChat{mock: m} m.UpdateChatMock.callArgs = []*AppPublicServiceServerMockUpdateChatParams{} + m.UpdateColumnDefinitionsMock = mAppPublicServiceServerMockUpdateColumnDefinitions{mock: m} + m.UpdateColumnDefinitionsMock.callArgs = []*AppPublicServiceServerMockUpdateColumnDefinitionsParams{} + m.UpdateConversationMock = mAppPublicServiceServerMockUpdateConversation{mock: m} m.UpdateConversationMock.callArgs = []*AppPublicServiceServerMockUpdateConversationParams{} m.UpdateMessageMock = mAppPublicServiceServerMockUpdateMessage{mock: m} m.UpdateMessageMock.callArgs = []*AppPublicServiceServerMockUpdateMessageParams{} + m.UpdateRowMock = mAppPublicServiceServerMockUpdateRow{mock: m} + m.UpdateRowMock.callArgs = []*AppPublicServiceServerMockUpdateRowParams{} + + m.UpdateRowsMock = mAppPublicServiceServerMockUpdateRows{mock: m} + m.UpdateRowsMock.callArgs = []*AppPublicServiceServerMockUpdateRowsParams{} + + m.UpdateTableMock = mAppPublicServiceServerMockUpdateTable{mock: m} + m.UpdateTableMock.callArgs = []*AppPublicServiceServerMockUpdateTableParams{} + t.Cleanup(m.MinimockFinish) return m @@ -2359,6 +2519,349 @@ func (m *AppPublicServiceServerMock) MinimockCreateMessageInspect() { } } +type mAppPublicServiceServerMockCreateTable struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockCreateTableExpectation + expectations []*AppPublicServiceServerMockCreateTableExpectation + + callArgs []*AppPublicServiceServerMockCreateTableParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockCreateTableExpectation specifies expectation struct of the AppPublicServiceServer.CreateTable +type AppPublicServiceServerMockCreateTableExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockCreateTableParams + paramPtrs *AppPublicServiceServerMockCreateTableParamPtrs + expectationOrigins AppPublicServiceServerMockCreateTableExpectationOrigins + results *AppPublicServiceServerMockCreateTableResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockCreateTableParams contains parameters of the AppPublicServiceServer.CreateTable +type AppPublicServiceServerMockCreateTableParams struct { + ctx context.Context + cp1 *mm_appv1alpha.CreateTableRequest +} + +// AppPublicServiceServerMockCreateTableParamPtrs contains pointers to parameters of the AppPublicServiceServer.CreateTable +type AppPublicServiceServerMockCreateTableParamPtrs struct { + ctx *context.Context + cp1 **mm_appv1alpha.CreateTableRequest +} + +// AppPublicServiceServerMockCreateTableResults contains results of the AppPublicServiceServer.CreateTable +type AppPublicServiceServerMockCreateTableResults struct { + cp2 *mm_appv1alpha.CreateTableResponse + err error +} + +// AppPublicServiceServerMockCreateTableOrigins contains origins of expectations of the AppPublicServiceServer.CreateTable +type AppPublicServiceServerMockCreateTableExpectationOrigins struct { + origin string + originCtx string + originCp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Optional() *mAppPublicServiceServerMockCreateTable { + mmCreateTable.optional = true + return mmCreateTable +} + +// Expect sets up expected params for AppPublicServiceServer.CreateTable +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Expect(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest) *mAppPublicServiceServerMockCreateTable { + if mmCreateTable.mock.funcCreateTable != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Set") + } + + if mmCreateTable.defaultExpectation == nil { + mmCreateTable.defaultExpectation = &AppPublicServiceServerMockCreateTableExpectation{} + } + + if mmCreateTable.defaultExpectation.paramPtrs != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by ExpectParams functions") + } + + mmCreateTable.defaultExpectation.params = &AppPublicServiceServerMockCreateTableParams{ctx, cp1} + mmCreateTable.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreateTable.expectations { + if minimock.Equal(e.params, mmCreateTable.defaultExpectation.params) { + mmCreateTable.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateTable.defaultExpectation.params) + } + } + + return mmCreateTable +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.CreateTable +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockCreateTable { + if mmCreateTable.mock.funcCreateTable != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Set") + } + + if mmCreateTable.defaultExpectation == nil { + mmCreateTable.defaultExpectation = &AppPublicServiceServerMockCreateTableExpectation{} + } + + if mmCreateTable.defaultExpectation.params != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Expect") + } + + if mmCreateTable.defaultExpectation.paramPtrs == nil { + mmCreateTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockCreateTableParamPtrs{} + } + mmCreateTable.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateTable.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmCreateTable +} + +// ExpectCp1Param2 sets up expected param cp1 for AppPublicServiceServer.CreateTable +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) ExpectCp1Param2(cp1 *mm_appv1alpha.CreateTableRequest) *mAppPublicServiceServerMockCreateTable { + if mmCreateTable.mock.funcCreateTable != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Set") + } + + if mmCreateTable.defaultExpectation == nil { + mmCreateTable.defaultExpectation = &AppPublicServiceServerMockCreateTableExpectation{} + } + + if mmCreateTable.defaultExpectation.params != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Expect") + } + + if mmCreateTable.defaultExpectation.paramPtrs == nil { + mmCreateTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockCreateTableParamPtrs{} + } + mmCreateTable.defaultExpectation.paramPtrs.cp1 = &cp1 + mmCreateTable.defaultExpectation.expectationOrigins.originCp1 = minimock.CallerInfo(1) + + return mmCreateTable +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.CreateTable +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Inspect(f func(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest)) *mAppPublicServiceServerMockCreateTable { + if mmCreateTable.mock.inspectFuncCreateTable != nil { + mmCreateTable.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.CreateTable") + } + + mmCreateTable.mock.inspectFuncCreateTable = f + + return mmCreateTable +} + +// Return sets up results that will be returned by AppPublicServiceServer.CreateTable +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Return(cp2 *mm_appv1alpha.CreateTableResponse, err error) *AppPublicServiceServerMock { + if mmCreateTable.mock.funcCreateTable != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Set") + } + + if mmCreateTable.defaultExpectation == nil { + mmCreateTable.defaultExpectation = &AppPublicServiceServerMockCreateTableExpectation{mock: mmCreateTable.mock} + } + mmCreateTable.defaultExpectation.results = &AppPublicServiceServerMockCreateTableResults{cp2, err} + mmCreateTable.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreateTable.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.CreateTable method +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Set(f func(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest) (cp2 *mm_appv1alpha.CreateTableResponse, err error)) *AppPublicServiceServerMock { + if mmCreateTable.defaultExpectation != nil { + mmCreateTable.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.CreateTable method") + } + + if len(mmCreateTable.expectations) > 0 { + mmCreateTable.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.CreateTable method") + } + + mmCreateTable.mock.funcCreateTable = f + mmCreateTable.mock.funcCreateTableOrigin = minimock.CallerInfo(1) + return mmCreateTable.mock +} + +// When sets expectation for the AppPublicServiceServer.CreateTable which will trigger the result defined by the following +// Then helper +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) When(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest) *AppPublicServiceServerMockCreateTableExpectation { + if mmCreateTable.mock.funcCreateTable != nil { + mmCreateTable.mock.t.Fatalf("AppPublicServiceServerMock.CreateTable mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockCreateTableExpectation{ + mock: mmCreateTable.mock, + params: &AppPublicServiceServerMockCreateTableParams{ctx, cp1}, + expectationOrigins: AppPublicServiceServerMockCreateTableExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmCreateTable.expectations = append(mmCreateTable.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.CreateTable return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockCreateTableExpectation) Then(cp2 *mm_appv1alpha.CreateTableResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockCreateTableResults{cp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.CreateTable should be invoked +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Times(n uint64) *mAppPublicServiceServerMockCreateTable { + if n == 0 { + mmCreateTable.mock.t.Fatalf("Times of AppPublicServiceServerMock.CreateTable mock can not be zero") + } + mm_atomic.StoreUint64(&mmCreateTable.expectedInvocations, n) + mmCreateTable.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreateTable +} + +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) invocationsDone() bool { + if len(mmCreateTable.expectations) == 0 && mmCreateTable.defaultExpectation == nil && mmCreateTable.mock.funcCreateTable == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmCreateTable.mock.afterCreateTableCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreateTable.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// CreateTable implements mm_appv1alpha.AppPublicServiceServer +func (mmCreateTable *AppPublicServiceServerMock) CreateTable(ctx context.Context, cp1 *mm_appv1alpha.CreateTableRequest) (cp2 *mm_appv1alpha.CreateTableResponse, err error) { + mm_atomic.AddUint64(&mmCreateTable.beforeCreateTableCounter, 1) + defer mm_atomic.AddUint64(&mmCreateTable.afterCreateTableCounter, 1) + + mmCreateTable.t.Helper() + + if mmCreateTable.inspectFuncCreateTable != nil { + mmCreateTable.inspectFuncCreateTable(ctx, cp1) + } + + mm_params := AppPublicServiceServerMockCreateTableParams{ctx, cp1} + + // Record call args + mmCreateTable.CreateTableMock.mutex.Lock() + mmCreateTable.CreateTableMock.callArgs = append(mmCreateTable.CreateTableMock.callArgs, &mm_params) + mmCreateTable.CreateTableMock.mutex.Unlock() + + for _, e := range mmCreateTable.CreateTableMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.cp2, e.results.err + } + } + + if mmCreateTable.CreateTableMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreateTable.CreateTableMock.defaultExpectation.Counter, 1) + mm_want := mmCreateTable.CreateTableMock.defaultExpectation.params + mm_want_ptrs := mmCreateTable.CreateTableMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockCreateTableParams{ctx, cp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmCreateTable.t.Errorf("AppPublicServiceServerMock.CreateTable got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateTable.CreateTableMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.cp1 != nil && !minimock.Equal(*mm_want_ptrs.cp1, mm_got.cp1) { + mmCreateTable.t.Errorf("AppPublicServiceServerMock.CreateTable got unexpected parameter cp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateTable.CreateTableMock.defaultExpectation.expectationOrigins.originCp1, *mm_want_ptrs.cp1, mm_got.cp1, minimock.Diff(*mm_want_ptrs.cp1, mm_got.cp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmCreateTable.t.Errorf("AppPublicServiceServerMock.CreateTable got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateTable.CreateTableMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmCreateTable.CreateTableMock.defaultExpectation.results + if mm_results == nil { + mmCreateTable.t.Fatal("No results are set for the AppPublicServiceServerMock.CreateTable") + } + return (*mm_results).cp2, (*mm_results).err + } + if mmCreateTable.funcCreateTable != nil { + return mmCreateTable.funcCreateTable(ctx, cp1) + } + mmCreateTable.t.Fatalf("Unexpected call to AppPublicServiceServerMock.CreateTable. %v %v", ctx, cp1) + return +} + +// CreateTableAfterCounter returns a count of finished AppPublicServiceServerMock.CreateTable invocations +func (mmCreateTable *AppPublicServiceServerMock) CreateTableAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateTable.afterCreateTableCounter) +} + +// CreateTableBeforeCounter returns a count of AppPublicServiceServerMock.CreateTable invocations +func (mmCreateTable *AppPublicServiceServerMock) CreateTableBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateTable.beforeCreateTableCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.CreateTable. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmCreateTable *mAppPublicServiceServerMockCreateTable) Calls() []*AppPublicServiceServerMockCreateTableParams { + mmCreateTable.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockCreateTableParams, len(mmCreateTable.callArgs)) + copy(argCopy, mmCreateTable.callArgs) + + mmCreateTable.mutex.RUnlock() + + return argCopy +} + +// MinimockCreateTableDone returns true if the count of the CreateTable invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockCreateTableDone() bool { + if m.CreateTableMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.CreateTableMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.CreateTableMock.invocationsDone() +} + +// MinimockCreateTableInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockCreateTableInspect() { + for _, e := range m.CreateTableMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.CreateTable at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterCreateTableCounter := mm_atomic.LoadUint64(&m.afterCreateTableCounter) + // if default expectation was set then invocations count should be greater than zero + if m.CreateTableMock.defaultExpectation != nil && afterCreateTableCounter < 1 { + if m.CreateTableMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.CreateTable at\n%s", m.CreateTableMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.CreateTable at\n%s with params: %#v", m.CreateTableMock.defaultExpectation.expectationOrigins.origin, *m.CreateTableMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcCreateTable != nil && afterCreateTableCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.CreateTable at\n%s", m.funcCreateTableOrigin) + } + + if !m.CreateTableMock.invocationsDone() && afterCreateTableCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.CreateTable at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateTableMock.expectedInvocations), m.CreateTableMock.expectedInvocationsOrigin, afterCreateTableCounter) + } +} + type mAppPublicServiceServerMockDeleteAgent struct { optional bool mock *AppPublicServiceServerMock @@ -4074,53 +4577,53 @@ func (m *AppPublicServiceServerMock) MinimockDeleteMessageInspect() { } } -type mAppPublicServiceServerMockGetPlaygroundConversation struct { +type mAppPublicServiceServerMockDeleteRow struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockGetPlaygroundConversationExpectation - expectations []*AppPublicServiceServerMockGetPlaygroundConversationExpectation + defaultExpectation *AppPublicServiceServerMockDeleteRowExpectation + expectations []*AppPublicServiceServerMockDeleteRowExpectation - callArgs []*AppPublicServiceServerMockGetPlaygroundConversationParams + callArgs []*AppPublicServiceServerMockDeleteRowParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockGetPlaygroundConversationExpectation specifies expectation struct of the AppPublicServiceServer.GetPlaygroundConversation -type AppPublicServiceServerMockGetPlaygroundConversationExpectation struct { +// AppPublicServiceServerMockDeleteRowExpectation specifies expectation struct of the AppPublicServiceServer.DeleteRow +type AppPublicServiceServerMockDeleteRowExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockGetPlaygroundConversationParams - paramPtrs *AppPublicServiceServerMockGetPlaygroundConversationParamPtrs - expectationOrigins AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins - results *AppPublicServiceServerMockGetPlaygroundConversationResults + params *AppPublicServiceServerMockDeleteRowParams + paramPtrs *AppPublicServiceServerMockDeleteRowParamPtrs + expectationOrigins AppPublicServiceServerMockDeleteRowExpectationOrigins + results *AppPublicServiceServerMockDeleteRowResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockGetPlaygroundConversationParams contains parameters of the AppPublicServiceServer.GetPlaygroundConversation -type AppPublicServiceServerMockGetPlaygroundConversationParams struct { +// AppPublicServiceServerMockDeleteRowParams contains parameters of the AppPublicServiceServer.DeleteRow +type AppPublicServiceServerMockDeleteRowParams struct { ctx context.Context - gp1 *mm_appv1alpha.GetPlaygroundConversationRequest + dp1 *mm_appv1alpha.DeleteRowRequest } -// AppPublicServiceServerMockGetPlaygroundConversationParamPtrs contains pointers to parameters of the AppPublicServiceServer.GetPlaygroundConversation -type AppPublicServiceServerMockGetPlaygroundConversationParamPtrs struct { +// AppPublicServiceServerMockDeleteRowParamPtrs contains pointers to parameters of the AppPublicServiceServer.DeleteRow +type AppPublicServiceServerMockDeleteRowParamPtrs struct { ctx *context.Context - gp1 **mm_appv1alpha.GetPlaygroundConversationRequest + dp1 **mm_appv1alpha.DeleteRowRequest } -// AppPublicServiceServerMockGetPlaygroundConversationResults contains results of the AppPublicServiceServer.GetPlaygroundConversation -type AppPublicServiceServerMockGetPlaygroundConversationResults struct { - gp2 *mm_appv1alpha.GetPlaygroundConversationResponse +// AppPublicServiceServerMockDeleteRowResults contains results of the AppPublicServiceServer.DeleteRow +type AppPublicServiceServerMockDeleteRowResults struct { + dp2 *mm_appv1alpha.DeleteRowResponse err error } -// AppPublicServiceServerMockGetPlaygroundConversationOrigins contains origins of expectations of the AppPublicServiceServer.GetPlaygroundConversation -type AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins struct { +// AppPublicServiceServerMockDeleteRowOrigins contains origins of expectations of the AppPublicServiceServer.DeleteRow +type AppPublicServiceServerMockDeleteRowExpectationOrigins struct { origin string originCtx string - originGp1 string + originDp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -4128,342 +4631,342 @@ type AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins struc // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Optional() *mAppPublicServiceServerMockGetPlaygroundConversation { - mmGetPlaygroundConversation.optional = true - return mmGetPlaygroundConversation +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Optional() *mAppPublicServiceServerMockDeleteRow { + mmDeleteRow.optional = true + return mmDeleteRow } -// Expect sets up expected params for AppPublicServiceServer.GetPlaygroundConversation -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Expect(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) *mAppPublicServiceServerMockGetPlaygroundConversation { - if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.DeleteRow +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Expect(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest) *mAppPublicServiceServerMockDeleteRow { + if mmDeleteRow.mock.funcDeleteRow != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Set") } - if mmGetPlaygroundConversation.defaultExpectation == nil { - mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{} + if mmDeleteRow.defaultExpectation == nil { + mmDeleteRow.defaultExpectation = &AppPublicServiceServerMockDeleteRowExpectation{} } - if mmGetPlaygroundConversation.defaultExpectation.paramPtrs != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by ExpectParams functions") + if mmDeleteRow.defaultExpectation.paramPtrs != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by ExpectParams functions") } - mmGetPlaygroundConversation.defaultExpectation.params = &AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1} - mmGetPlaygroundConversation.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPlaygroundConversation.expectations { - if minimock.Equal(e.params, mmGetPlaygroundConversation.defaultExpectation.params) { - mmGetPlaygroundConversation.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPlaygroundConversation.defaultExpectation.params) + mmDeleteRow.defaultExpectation.params = &AppPublicServiceServerMockDeleteRowParams{ctx, dp1} + mmDeleteRow.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteRow.expectations { + if minimock.Equal(e.params, mmDeleteRow.defaultExpectation.params) { + mmDeleteRow.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteRow.defaultExpectation.params) } } - return mmGetPlaygroundConversation + return mmDeleteRow } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.GetPlaygroundConversation -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockGetPlaygroundConversation { - if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.DeleteRow +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockDeleteRow { + if mmDeleteRow.mock.funcDeleteRow != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Set") } - if mmGetPlaygroundConversation.defaultExpectation == nil { - mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{} + if mmDeleteRow.defaultExpectation == nil { + mmDeleteRow.defaultExpectation = &AppPublicServiceServerMockDeleteRowExpectation{} } - if mmGetPlaygroundConversation.defaultExpectation.params != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Expect") + if mmDeleteRow.defaultExpectation.params != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Expect") } - if mmGetPlaygroundConversation.defaultExpectation.paramPtrs == nil { - mmGetPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetPlaygroundConversationParamPtrs{} + if mmDeleteRow.defaultExpectation.paramPtrs == nil { + mmDeleteRow.defaultExpectation.paramPtrs = &AppPublicServiceServerMockDeleteRowParamPtrs{} } - mmGetPlaygroundConversation.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPlaygroundConversation.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteRow.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteRow.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPlaygroundConversation + return mmDeleteRow } -// ExpectGp1Param2 sets up expected param gp1 for AppPublicServiceServer.GetPlaygroundConversation -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) ExpectGp1Param2(gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) *mAppPublicServiceServerMockGetPlaygroundConversation { - if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") +// ExpectDp1Param2 sets up expected param dp1 for AppPublicServiceServer.DeleteRow +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) ExpectDp1Param2(dp1 *mm_appv1alpha.DeleteRowRequest) *mAppPublicServiceServerMockDeleteRow { + if mmDeleteRow.mock.funcDeleteRow != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Set") } - if mmGetPlaygroundConversation.defaultExpectation == nil { - mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{} + if mmDeleteRow.defaultExpectation == nil { + mmDeleteRow.defaultExpectation = &AppPublicServiceServerMockDeleteRowExpectation{} } - if mmGetPlaygroundConversation.defaultExpectation.params != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Expect") + if mmDeleteRow.defaultExpectation.params != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Expect") } - if mmGetPlaygroundConversation.defaultExpectation.paramPtrs == nil { - mmGetPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetPlaygroundConversationParamPtrs{} + if mmDeleteRow.defaultExpectation.paramPtrs == nil { + mmDeleteRow.defaultExpectation.paramPtrs = &AppPublicServiceServerMockDeleteRowParamPtrs{} } - mmGetPlaygroundConversation.defaultExpectation.paramPtrs.gp1 = &gp1 - mmGetPlaygroundConversation.defaultExpectation.expectationOrigins.originGp1 = minimock.CallerInfo(1) + mmDeleteRow.defaultExpectation.paramPtrs.dp1 = &dp1 + mmDeleteRow.defaultExpectation.expectationOrigins.originDp1 = minimock.CallerInfo(1) - return mmGetPlaygroundConversation + return mmDeleteRow } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.GetPlaygroundConversation -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Inspect(f func(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest)) *mAppPublicServiceServerMockGetPlaygroundConversation { - if mmGetPlaygroundConversation.mock.inspectFuncGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.GetPlaygroundConversation") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.DeleteRow +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Inspect(f func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest)) *mAppPublicServiceServerMockDeleteRow { + if mmDeleteRow.mock.inspectFuncDeleteRow != nil { + mmDeleteRow.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.DeleteRow") } - mmGetPlaygroundConversation.mock.inspectFuncGetPlaygroundConversation = f + mmDeleteRow.mock.inspectFuncDeleteRow = f - return mmGetPlaygroundConversation + return mmDeleteRow } -// Return sets up results that will be returned by AppPublicServiceServer.GetPlaygroundConversation -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Return(gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { - if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.DeleteRow +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Return(dp2 *mm_appv1alpha.DeleteRowResponse, err error) *AppPublicServiceServerMock { + if mmDeleteRow.mock.funcDeleteRow != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Set") } - if mmGetPlaygroundConversation.defaultExpectation == nil { - mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{mock: mmGetPlaygroundConversation.mock} + if mmDeleteRow.defaultExpectation == nil { + mmDeleteRow.defaultExpectation = &AppPublicServiceServerMockDeleteRowExpectation{mock: mmDeleteRow.mock} } - mmGetPlaygroundConversation.defaultExpectation.results = &AppPublicServiceServerMockGetPlaygroundConversationResults{gp2, err} - mmGetPlaygroundConversation.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPlaygroundConversation.mock + mmDeleteRow.defaultExpectation.results = &AppPublicServiceServerMockDeleteRowResults{dp2, err} + mmDeleteRow.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteRow.mock } -// Set uses given function f to mock the AppPublicServiceServer.GetPlaygroundConversation method -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Set(f func(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) (gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error)) *AppPublicServiceServerMock { - if mmGetPlaygroundConversation.defaultExpectation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.GetPlaygroundConversation method") +// Set uses given function f to mock the AppPublicServiceServer.DeleteRow method +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Set(f func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest) (dp2 *mm_appv1alpha.DeleteRowResponse, err error)) *AppPublicServiceServerMock { + if mmDeleteRow.defaultExpectation != nil { + mmDeleteRow.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.DeleteRow method") } - if len(mmGetPlaygroundConversation.expectations) > 0 { - mmGetPlaygroundConversation.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.GetPlaygroundConversation method") + if len(mmDeleteRow.expectations) > 0 { + mmDeleteRow.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.DeleteRow method") } - mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation = f - mmGetPlaygroundConversation.mock.funcGetPlaygroundConversationOrigin = minimock.CallerInfo(1) - return mmGetPlaygroundConversation.mock + mmDeleteRow.mock.funcDeleteRow = f + mmDeleteRow.mock.funcDeleteRowOrigin = minimock.CallerInfo(1) + return mmDeleteRow.mock } -// When sets expectation for the AppPublicServiceServer.GetPlaygroundConversation which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.DeleteRow which will trigger the result defined by the following // Then helper -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) When(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) *AppPublicServiceServerMockGetPlaygroundConversationExpectation { - if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) When(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest) *AppPublicServiceServerMockDeleteRowExpectation { + if mmDeleteRow.mock.funcDeleteRow != nil { + mmDeleteRow.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRow mock is already set by Set") } - expectation := &AppPublicServiceServerMockGetPlaygroundConversationExpectation{ - mock: mmGetPlaygroundConversation.mock, - params: &AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1}, - expectationOrigins: AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockDeleteRowExpectation{ + mock: mmDeleteRow.mock, + params: &AppPublicServiceServerMockDeleteRowParams{ctx, dp1}, + expectationOrigins: AppPublicServiceServerMockDeleteRowExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPlaygroundConversation.expectations = append(mmGetPlaygroundConversation.expectations, expectation) + mmDeleteRow.expectations = append(mmDeleteRow.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.GetPlaygroundConversation return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockGetPlaygroundConversationExpectation) Then(gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockGetPlaygroundConversationResults{gp2, err} +// Then sets up AppPublicServiceServer.DeleteRow return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockDeleteRowExpectation) Then(dp2 *mm_appv1alpha.DeleteRowResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockDeleteRowResults{dp2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.GetPlaygroundConversation should be invoked -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Times(n uint64) *mAppPublicServiceServerMockGetPlaygroundConversation { +// Times sets number of times AppPublicServiceServer.DeleteRow should be invoked +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Times(n uint64) *mAppPublicServiceServerMockDeleteRow { if n == 0 { - mmGetPlaygroundConversation.mock.t.Fatalf("Times of AppPublicServiceServerMock.GetPlaygroundConversation mock can not be zero") + mmDeleteRow.mock.t.Fatalf("Times of AppPublicServiceServerMock.DeleteRow mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPlaygroundConversation.expectedInvocations, n) - mmGetPlaygroundConversation.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPlaygroundConversation + mm_atomic.StoreUint64(&mmDeleteRow.expectedInvocations, n) + mmDeleteRow.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteRow } -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) invocationsDone() bool { - if len(mmGetPlaygroundConversation.expectations) == 0 && mmGetPlaygroundConversation.defaultExpectation == nil && mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation == nil { +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) invocationsDone() bool { + if len(mmDeleteRow.expectations) == 0 && mmDeleteRow.defaultExpectation == nil && mmDeleteRow.mock.funcDeleteRow == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPlaygroundConversation.mock.afterGetPlaygroundConversationCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPlaygroundConversation.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteRow.mock.afterDeleteRowCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteRow.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPlaygroundConversation implements mm_appv1alpha.AppPublicServiceServer -func (mmGetPlaygroundConversation *AppPublicServiceServerMock) GetPlaygroundConversation(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) (gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) { - mm_atomic.AddUint64(&mmGetPlaygroundConversation.beforeGetPlaygroundConversationCounter, 1) - defer mm_atomic.AddUint64(&mmGetPlaygroundConversation.afterGetPlaygroundConversationCounter, 1) +// DeleteRow implements mm_appv1alpha.AppPublicServiceServer +func (mmDeleteRow *AppPublicServiceServerMock) DeleteRow(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowRequest) (dp2 *mm_appv1alpha.DeleteRowResponse, err error) { + mm_atomic.AddUint64(&mmDeleteRow.beforeDeleteRowCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteRow.afterDeleteRowCounter, 1) - mmGetPlaygroundConversation.t.Helper() + mmDeleteRow.t.Helper() - if mmGetPlaygroundConversation.inspectFuncGetPlaygroundConversation != nil { - mmGetPlaygroundConversation.inspectFuncGetPlaygroundConversation(ctx, gp1) + if mmDeleteRow.inspectFuncDeleteRow != nil { + mmDeleteRow.inspectFuncDeleteRow(ctx, dp1) } - mm_params := AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1} + mm_params := AppPublicServiceServerMockDeleteRowParams{ctx, dp1} // Record call args - mmGetPlaygroundConversation.GetPlaygroundConversationMock.mutex.Lock() - mmGetPlaygroundConversation.GetPlaygroundConversationMock.callArgs = append(mmGetPlaygroundConversation.GetPlaygroundConversationMock.callArgs, &mm_params) - mmGetPlaygroundConversation.GetPlaygroundConversationMock.mutex.Unlock() + mmDeleteRow.DeleteRowMock.mutex.Lock() + mmDeleteRow.DeleteRowMock.callArgs = append(mmDeleteRow.DeleteRowMock.callArgs, &mm_params) + mmDeleteRow.DeleteRowMock.mutex.Unlock() - for _, e := range mmGetPlaygroundConversation.GetPlaygroundConversationMock.expectations { + for _, e := range mmDeleteRow.DeleteRowMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.gp2, e.results.err + return e.results.dp2, e.results.err } } - if mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.Counter, 1) - mm_want := mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.params - mm_want_ptrs := mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.paramPtrs + if mmDeleteRow.DeleteRowMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteRow.DeleteRowMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteRow.DeleteRowMock.defaultExpectation.params + mm_want_ptrs := mmDeleteRow.DeleteRowMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1} + mm_got := AppPublicServiceServerMockDeleteRowParams{ctx, dp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.GetPlaygroundConversation got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteRow.t.Errorf("AppPublicServiceServerMock.DeleteRow got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRow.DeleteRowMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.gp1 != nil && !minimock.Equal(*mm_want_ptrs.gp1, mm_got.gp1) { - mmGetPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.GetPlaygroundConversation got unexpected parameter gp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.originGp1, *mm_want_ptrs.gp1, mm_got.gp1, minimock.Diff(*mm_want_ptrs.gp1, mm_got.gp1)) + if mm_want_ptrs.dp1 != nil && !minimock.Equal(*mm_want_ptrs.dp1, mm_got.dp1) { + mmDeleteRow.t.Errorf("AppPublicServiceServerMock.DeleteRow got unexpected parameter dp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRow.DeleteRowMock.defaultExpectation.expectationOrigins.originDp1, *mm_want_ptrs.dp1, mm_got.dp1, minimock.Diff(*mm_want_ptrs.dp1, mm_got.dp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.GetPlaygroundConversation got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteRow.t.Errorf("AppPublicServiceServerMock.DeleteRow got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRow.DeleteRowMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.results + mm_results := mmDeleteRow.DeleteRowMock.defaultExpectation.results if mm_results == nil { - mmGetPlaygroundConversation.t.Fatal("No results are set for the AppPublicServiceServerMock.GetPlaygroundConversation") + mmDeleteRow.t.Fatal("No results are set for the AppPublicServiceServerMock.DeleteRow") } - return (*mm_results).gp2, (*mm_results).err + return (*mm_results).dp2, (*mm_results).err } - if mmGetPlaygroundConversation.funcGetPlaygroundConversation != nil { - return mmGetPlaygroundConversation.funcGetPlaygroundConversation(ctx, gp1) + if mmDeleteRow.funcDeleteRow != nil { + return mmDeleteRow.funcDeleteRow(ctx, dp1) } - mmGetPlaygroundConversation.t.Fatalf("Unexpected call to AppPublicServiceServerMock.GetPlaygroundConversation. %v %v", ctx, gp1) + mmDeleteRow.t.Fatalf("Unexpected call to AppPublicServiceServerMock.DeleteRow. %v %v", ctx, dp1) return } -// GetPlaygroundConversationAfterCounter returns a count of finished AppPublicServiceServerMock.GetPlaygroundConversation invocations -func (mmGetPlaygroundConversation *AppPublicServiceServerMock) GetPlaygroundConversationAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPlaygroundConversation.afterGetPlaygroundConversationCounter) +// DeleteRowAfterCounter returns a count of finished AppPublicServiceServerMock.DeleteRow invocations +func (mmDeleteRow *AppPublicServiceServerMock) DeleteRowAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteRow.afterDeleteRowCounter) } -// GetPlaygroundConversationBeforeCounter returns a count of AppPublicServiceServerMock.GetPlaygroundConversation invocations -func (mmGetPlaygroundConversation *AppPublicServiceServerMock) GetPlaygroundConversationBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPlaygroundConversation.beforeGetPlaygroundConversationCounter) +// DeleteRowBeforeCounter returns a count of AppPublicServiceServerMock.DeleteRow invocations +func (mmDeleteRow *AppPublicServiceServerMock) DeleteRowBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteRow.beforeDeleteRowCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.GetPlaygroundConversation. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.DeleteRow. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Calls() []*AppPublicServiceServerMockGetPlaygroundConversationParams { - mmGetPlaygroundConversation.mutex.RLock() +func (mmDeleteRow *mAppPublicServiceServerMockDeleteRow) Calls() []*AppPublicServiceServerMockDeleteRowParams { + mmDeleteRow.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockGetPlaygroundConversationParams, len(mmGetPlaygroundConversation.callArgs)) - copy(argCopy, mmGetPlaygroundConversation.callArgs) + argCopy := make([]*AppPublicServiceServerMockDeleteRowParams, len(mmDeleteRow.callArgs)) + copy(argCopy, mmDeleteRow.callArgs) - mmGetPlaygroundConversation.mutex.RUnlock() + mmDeleteRow.mutex.RUnlock() return argCopy } -// MinimockGetPlaygroundConversationDone returns true if the count of the GetPlaygroundConversation invocations corresponds +// MinimockDeleteRowDone returns true if the count of the DeleteRow invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockGetPlaygroundConversationDone() bool { - if m.GetPlaygroundConversationMock.optional { +func (m *AppPublicServiceServerMock) MinimockDeleteRowDone() bool { + if m.DeleteRowMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPlaygroundConversationMock.expectations { + for _, e := range m.DeleteRowMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPlaygroundConversationMock.invocationsDone() + return m.DeleteRowMock.invocationsDone() } -// MinimockGetPlaygroundConversationInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockGetPlaygroundConversationInspect() { - for _, e := range m.GetPlaygroundConversationMock.expectations { +// MinimockDeleteRowInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockDeleteRowInspect() { + for _, e := range m.DeleteRowMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRow at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPlaygroundConversationCounter := mm_atomic.LoadUint64(&m.afterGetPlaygroundConversationCounter) + afterDeleteRowCounter := mm_atomic.LoadUint64(&m.afterDeleteRowCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPlaygroundConversationMock.defaultExpectation != nil && afterGetPlaygroundConversationCounter < 1 { - if m.GetPlaygroundConversationMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s", m.GetPlaygroundConversationMock.defaultExpectation.returnOrigin) + if m.DeleteRowMock.defaultExpectation != nil && afterDeleteRowCounter < 1 { + if m.DeleteRowMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRow at\n%s", m.DeleteRowMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s with params: %#v", m.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *m.GetPlaygroundConversationMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRow at\n%s with params: %#v", m.DeleteRowMock.defaultExpectation.expectationOrigins.origin, *m.DeleteRowMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPlaygroundConversation != nil && afterGetPlaygroundConversationCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s", m.funcGetPlaygroundConversationOrigin) + if m.funcDeleteRow != nil && afterDeleteRowCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRow at\n%s", m.funcDeleteRowOrigin) } - if !m.GetPlaygroundConversationMock.invocationsDone() && afterGetPlaygroundConversationCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPlaygroundConversationMock.expectedInvocations), m.GetPlaygroundConversationMock.expectedInvocationsOrigin, afterGetPlaygroundConversationCounter) + if !m.DeleteRowMock.invocationsDone() && afterDeleteRowCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.DeleteRow at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteRowMock.expectedInvocations), m.DeleteRowMock.expectedInvocationsOrigin, afterDeleteRowCounter) } } -type mAppPublicServiceServerMockListAgents struct { +type mAppPublicServiceServerMockDeleteRows struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListAgentsExpectation - expectations []*AppPublicServiceServerMockListAgentsExpectation + defaultExpectation *AppPublicServiceServerMockDeleteRowsExpectation + expectations []*AppPublicServiceServerMockDeleteRowsExpectation - callArgs []*AppPublicServiceServerMockListAgentsParams + callArgs []*AppPublicServiceServerMockDeleteRowsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListAgentsExpectation specifies expectation struct of the AppPublicServiceServer.ListAgents -type AppPublicServiceServerMockListAgentsExpectation struct { +// AppPublicServiceServerMockDeleteRowsExpectation specifies expectation struct of the AppPublicServiceServer.DeleteRows +type AppPublicServiceServerMockDeleteRowsExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListAgentsParams - paramPtrs *AppPublicServiceServerMockListAgentsParamPtrs - expectationOrigins AppPublicServiceServerMockListAgentsExpectationOrigins - results *AppPublicServiceServerMockListAgentsResults + params *AppPublicServiceServerMockDeleteRowsParams + paramPtrs *AppPublicServiceServerMockDeleteRowsParamPtrs + expectationOrigins AppPublicServiceServerMockDeleteRowsExpectationOrigins + results *AppPublicServiceServerMockDeleteRowsResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListAgentsParams contains parameters of the AppPublicServiceServer.ListAgents -type AppPublicServiceServerMockListAgentsParams struct { +// AppPublicServiceServerMockDeleteRowsParams contains parameters of the AppPublicServiceServer.DeleteRows +type AppPublicServiceServerMockDeleteRowsParams struct { ctx context.Context - lp1 *mm_appv1alpha.ListAgentsRequest + dp1 *mm_appv1alpha.DeleteRowsRequest } -// AppPublicServiceServerMockListAgentsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListAgents -type AppPublicServiceServerMockListAgentsParamPtrs struct { +// AppPublicServiceServerMockDeleteRowsParamPtrs contains pointers to parameters of the AppPublicServiceServer.DeleteRows +type AppPublicServiceServerMockDeleteRowsParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.ListAgentsRequest + dp1 **mm_appv1alpha.DeleteRowsRequest } -// AppPublicServiceServerMockListAgentsResults contains results of the AppPublicServiceServer.ListAgents -type AppPublicServiceServerMockListAgentsResults struct { - lp2 *mm_appv1alpha.ListAgentsResponse +// AppPublicServiceServerMockDeleteRowsResults contains results of the AppPublicServiceServer.DeleteRows +type AppPublicServiceServerMockDeleteRowsResults struct { + dp2 *mm_appv1alpha.DeleteRowsResponse err error } -// AppPublicServiceServerMockListAgentsOrigins contains origins of expectations of the AppPublicServiceServer.ListAgents -type AppPublicServiceServerMockListAgentsExpectationOrigins struct { +// AppPublicServiceServerMockDeleteRowsOrigins contains origins of expectations of the AppPublicServiceServer.DeleteRows +type AppPublicServiceServerMockDeleteRowsExpectationOrigins struct { origin string originCtx string - originLp1 string + originDp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -4471,342 +4974,342 @@ type AppPublicServiceServerMockListAgentsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListAgents *mAppPublicServiceServerMockListAgents) Optional() *mAppPublicServiceServerMockListAgents { - mmListAgents.optional = true - return mmListAgents +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Optional() *mAppPublicServiceServerMockDeleteRows { + mmDeleteRows.optional = true + return mmDeleteRows } -// Expect sets up expected params for AppPublicServiceServer.ListAgents -func (mmListAgents *mAppPublicServiceServerMockListAgents) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) *mAppPublicServiceServerMockListAgents { - if mmListAgents.mock.funcListAgents != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.DeleteRows +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Expect(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest) *mAppPublicServiceServerMockDeleteRows { + if mmDeleteRows.mock.funcDeleteRows != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Set") } - if mmListAgents.defaultExpectation == nil { - mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{} + if mmDeleteRows.defaultExpectation == nil { + mmDeleteRows.defaultExpectation = &AppPublicServiceServerMockDeleteRowsExpectation{} } - if mmListAgents.defaultExpectation.paramPtrs != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by ExpectParams functions") + if mmDeleteRows.defaultExpectation.paramPtrs != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by ExpectParams functions") } - mmListAgents.defaultExpectation.params = &AppPublicServiceServerMockListAgentsParams{ctx, lp1} - mmListAgents.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListAgents.expectations { - if minimock.Equal(e.params, mmListAgents.defaultExpectation.params) { - mmListAgents.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListAgents.defaultExpectation.params) + mmDeleteRows.defaultExpectation.params = &AppPublicServiceServerMockDeleteRowsParams{ctx, dp1} + mmDeleteRows.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteRows.expectations { + if minimock.Equal(e.params, mmDeleteRows.defaultExpectation.params) { + mmDeleteRows.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteRows.defaultExpectation.params) } } - return mmListAgents + return mmDeleteRows } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListAgents -func (mmListAgents *mAppPublicServiceServerMockListAgents) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListAgents { - if mmListAgents.mock.funcListAgents != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.DeleteRows +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockDeleteRows { + if mmDeleteRows.mock.funcDeleteRows != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Set") } - if mmListAgents.defaultExpectation == nil { - mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{} + if mmDeleteRows.defaultExpectation == nil { + mmDeleteRows.defaultExpectation = &AppPublicServiceServerMockDeleteRowsExpectation{} } - if mmListAgents.defaultExpectation.params != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Expect") + if mmDeleteRows.defaultExpectation.params != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Expect") } - if mmListAgents.defaultExpectation.paramPtrs == nil { - mmListAgents.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAgentsParamPtrs{} + if mmDeleteRows.defaultExpectation.paramPtrs == nil { + mmDeleteRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockDeleteRowsParamPtrs{} } - mmListAgents.defaultExpectation.paramPtrs.ctx = &ctx - mmListAgents.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteRows.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteRows.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmListAgents + return mmDeleteRows } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListAgents -func (mmListAgents *mAppPublicServiceServerMockListAgents) ExpectLp1Param2(lp1 *mm_appv1alpha.ListAgentsRequest) *mAppPublicServiceServerMockListAgents { - if mmListAgents.mock.funcListAgents != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") +// ExpectDp1Param2 sets up expected param dp1 for AppPublicServiceServer.DeleteRows +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) ExpectDp1Param2(dp1 *mm_appv1alpha.DeleteRowsRequest) *mAppPublicServiceServerMockDeleteRows { + if mmDeleteRows.mock.funcDeleteRows != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Set") } - if mmListAgents.defaultExpectation == nil { - mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{} + if mmDeleteRows.defaultExpectation == nil { + mmDeleteRows.defaultExpectation = &AppPublicServiceServerMockDeleteRowsExpectation{} } - if mmListAgents.defaultExpectation.params != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Expect") + if mmDeleteRows.defaultExpectation.params != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Expect") } - if mmListAgents.defaultExpectation.paramPtrs == nil { - mmListAgents.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAgentsParamPtrs{} + if mmDeleteRows.defaultExpectation.paramPtrs == nil { + mmDeleteRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockDeleteRowsParamPtrs{} } - mmListAgents.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListAgents.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmDeleteRows.defaultExpectation.paramPtrs.dp1 = &dp1 + mmDeleteRows.defaultExpectation.expectationOrigins.originDp1 = minimock.CallerInfo(1) - return mmListAgents + return mmDeleteRows } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListAgents -func (mmListAgents *mAppPublicServiceServerMockListAgents) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest)) *mAppPublicServiceServerMockListAgents { - if mmListAgents.mock.inspectFuncListAgents != nil { - mmListAgents.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListAgents") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.DeleteRows +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Inspect(f func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest)) *mAppPublicServiceServerMockDeleteRows { + if mmDeleteRows.mock.inspectFuncDeleteRows != nil { + mmDeleteRows.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.DeleteRows") } - mmListAgents.mock.inspectFuncListAgents = f + mmDeleteRows.mock.inspectFuncDeleteRows = f - return mmListAgents + return mmDeleteRows } -// Return sets up results that will be returned by AppPublicServiceServer.ListAgents -func (mmListAgents *mAppPublicServiceServerMockListAgents) Return(lp2 *mm_appv1alpha.ListAgentsResponse, err error) *AppPublicServiceServerMock { - if mmListAgents.mock.funcListAgents != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.DeleteRows +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Return(dp2 *mm_appv1alpha.DeleteRowsResponse, err error) *AppPublicServiceServerMock { + if mmDeleteRows.mock.funcDeleteRows != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Set") } - if mmListAgents.defaultExpectation == nil { - mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{mock: mmListAgents.mock} + if mmDeleteRows.defaultExpectation == nil { + mmDeleteRows.defaultExpectation = &AppPublicServiceServerMockDeleteRowsExpectation{mock: mmDeleteRows.mock} } - mmListAgents.defaultExpectation.results = &AppPublicServiceServerMockListAgentsResults{lp2, err} - mmListAgents.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListAgents.mock + mmDeleteRows.defaultExpectation.results = &AppPublicServiceServerMockDeleteRowsResults{dp2, err} + mmDeleteRows.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteRows.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListAgents method -func (mmListAgents *mAppPublicServiceServerMockListAgents) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) (lp2 *mm_appv1alpha.ListAgentsResponse, err error)) *AppPublicServiceServerMock { - if mmListAgents.defaultExpectation != nil { - mmListAgents.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListAgents method") +// Set uses given function f to mock the AppPublicServiceServer.DeleteRows method +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Set(f func(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest) (dp2 *mm_appv1alpha.DeleteRowsResponse, err error)) *AppPublicServiceServerMock { + if mmDeleteRows.defaultExpectation != nil { + mmDeleteRows.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.DeleteRows method") } - if len(mmListAgents.expectations) > 0 { - mmListAgents.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListAgents method") + if len(mmDeleteRows.expectations) > 0 { + mmDeleteRows.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.DeleteRows method") } - mmListAgents.mock.funcListAgents = f - mmListAgents.mock.funcListAgentsOrigin = minimock.CallerInfo(1) - return mmListAgents.mock + mmDeleteRows.mock.funcDeleteRows = f + mmDeleteRows.mock.funcDeleteRowsOrigin = minimock.CallerInfo(1) + return mmDeleteRows.mock } -// When sets expectation for the AppPublicServiceServer.ListAgents which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.DeleteRows which will trigger the result defined by the following // Then helper -func (mmListAgents *mAppPublicServiceServerMockListAgents) When(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) *AppPublicServiceServerMockListAgentsExpectation { - if mmListAgents.mock.funcListAgents != nil { - mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) When(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest) *AppPublicServiceServerMockDeleteRowsExpectation { + if mmDeleteRows.mock.funcDeleteRows != nil { + mmDeleteRows.mock.t.Fatalf("AppPublicServiceServerMock.DeleteRows mock is already set by Set") } - expectation := &AppPublicServiceServerMockListAgentsExpectation{ - mock: mmListAgents.mock, - params: &AppPublicServiceServerMockListAgentsParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListAgentsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockDeleteRowsExpectation{ + mock: mmDeleteRows.mock, + params: &AppPublicServiceServerMockDeleteRowsParams{ctx, dp1}, + expectationOrigins: AppPublicServiceServerMockDeleteRowsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListAgents.expectations = append(mmListAgents.expectations, expectation) + mmDeleteRows.expectations = append(mmDeleteRows.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListAgents return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListAgentsExpectation) Then(lp2 *mm_appv1alpha.ListAgentsResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListAgentsResults{lp2, err} +// Then sets up AppPublicServiceServer.DeleteRows return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockDeleteRowsExpectation) Then(dp2 *mm_appv1alpha.DeleteRowsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockDeleteRowsResults{dp2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListAgents should be invoked -func (mmListAgents *mAppPublicServiceServerMockListAgents) Times(n uint64) *mAppPublicServiceServerMockListAgents { +// Times sets number of times AppPublicServiceServer.DeleteRows should be invoked +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Times(n uint64) *mAppPublicServiceServerMockDeleteRows { if n == 0 { - mmListAgents.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListAgents mock can not be zero") + mmDeleteRows.mock.t.Fatalf("Times of AppPublicServiceServerMock.DeleteRows mock can not be zero") } - mm_atomic.StoreUint64(&mmListAgents.expectedInvocations, n) - mmListAgents.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListAgents + mm_atomic.StoreUint64(&mmDeleteRows.expectedInvocations, n) + mmDeleteRows.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteRows } -func (mmListAgents *mAppPublicServiceServerMockListAgents) invocationsDone() bool { - if len(mmListAgents.expectations) == 0 && mmListAgents.defaultExpectation == nil && mmListAgents.mock.funcListAgents == nil { +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) invocationsDone() bool { + if len(mmDeleteRows.expectations) == 0 && mmDeleteRows.defaultExpectation == nil && mmDeleteRows.mock.funcDeleteRows == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListAgents.mock.afterListAgentsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListAgents.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteRows.mock.afterDeleteRowsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteRows.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListAgents implements mm_appv1alpha.AppPublicServiceServer -func (mmListAgents *AppPublicServiceServerMock) ListAgents(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) (lp2 *mm_appv1alpha.ListAgentsResponse, err error) { - mm_atomic.AddUint64(&mmListAgents.beforeListAgentsCounter, 1) - defer mm_atomic.AddUint64(&mmListAgents.afterListAgentsCounter, 1) +// DeleteRows implements mm_appv1alpha.AppPublicServiceServer +func (mmDeleteRows *AppPublicServiceServerMock) DeleteRows(ctx context.Context, dp1 *mm_appv1alpha.DeleteRowsRequest) (dp2 *mm_appv1alpha.DeleteRowsResponse, err error) { + mm_atomic.AddUint64(&mmDeleteRows.beforeDeleteRowsCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteRows.afterDeleteRowsCounter, 1) - mmListAgents.t.Helper() + mmDeleteRows.t.Helper() - if mmListAgents.inspectFuncListAgents != nil { - mmListAgents.inspectFuncListAgents(ctx, lp1) + if mmDeleteRows.inspectFuncDeleteRows != nil { + mmDeleteRows.inspectFuncDeleteRows(ctx, dp1) } - mm_params := AppPublicServiceServerMockListAgentsParams{ctx, lp1} + mm_params := AppPublicServiceServerMockDeleteRowsParams{ctx, dp1} // Record call args - mmListAgents.ListAgentsMock.mutex.Lock() - mmListAgents.ListAgentsMock.callArgs = append(mmListAgents.ListAgentsMock.callArgs, &mm_params) - mmListAgents.ListAgentsMock.mutex.Unlock() + mmDeleteRows.DeleteRowsMock.mutex.Lock() + mmDeleteRows.DeleteRowsMock.callArgs = append(mmDeleteRows.DeleteRowsMock.callArgs, &mm_params) + mmDeleteRows.DeleteRowsMock.mutex.Unlock() - for _, e := range mmListAgents.ListAgentsMock.expectations { + for _, e := range mmDeleteRows.DeleteRowsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.dp2, e.results.err } } - if mmListAgents.ListAgentsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListAgents.ListAgentsMock.defaultExpectation.Counter, 1) - mm_want := mmListAgents.ListAgentsMock.defaultExpectation.params - mm_want_ptrs := mmListAgents.ListAgentsMock.defaultExpectation.paramPtrs + if mmDeleteRows.DeleteRowsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteRows.DeleteRowsMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteRows.DeleteRowsMock.defaultExpectation.params + mm_want_ptrs := mmDeleteRows.DeleteRowsMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListAgentsParams{ctx, lp1} + mm_got := AppPublicServiceServerMockDeleteRowsParams{ctx, dp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListAgents.t.Errorf("AppPublicServiceServerMock.ListAgents got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListAgents.ListAgentsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteRows.t.Errorf("AppPublicServiceServerMock.DeleteRows got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRows.DeleteRowsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListAgents.t.Errorf("AppPublicServiceServerMock.ListAgents got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListAgents.ListAgentsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.dp1 != nil && !minimock.Equal(*mm_want_ptrs.dp1, mm_got.dp1) { + mmDeleteRows.t.Errorf("AppPublicServiceServerMock.DeleteRows got unexpected parameter dp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRows.DeleteRowsMock.defaultExpectation.expectationOrigins.originDp1, *mm_want_ptrs.dp1, mm_got.dp1, minimock.Diff(*mm_want_ptrs.dp1, mm_got.dp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListAgents.t.Errorf("AppPublicServiceServerMock.ListAgents got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListAgents.ListAgentsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteRows.t.Errorf("AppPublicServiceServerMock.DeleteRows got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRows.DeleteRowsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListAgents.ListAgentsMock.defaultExpectation.results + mm_results := mmDeleteRows.DeleteRowsMock.defaultExpectation.results if mm_results == nil { - mmListAgents.t.Fatal("No results are set for the AppPublicServiceServerMock.ListAgents") + mmDeleteRows.t.Fatal("No results are set for the AppPublicServiceServerMock.DeleteRows") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).dp2, (*mm_results).err } - if mmListAgents.funcListAgents != nil { - return mmListAgents.funcListAgents(ctx, lp1) + if mmDeleteRows.funcDeleteRows != nil { + return mmDeleteRows.funcDeleteRows(ctx, dp1) } - mmListAgents.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListAgents. %v %v", ctx, lp1) + mmDeleteRows.t.Fatalf("Unexpected call to AppPublicServiceServerMock.DeleteRows. %v %v", ctx, dp1) return } -// ListAgentsAfterCounter returns a count of finished AppPublicServiceServerMock.ListAgents invocations -func (mmListAgents *AppPublicServiceServerMock) ListAgentsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListAgents.afterListAgentsCounter) +// DeleteRowsAfterCounter returns a count of finished AppPublicServiceServerMock.DeleteRows invocations +func (mmDeleteRows *AppPublicServiceServerMock) DeleteRowsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteRows.afterDeleteRowsCounter) } -// ListAgentsBeforeCounter returns a count of AppPublicServiceServerMock.ListAgents invocations -func (mmListAgents *AppPublicServiceServerMock) ListAgentsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListAgents.beforeListAgentsCounter) +// DeleteRowsBeforeCounter returns a count of AppPublicServiceServerMock.DeleteRows invocations +func (mmDeleteRows *AppPublicServiceServerMock) DeleteRowsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteRows.beforeDeleteRowsCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListAgents. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.DeleteRows. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListAgents *mAppPublicServiceServerMockListAgents) Calls() []*AppPublicServiceServerMockListAgentsParams { - mmListAgents.mutex.RLock() +func (mmDeleteRows *mAppPublicServiceServerMockDeleteRows) Calls() []*AppPublicServiceServerMockDeleteRowsParams { + mmDeleteRows.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListAgentsParams, len(mmListAgents.callArgs)) - copy(argCopy, mmListAgents.callArgs) + argCopy := make([]*AppPublicServiceServerMockDeleteRowsParams, len(mmDeleteRows.callArgs)) + copy(argCopy, mmDeleteRows.callArgs) - mmListAgents.mutex.RUnlock() + mmDeleteRows.mutex.RUnlock() return argCopy } -// MinimockListAgentsDone returns true if the count of the ListAgents invocations corresponds +// MinimockDeleteRowsDone returns true if the count of the DeleteRows invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListAgentsDone() bool { - if m.ListAgentsMock.optional { +func (m *AppPublicServiceServerMock) MinimockDeleteRowsDone() bool { + if m.DeleteRowsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListAgentsMock.expectations { + for _, e := range m.DeleteRowsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListAgentsMock.invocationsDone() + return m.DeleteRowsMock.invocationsDone() } -// MinimockListAgentsInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListAgentsInspect() { - for _, e := range m.ListAgentsMock.expectations { +// MinimockDeleteRowsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockDeleteRowsInspect() { + for _, e := range m.DeleteRowsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRows at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListAgentsCounter := mm_atomic.LoadUint64(&m.afterListAgentsCounter) + afterDeleteRowsCounter := mm_atomic.LoadUint64(&m.afterDeleteRowsCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListAgentsMock.defaultExpectation != nil && afterListAgentsCounter < 1 { - if m.ListAgentsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s", m.ListAgentsMock.defaultExpectation.returnOrigin) + if m.DeleteRowsMock.defaultExpectation != nil && afterDeleteRowsCounter < 1 { + if m.DeleteRowsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRows at\n%s", m.DeleteRowsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s with params: %#v", m.ListAgentsMock.defaultExpectation.expectationOrigins.origin, *m.ListAgentsMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRows at\n%s with params: %#v", m.DeleteRowsMock.defaultExpectation.expectationOrigins.origin, *m.DeleteRowsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListAgents != nil && afterListAgentsCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s", m.funcListAgentsOrigin) + if m.funcDeleteRows != nil && afterDeleteRowsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteRows at\n%s", m.funcDeleteRowsOrigin) } - if !m.ListAgentsMock.invocationsDone() && afterListAgentsCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListAgents at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListAgentsMock.expectedInvocations), m.ListAgentsMock.expectedInvocationsOrigin, afterListAgentsCounter) + if !m.DeleteRowsMock.invocationsDone() && afterDeleteRowsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.DeleteRows at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteRowsMock.expectedInvocations), m.DeleteRowsMock.expectedInvocationsOrigin, afterDeleteRowsCounter) } } -type mAppPublicServiceServerMockListApps struct { +type mAppPublicServiceServerMockDeleteTable struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListAppsExpectation - expectations []*AppPublicServiceServerMockListAppsExpectation + defaultExpectation *AppPublicServiceServerMockDeleteTableExpectation + expectations []*AppPublicServiceServerMockDeleteTableExpectation - callArgs []*AppPublicServiceServerMockListAppsParams + callArgs []*AppPublicServiceServerMockDeleteTableParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListAppsExpectation specifies expectation struct of the AppPublicServiceServer.ListApps -type AppPublicServiceServerMockListAppsExpectation struct { +// AppPublicServiceServerMockDeleteTableExpectation specifies expectation struct of the AppPublicServiceServer.DeleteTable +type AppPublicServiceServerMockDeleteTableExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListAppsParams - paramPtrs *AppPublicServiceServerMockListAppsParamPtrs - expectationOrigins AppPublicServiceServerMockListAppsExpectationOrigins - results *AppPublicServiceServerMockListAppsResults + params *AppPublicServiceServerMockDeleteTableParams + paramPtrs *AppPublicServiceServerMockDeleteTableParamPtrs + expectationOrigins AppPublicServiceServerMockDeleteTableExpectationOrigins + results *AppPublicServiceServerMockDeleteTableResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListAppsParams contains parameters of the AppPublicServiceServer.ListApps -type AppPublicServiceServerMockListAppsParams struct { +// AppPublicServiceServerMockDeleteTableParams contains parameters of the AppPublicServiceServer.DeleteTable +type AppPublicServiceServerMockDeleteTableParams struct { ctx context.Context - lp1 *mm_appv1alpha.ListAppsRequest + dp1 *mm_appv1alpha.DeleteTableRequest } -// AppPublicServiceServerMockListAppsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListApps -type AppPublicServiceServerMockListAppsParamPtrs struct { +// AppPublicServiceServerMockDeleteTableParamPtrs contains pointers to parameters of the AppPublicServiceServer.DeleteTable +type AppPublicServiceServerMockDeleteTableParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.ListAppsRequest + dp1 **mm_appv1alpha.DeleteTableRequest } -// AppPublicServiceServerMockListAppsResults contains results of the AppPublicServiceServer.ListApps -type AppPublicServiceServerMockListAppsResults struct { - lp2 *mm_appv1alpha.ListAppsResponse +// AppPublicServiceServerMockDeleteTableResults contains results of the AppPublicServiceServer.DeleteTable +type AppPublicServiceServerMockDeleteTableResults struct { + dp2 *mm_appv1alpha.DeleteTableResponse err error } -// AppPublicServiceServerMockListAppsOrigins contains origins of expectations of the AppPublicServiceServer.ListApps -type AppPublicServiceServerMockListAppsExpectationOrigins struct { +// AppPublicServiceServerMockDeleteTableOrigins contains origins of expectations of the AppPublicServiceServer.DeleteTable +type AppPublicServiceServerMockDeleteTableExpectationOrigins struct { origin string originCtx string - originLp1 string + originDp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -4814,342 +5317,342 @@ type AppPublicServiceServerMockListAppsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListApps *mAppPublicServiceServerMockListApps) Optional() *mAppPublicServiceServerMockListApps { - mmListApps.optional = true - return mmListApps +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Optional() *mAppPublicServiceServerMockDeleteTable { + mmDeleteTable.optional = true + return mmDeleteTable } -// Expect sets up expected params for AppPublicServiceServer.ListApps -func (mmListApps *mAppPublicServiceServerMockListApps) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) *mAppPublicServiceServerMockListApps { - if mmListApps.mock.funcListApps != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.DeleteTable +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Expect(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest) *mAppPublicServiceServerMockDeleteTable { + if mmDeleteTable.mock.funcDeleteTable != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Set") } - if mmListApps.defaultExpectation == nil { - mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{} + if mmDeleteTable.defaultExpectation == nil { + mmDeleteTable.defaultExpectation = &AppPublicServiceServerMockDeleteTableExpectation{} } - if mmListApps.defaultExpectation.paramPtrs != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by ExpectParams functions") + if mmDeleteTable.defaultExpectation.paramPtrs != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by ExpectParams functions") } - mmListApps.defaultExpectation.params = &AppPublicServiceServerMockListAppsParams{ctx, lp1} - mmListApps.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListApps.expectations { - if minimock.Equal(e.params, mmListApps.defaultExpectation.params) { - mmListApps.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListApps.defaultExpectation.params) + mmDeleteTable.defaultExpectation.params = &AppPublicServiceServerMockDeleteTableParams{ctx, dp1} + mmDeleteTable.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteTable.expectations { + if minimock.Equal(e.params, mmDeleteTable.defaultExpectation.params) { + mmDeleteTable.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteTable.defaultExpectation.params) } } - return mmListApps + return mmDeleteTable } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListApps -func (mmListApps *mAppPublicServiceServerMockListApps) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListApps { - if mmListApps.mock.funcListApps != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.DeleteTable +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockDeleteTable { + if mmDeleteTable.mock.funcDeleteTable != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Set") } - if mmListApps.defaultExpectation == nil { - mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{} + if mmDeleteTable.defaultExpectation == nil { + mmDeleteTable.defaultExpectation = &AppPublicServiceServerMockDeleteTableExpectation{} } - if mmListApps.defaultExpectation.params != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Expect") + if mmDeleteTable.defaultExpectation.params != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Expect") } - if mmListApps.defaultExpectation.paramPtrs == nil { - mmListApps.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAppsParamPtrs{} + if mmDeleteTable.defaultExpectation.paramPtrs == nil { + mmDeleteTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockDeleteTableParamPtrs{} } - mmListApps.defaultExpectation.paramPtrs.ctx = &ctx - mmListApps.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteTable.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteTable.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmListApps + return mmDeleteTable } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListApps -func (mmListApps *mAppPublicServiceServerMockListApps) ExpectLp1Param2(lp1 *mm_appv1alpha.ListAppsRequest) *mAppPublicServiceServerMockListApps { - if mmListApps.mock.funcListApps != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") +// ExpectDp1Param2 sets up expected param dp1 for AppPublicServiceServer.DeleteTable +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) ExpectDp1Param2(dp1 *mm_appv1alpha.DeleteTableRequest) *mAppPublicServiceServerMockDeleteTable { + if mmDeleteTable.mock.funcDeleteTable != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Set") } - if mmListApps.defaultExpectation == nil { - mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{} + if mmDeleteTable.defaultExpectation == nil { + mmDeleteTable.defaultExpectation = &AppPublicServiceServerMockDeleteTableExpectation{} } - if mmListApps.defaultExpectation.params != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Expect") + if mmDeleteTable.defaultExpectation.params != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Expect") } - if mmListApps.defaultExpectation.paramPtrs == nil { - mmListApps.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAppsParamPtrs{} + if mmDeleteTable.defaultExpectation.paramPtrs == nil { + mmDeleteTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockDeleteTableParamPtrs{} } - mmListApps.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListApps.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmDeleteTable.defaultExpectation.paramPtrs.dp1 = &dp1 + mmDeleteTable.defaultExpectation.expectationOrigins.originDp1 = minimock.CallerInfo(1) - return mmListApps + return mmDeleteTable } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListApps -func (mmListApps *mAppPublicServiceServerMockListApps) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest)) *mAppPublicServiceServerMockListApps { - if mmListApps.mock.inspectFuncListApps != nil { - mmListApps.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListApps") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.DeleteTable +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Inspect(f func(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest)) *mAppPublicServiceServerMockDeleteTable { + if mmDeleteTable.mock.inspectFuncDeleteTable != nil { + mmDeleteTable.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.DeleteTable") } - mmListApps.mock.inspectFuncListApps = f + mmDeleteTable.mock.inspectFuncDeleteTable = f - return mmListApps + return mmDeleteTable } -// Return sets up results that will be returned by AppPublicServiceServer.ListApps -func (mmListApps *mAppPublicServiceServerMockListApps) Return(lp2 *mm_appv1alpha.ListAppsResponse, err error) *AppPublicServiceServerMock { - if mmListApps.mock.funcListApps != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.DeleteTable +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Return(dp2 *mm_appv1alpha.DeleteTableResponse, err error) *AppPublicServiceServerMock { + if mmDeleteTable.mock.funcDeleteTable != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Set") } - if mmListApps.defaultExpectation == nil { - mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{mock: mmListApps.mock} + if mmDeleteTable.defaultExpectation == nil { + mmDeleteTable.defaultExpectation = &AppPublicServiceServerMockDeleteTableExpectation{mock: mmDeleteTable.mock} } - mmListApps.defaultExpectation.results = &AppPublicServiceServerMockListAppsResults{lp2, err} - mmListApps.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListApps.mock + mmDeleteTable.defaultExpectation.results = &AppPublicServiceServerMockDeleteTableResults{dp2, err} + mmDeleteTable.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteTable.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListApps method -func (mmListApps *mAppPublicServiceServerMockListApps) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) (lp2 *mm_appv1alpha.ListAppsResponse, err error)) *AppPublicServiceServerMock { - if mmListApps.defaultExpectation != nil { - mmListApps.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListApps method") +// Set uses given function f to mock the AppPublicServiceServer.DeleteTable method +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Set(f func(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest) (dp2 *mm_appv1alpha.DeleteTableResponse, err error)) *AppPublicServiceServerMock { + if mmDeleteTable.defaultExpectation != nil { + mmDeleteTable.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.DeleteTable method") } - if len(mmListApps.expectations) > 0 { - mmListApps.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListApps method") + if len(mmDeleteTable.expectations) > 0 { + mmDeleteTable.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.DeleteTable method") } - mmListApps.mock.funcListApps = f - mmListApps.mock.funcListAppsOrigin = minimock.CallerInfo(1) - return mmListApps.mock + mmDeleteTable.mock.funcDeleteTable = f + mmDeleteTable.mock.funcDeleteTableOrigin = minimock.CallerInfo(1) + return mmDeleteTable.mock } -// When sets expectation for the AppPublicServiceServer.ListApps which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.DeleteTable which will trigger the result defined by the following // Then helper -func (mmListApps *mAppPublicServiceServerMockListApps) When(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) *AppPublicServiceServerMockListAppsExpectation { - if mmListApps.mock.funcListApps != nil { - mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) When(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest) *AppPublicServiceServerMockDeleteTableExpectation { + if mmDeleteTable.mock.funcDeleteTable != nil { + mmDeleteTable.mock.t.Fatalf("AppPublicServiceServerMock.DeleteTable mock is already set by Set") } - expectation := &AppPublicServiceServerMockListAppsExpectation{ - mock: mmListApps.mock, - params: &AppPublicServiceServerMockListAppsParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListAppsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockDeleteTableExpectation{ + mock: mmDeleteTable.mock, + params: &AppPublicServiceServerMockDeleteTableParams{ctx, dp1}, + expectationOrigins: AppPublicServiceServerMockDeleteTableExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListApps.expectations = append(mmListApps.expectations, expectation) + mmDeleteTable.expectations = append(mmDeleteTable.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListApps return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListAppsExpectation) Then(lp2 *mm_appv1alpha.ListAppsResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListAppsResults{lp2, err} +// Then sets up AppPublicServiceServer.DeleteTable return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockDeleteTableExpectation) Then(dp2 *mm_appv1alpha.DeleteTableResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockDeleteTableResults{dp2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListApps should be invoked -func (mmListApps *mAppPublicServiceServerMockListApps) Times(n uint64) *mAppPublicServiceServerMockListApps { +// Times sets number of times AppPublicServiceServer.DeleteTable should be invoked +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Times(n uint64) *mAppPublicServiceServerMockDeleteTable { if n == 0 { - mmListApps.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListApps mock can not be zero") + mmDeleteTable.mock.t.Fatalf("Times of AppPublicServiceServerMock.DeleteTable mock can not be zero") } - mm_atomic.StoreUint64(&mmListApps.expectedInvocations, n) - mmListApps.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListApps + mm_atomic.StoreUint64(&mmDeleteTable.expectedInvocations, n) + mmDeleteTable.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteTable } -func (mmListApps *mAppPublicServiceServerMockListApps) invocationsDone() bool { - if len(mmListApps.expectations) == 0 && mmListApps.defaultExpectation == nil && mmListApps.mock.funcListApps == nil { +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) invocationsDone() bool { + if len(mmDeleteTable.expectations) == 0 && mmDeleteTable.defaultExpectation == nil && mmDeleteTable.mock.funcDeleteTable == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListApps.mock.afterListAppsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListApps.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteTable.mock.afterDeleteTableCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteTable.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListApps implements mm_appv1alpha.AppPublicServiceServer -func (mmListApps *AppPublicServiceServerMock) ListApps(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) (lp2 *mm_appv1alpha.ListAppsResponse, err error) { - mm_atomic.AddUint64(&mmListApps.beforeListAppsCounter, 1) - defer mm_atomic.AddUint64(&mmListApps.afterListAppsCounter, 1) +// DeleteTable implements mm_appv1alpha.AppPublicServiceServer +func (mmDeleteTable *AppPublicServiceServerMock) DeleteTable(ctx context.Context, dp1 *mm_appv1alpha.DeleteTableRequest) (dp2 *mm_appv1alpha.DeleteTableResponse, err error) { + mm_atomic.AddUint64(&mmDeleteTable.beforeDeleteTableCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteTable.afterDeleteTableCounter, 1) - mmListApps.t.Helper() + mmDeleteTable.t.Helper() - if mmListApps.inspectFuncListApps != nil { - mmListApps.inspectFuncListApps(ctx, lp1) + if mmDeleteTable.inspectFuncDeleteTable != nil { + mmDeleteTable.inspectFuncDeleteTable(ctx, dp1) } - mm_params := AppPublicServiceServerMockListAppsParams{ctx, lp1} + mm_params := AppPublicServiceServerMockDeleteTableParams{ctx, dp1} // Record call args - mmListApps.ListAppsMock.mutex.Lock() - mmListApps.ListAppsMock.callArgs = append(mmListApps.ListAppsMock.callArgs, &mm_params) - mmListApps.ListAppsMock.mutex.Unlock() + mmDeleteTable.DeleteTableMock.mutex.Lock() + mmDeleteTable.DeleteTableMock.callArgs = append(mmDeleteTable.DeleteTableMock.callArgs, &mm_params) + mmDeleteTable.DeleteTableMock.mutex.Unlock() - for _, e := range mmListApps.ListAppsMock.expectations { + for _, e := range mmDeleteTable.DeleteTableMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.dp2, e.results.err } } - if mmListApps.ListAppsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListApps.ListAppsMock.defaultExpectation.Counter, 1) - mm_want := mmListApps.ListAppsMock.defaultExpectation.params - mm_want_ptrs := mmListApps.ListAppsMock.defaultExpectation.paramPtrs + if mmDeleteTable.DeleteTableMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteTable.DeleteTableMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteTable.DeleteTableMock.defaultExpectation.params + mm_want_ptrs := mmDeleteTable.DeleteTableMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListAppsParams{ctx, lp1} + mm_got := AppPublicServiceServerMockDeleteTableParams{ctx, dp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListApps.t.Errorf("AppPublicServiceServerMock.ListApps got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListApps.ListAppsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteTable.t.Errorf("AppPublicServiceServerMock.DeleteTable got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteTable.DeleteTableMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListApps.t.Errorf("AppPublicServiceServerMock.ListApps got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListApps.ListAppsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.dp1 != nil && !minimock.Equal(*mm_want_ptrs.dp1, mm_got.dp1) { + mmDeleteTable.t.Errorf("AppPublicServiceServerMock.DeleteTable got unexpected parameter dp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteTable.DeleteTableMock.defaultExpectation.expectationOrigins.originDp1, *mm_want_ptrs.dp1, mm_got.dp1, minimock.Diff(*mm_want_ptrs.dp1, mm_got.dp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListApps.t.Errorf("AppPublicServiceServerMock.ListApps got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListApps.ListAppsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteTable.t.Errorf("AppPublicServiceServerMock.DeleteTable got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteTable.DeleteTableMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListApps.ListAppsMock.defaultExpectation.results + mm_results := mmDeleteTable.DeleteTableMock.defaultExpectation.results if mm_results == nil { - mmListApps.t.Fatal("No results are set for the AppPublicServiceServerMock.ListApps") + mmDeleteTable.t.Fatal("No results are set for the AppPublicServiceServerMock.DeleteTable") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).dp2, (*mm_results).err } - if mmListApps.funcListApps != nil { - return mmListApps.funcListApps(ctx, lp1) + if mmDeleteTable.funcDeleteTable != nil { + return mmDeleteTable.funcDeleteTable(ctx, dp1) } - mmListApps.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListApps. %v %v", ctx, lp1) + mmDeleteTable.t.Fatalf("Unexpected call to AppPublicServiceServerMock.DeleteTable. %v %v", ctx, dp1) return } -// ListAppsAfterCounter returns a count of finished AppPublicServiceServerMock.ListApps invocations -func (mmListApps *AppPublicServiceServerMock) ListAppsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListApps.afterListAppsCounter) +// DeleteTableAfterCounter returns a count of finished AppPublicServiceServerMock.DeleteTable invocations +func (mmDeleteTable *AppPublicServiceServerMock) DeleteTableAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteTable.afterDeleteTableCounter) } -// ListAppsBeforeCounter returns a count of AppPublicServiceServerMock.ListApps invocations -func (mmListApps *AppPublicServiceServerMock) ListAppsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListApps.beforeListAppsCounter) +// DeleteTableBeforeCounter returns a count of AppPublicServiceServerMock.DeleteTable invocations +func (mmDeleteTable *AppPublicServiceServerMock) DeleteTableBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteTable.beforeDeleteTableCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListApps. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.DeleteTable. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListApps *mAppPublicServiceServerMockListApps) Calls() []*AppPublicServiceServerMockListAppsParams { - mmListApps.mutex.RLock() +func (mmDeleteTable *mAppPublicServiceServerMockDeleteTable) Calls() []*AppPublicServiceServerMockDeleteTableParams { + mmDeleteTable.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListAppsParams, len(mmListApps.callArgs)) - copy(argCopy, mmListApps.callArgs) + argCopy := make([]*AppPublicServiceServerMockDeleteTableParams, len(mmDeleteTable.callArgs)) + copy(argCopy, mmDeleteTable.callArgs) - mmListApps.mutex.RUnlock() + mmDeleteTable.mutex.RUnlock() return argCopy } -// MinimockListAppsDone returns true if the count of the ListApps invocations corresponds +// MinimockDeleteTableDone returns true if the count of the DeleteTable invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListAppsDone() bool { - if m.ListAppsMock.optional { +func (m *AppPublicServiceServerMock) MinimockDeleteTableDone() bool { + if m.DeleteTableMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListAppsMock.expectations { + for _, e := range m.DeleteTableMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListAppsMock.invocationsDone() + return m.DeleteTableMock.invocationsDone() } -// MinimockListAppsInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListAppsInspect() { - for _, e := range m.ListAppsMock.expectations { +// MinimockDeleteTableInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockDeleteTableInspect() { + for _, e := range m.DeleteTableMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteTable at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListAppsCounter := mm_atomic.LoadUint64(&m.afterListAppsCounter) + afterDeleteTableCounter := mm_atomic.LoadUint64(&m.afterDeleteTableCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListAppsMock.defaultExpectation != nil && afterListAppsCounter < 1 { - if m.ListAppsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s", m.ListAppsMock.defaultExpectation.returnOrigin) + if m.DeleteTableMock.defaultExpectation != nil && afterDeleteTableCounter < 1 { + if m.DeleteTableMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteTable at\n%s", m.DeleteTableMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s with params: %#v", m.ListAppsMock.defaultExpectation.expectationOrigins.origin, *m.ListAppsMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteTable at\n%s with params: %#v", m.DeleteTableMock.defaultExpectation.expectationOrigins.origin, *m.DeleteTableMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListApps != nil && afterListAppsCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s", m.funcListAppsOrigin) + if m.funcDeleteTable != nil && afterDeleteTableCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.DeleteTable at\n%s", m.funcDeleteTableOrigin) } - if !m.ListAppsMock.invocationsDone() && afterListAppsCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListApps at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListAppsMock.expectedInvocations), m.ListAppsMock.expectedInvocationsOrigin, afterListAppsCounter) + if !m.DeleteTableMock.invocationsDone() && afterDeleteTableCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.DeleteTable at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteTableMock.expectedInvocations), m.DeleteTableMock.expectedInvocationsOrigin, afterDeleteTableCounter) } } -type mAppPublicServiceServerMockListChatMessages struct { +type mAppPublicServiceServerMockExport struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListChatMessagesExpectation - expectations []*AppPublicServiceServerMockListChatMessagesExpectation + defaultExpectation *AppPublicServiceServerMockExportExpectation + expectations []*AppPublicServiceServerMockExportExpectation - callArgs []*AppPublicServiceServerMockListChatMessagesParams + callArgs []*AppPublicServiceServerMockExportParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListChatMessagesExpectation specifies expectation struct of the AppPublicServiceServer.ListChatMessages -type AppPublicServiceServerMockListChatMessagesExpectation struct { +// AppPublicServiceServerMockExportExpectation specifies expectation struct of the AppPublicServiceServer.Export +type AppPublicServiceServerMockExportExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListChatMessagesParams - paramPtrs *AppPublicServiceServerMockListChatMessagesParamPtrs - expectationOrigins AppPublicServiceServerMockListChatMessagesExpectationOrigins - results *AppPublicServiceServerMockListChatMessagesResults + params *AppPublicServiceServerMockExportParams + paramPtrs *AppPublicServiceServerMockExportParamPtrs + expectationOrigins AppPublicServiceServerMockExportExpectationOrigins + results *AppPublicServiceServerMockExportResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListChatMessagesParams contains parameters of the AppPublicServiceServer.ListChatMessages -type AppPublicServiceServerMockListChatMessagesParams struct { +// AppPublicServiceServerMockExportParams contains parameters of the AppPublicServiceServer.Export +type AppPublicServiceServerMockExportParams struct { ctx context.Context - lp1 *mm_appv1alpha.ListChatMessagesRequest + ep1 *mm_appv1alpha.ExportRequest } -// AppPublicServiceServerMockListChatMessagesParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListChatMessages -type AppPublicServiceServerMockListChatMessagesParamPtrs struct { +// AppPublicServiceServerMockExportParamPtrs contains pointers to parameters of the AppPublicServiceServer.Export +type AppPublicServiceServerMockExportParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.ListChatMessagesRequest + ep1 **mm_appv1alpha.ExportRequest } -// AppPublicServiceServerMockListChatMessagesResults contains results of the AppPublicServiceServer.ListChatMessages -type AppPublicServiceServerMockListChatMessagesResults struct { - lp2 *mm_appv1alpha.ListChatMessagesResponse +// AppPublicServiceServerMockExportResults contains results of the AppPublicServiceServer.Export +type AppPublicServiceServerMockExportResults struct { + ep2 *mm_appv1alpha.ExportResponse err error } -// AppPublicServiceServerMockListChatMessagesOrigins contains origins of expectations of the AppPublicServiceServer.ListChatMessages -type AppPublicServiceServerMockListChatMessagesExpectationOrigins struct { +// AppPublicServiceServerMockExportOrigins contains origins of expectations of the AppPublicServiceServer.Export +type AppPublicServiceServerMockExportExpectationOrigins struct { origin string originCtx string - originLp1 string + originEp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -5157,342 +5660,342 @@ type AppPublicServiceServerMockListChatMessagesExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Optional() *mAppPublicServiceServerMockListChatMessages { - mmListChatMessages.optional = true - return mmListChatMessages +func (mmExport *mAppPublicServiceServerMockExport) Optional() *mAppPublicServiceServerMockExport { + mmExport.optional = true + return mmExport } -// Expect sets up expected params for AppPublicServiceServer.ListChatMessages -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) *mAppPublicServiceServerMockListChatMessages { - if mmListChatMessages.mock.funcListChatMessages != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.Export +func (mmExport *mAppPublicServiceServerMockExport) Expect(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest) *mAppPublicServiceServerMockExport { + if mmExport.mock.funcExport != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Set") } - if mmListChatMessages.defaultExpectation == nil { - mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{} + if mmExport.defaultExpectation == nil { + mmExport.defaultExpectation = &AppPublicServiceServerMockExportExpectation{} } - if mmListChatMessages.defaultExpectation.paramPtrs != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by ExpectParams functions") + if mmExport.defaultExpectation.paramPtrs != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by ExpectParams functions") } - mmListChatMessages.defaultExpectation.params = &AppPublicServiceServerMockListChatMessagesParams{ctx, lp1} - mmListChatMessages.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListChatMessages.expectations { - if minimock.Equal(e.params, mmListChatMessages.defaultExpectation.params) { - mmListChatMessages.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListChatMessages.defaultExpectation.params) + mmExport.defaultExpectation.params = &AppPublicServiceServerMockExportParams{ctx, ep1} + mmExport.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmExport.expectations { + if minimock.Equal(e.params, mmExport.defaultExpectation.params) { + mmExport.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmExport.defaultExpectation.params) } } - return mmListChatMessages + return mmExport } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListChatMessages -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListChatMessages { - if mmListChatMessages.mock.funcListChatMessages != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.Export +func (mmExport *mAppPublicServiceServerMockExport) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockExport { + if mmExport.mock.funcExport != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Set") } - if mmListChatMessages.defaultExpectation == nil { - mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{} + if mmExport.defaultExpectation == nil { + mmExport.defaultExpectation = &AppPublicServiceServerMockExportExpectation{} } - if mmListChatMessages.defaultExpectation.params != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Expect") + if mmExport.defaultExpectation.params != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Expect") } - if mmListChatMessages.defaultExpectation.paramPtrs == nil { - mmListChatMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatMessagesParamPtrs{} + if mmExport.defaultExpectation.paramPtrs == nil { + mmExport.defaultExpectation.paramPtrs = &AppPublicServiceServerMockExportParamPtrs{} } - mmListChatMessages.defaultExpectation.paramPtrs.ctx = &ctx - mmListChatMessages.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmExport.defaultExpectation.paramPtrs.ctx = &ctx + mmExport.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmListChatMessages + return mmExport } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListChatMessages -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) ExpectLp1Param2(lp1 *mm_appv1alpha.ListChatMessagesRequest) *mAppPublicServiceServerMockListChatMessages { - if mmListChatMessages.mock.funcListChatMessages != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") +// ExpectEp1Param2 sets up expected param ep1 for AppPublicServiceServer.Export +func (mmExport *mAppPublicServiceServerMockExport) ExpectEp1Param2(ep1 *mm_appv1alpha.ExportRequest) *mAppPublicServiceServerMockExport { + if mmExport.mock.funcExport != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Set") } - if mmListChatMessages.defaultExpectation == nil { - mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{} + if mmExport.defaultExpectation == nil { + mmExport.defaultExpectation = &AppPublicServiceServerMockExportExpectation{} } - if mmListChatMessages.defaultExpectation.params != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Expect") + if mmExport.defaultExpectation.params != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Expect") } - if mmListChatMessages.defaultExpectation.paramPtrs == nil { - mmListChatMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatMessagesParamPtrs{} + if mmExport.defaultExpectation.paramPtrs == nil { + mmExport.defaultExpectation.paramPtrs = &AppPublicServiceServerMockExportParamPtrs{} } - mmListChatMessages.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListChatMessages.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmExport.defaultExpectation.paramPtrs.ep1 = &ep1 + mmExport.defaultExpectation.expectationOrigins.originEp1 = minimock.CallerInfo(1) - return mmListChatMessages + return mmExport } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListChatMessages -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest)) *mAppPublicServiceServerMockListChatMessages { - if mmListChatMessages.mock.inspectFuncListChatMessages != nil { - mmListChatMessages.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListChatMessages") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.Export +func (mmExport *mAppPublicServiceServerMockExport) Inspect(f func(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest)) *mAppPublicServiceServerMockExport { + if mmExport.mock.inspectFuncExport != nil { + mmExport.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.Export") } - mmListChatMessages.mock.inspectFuncListChatMessages = f + mmExport.mock.inspectFuncExport = f - return mmListChatMessages + return mmExport } -// Return sets up results that will be returned by AppPublicServiceServer.ListChatMessages -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Return(lp2 *mm_appv1alpha.ListChatMessagesResponse, err error) *AppPublicServiceServerMock { - if mmListChatMessages.mock.funcListChatMessages != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.Export +func (mmExport *mAppPublicServiceServerMockExport) Return(ep2 *mm_appv1alpha.ExportResponse, err error) *AppPublicServiceServerMock { + if mmExport.mock.funcExport != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Set") } - if mmListChatMessages.defaultExpectation == nil { - mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{mock: mmListChatMessages.mock} + if mmExport.defaultExpectation == nil { + mmExport.defaultExpectation = &AppPublicServiceServerMockExportExpectation{mock: mmExport.mock} } - mmListChatMessages.defaultExpectation.results = &AppPublicServiceServerMockListChatMessagesResults{lp2, err} - mmListChatMessages.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListChatMessages.mock + mmExport.defaultExpectation.results = &AppPublicServiceServerMockExportResults{ep2, err} + mmExport.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmExport.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListChatMessages method -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) (lp2 *mm_appv1alpha.ListChatMessagesResponse, err error)) *AppPublicServiceServerMock { - if mmListChatMessages.defaultExpectation != nil { - mmListChatMessages.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListChatMessages method") +// Set uses given function f to mock the AppPublicServiceServer.Export method +func (mmExport *mAppPublicServiceServerMockExport) Set(f func(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest) (ep2 *mm_appv1alpha.ExportResponse, err error)) *AppPublicServiceServerMock { + if mmExport.defaultExpectation != nil { + mmExport.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.Export method") } - if len(mmListChatMessages.expectations) > 0 { - mmListChatMessages.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListChatMessages method") + if len(mmExport.expectations) > 0 { + mmExport.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.Export method") } - mmListChatMessages.mock.funcListChatMessages = f - mmListChatMessages.mock.funcListChatMessagesOrigin = minimock.CallerInfo(1) - return mmListChatMessages.mock + mmExport.mock.funcExport = f + mmExport.mock.funcExportOrigin = minimock.CallerInfo(1) + return mmExport.mock } -// When sets expectation for the AppPublicServiceServer.ListChatMessages which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.Export which will trigger the result defined by the following // Then helper -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) When(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) *AppPublicServiceServerMockListChatMessagesExpectation { - if mmListChatMessages.mock.funcListChatMessages != nil { - mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") +func (mmExport *mAppPublicServiceServerMockExport) When(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest) *AppPublicServiceServerMockExportExpectation { + if mmExport.mock.funcExport != nil { + mmExport.mock.t.Fatalf("AppPublicServiceServerMock.Export mock is already set by Set") } - expectation := &AppPublicServiceServerMockListChatMessagesExpectation{ - mock: mmListChatMessages.mock, - params: &AppPublicServiceServerMockListChatMessagesParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListChatMessagesExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockExportExpectation{ + mock: mmExport.mock, + params: &AppPublicServiceServerMockExportParams{ctx, ep1}, + expectationOrigins: AppPublicServiceServerMockExportExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListChatMessages.expectations = append(mmListChatMessages.expectations, expectation) + mmExport.expectations = append(mmExport.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListChatMessages return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListChatMessagesExpectation) Then(lp2 *mm_appv1alpha.ListChatMessagesResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListChatMessagesResults{lp2, err} +// Then sets up AppPublicServiceServer.Export return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockExportExpectation) Then(ep2 *mm_appv1alpha.ExportResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockExportResults{ep2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListChatMessages should be invoked -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Times(n uint64) *mAppPublicServiceServerMockListChatMessages { +// Times sets number of times AppPublicServiceServer.Export should be invoked +func (mmExport *mAppPublicServiceServerMockExport) Times(n uint64) *mAppPublicServiceServerMockExport { if n == 0 { - mmListChatMessages.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListChatMessages mock can not be zero") + mmExport.mock.t.Fatalf("Times of AppPublicServiceServerMock.Export mock can not be zero") } - mm_atomic.StoreUint64(&mmListChatMessages.expectedInvocations, n) - mmListChatMessages.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListChatMessages + mm_atomic.StoreUint64(&mmExport.expectedInvocations, n) + mmExport.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmExport } -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) invocationsDone() bool { - if len(mmListChatMessages.expectations) == 0 && mmListChatMessages.defaultExpectation == nil && mmListChatMessages.mock.funcListChatMessages == nil { +func (mmExport *mAppPublicServiceServerMockExport) invocationsDone() bool { + if len(mmExport.expectations) == 0 && mmExport.defaultExpectation == nil && mmExport.mock.funcExport == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListChatMessages.mock.afterListChatMessagesCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListChatMessages.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmExport.mock.afterExportCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmExport.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListChatMessages implements mm_appv1alpha.AppPublicServiceServer -func (mmListChatMessages *AppPublicServiceServerMock) ListChatMessages(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) (lp2 *mm_appv1alpha.ListChatMessagesResponse, err error) { - mm_atomic.AddUint64(&mmListChatMessages.beforeListChatMessagesCounter, 1) - defer mm_atomic.AddUint64(&mmListChatMessages.afterListChatMessagesCounter, 1) +// Export implements mm_appv1alpha.AppPublicServiceServer +func (mmExport *AppPublicServiceServerMock) Export(ctx context.Context, ep1 *mm_appv1alpha.ExportRequest) (ep2 *mm_appv1alpha.ExportResponse, err error) { + mm_atomic.AddUint64(&mmExport.beforeExportCounter, 1) + defer mm_atomic.AddUint64(&mmExport.afterExportCounter, 1) - mmListChatMessages.t.Helper() + mmExport.t.Helper() - if mmListChatMessages.inspectFuncListChatMessages != nil { - mmListChatMessages.inspectFuncListChatMessages(ctx, lp1) + if mmExport.inspectFuncExport != nil { + mmExport.inspectFuncExport(ctx, ep1) } - mm_params := AppPublicServiceServerMockListChatMessagesParams{ctx, lp1} + mm_params := AppPublicServiceServerMockExportParams{ctx, ep1} // Record call args - mmListChatMessages.ListChatMessagesMock.mutex.Lock() - mmListChatMessages.ListChatMessagesMock.callArgs = append(mmListChatMessages.ListChatMessagesMock.callArgs, &mm_params) - mmListChatMessages.ListChatMessagesMock.mutex.Unlock() + mmExport.ExportMock.mutex.Lock() + mmExport.ExportMock.callArgs = append(mmExport.ExportMock.callArgs, &mm_params) + mmExport.ExportMock.mutex.Unlock() - for _, e := range mmListChatMessages.ListChatMessagesMock.expectations { + for _, e := range mmExport.ExportMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.ep2, e.results.err } } - if mmListChatMessages.ListChatMessagesMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListChatMessages.ListChatMessagesMock.defaultExpectation.Counter, 1) - mm_want := mmListChatMessages.ListChatMessagesMock.defaultExpectation.params - mm_want_ptrs := mmListChatMessages.ListChatMessagesMock.defaultExpectation.paramPtrs + if mmExport.ExportMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmExport.ExportMock.defaultExpectation.Counter, 1) + mm_want := mmExport.ExportMock.defaultExpectation.params + mm_want_ptrs := mmExport.ExportMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListChatMessagesParams{ctx, lp1} + mm_got := AppPublicServiceServerMockExportParams{ctx, ep1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListChatMessages.t.Errorf("AppPublicServiceServerMock.ListChatMessages got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListChatMessages.ListChatMessagesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmExport.t.Errorf("AppPublicServiceServerMock.Export got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmExport.ExportMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListChatMessages.t.Errorf("AppPublicServiceServerMock.ListChatMessages got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListChatMessages.ListChatMessagesMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.ep1 != nil && !minimock.Equal(*mm_want_ptrs.ep1, mm_got.ep1) { + mmExport.t.Errorf("AppPublicServiceServerMock.Export got unexpected parameter ep1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmExport.ExportMock.defaultExpectation.expectationOrigins.originEp1, *mm_want_ptrs.ep1, mm_got.ep1, minimock.Diff(*mm_want_ptrs.ep1, mm_got.ep1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListChatMessages.t.Errorf("AppPublicServiceServerMock.ListChatMessages got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListChatMessages.ListChatMessagesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmExport.t.Errorf("AppPublicServiceServerMock.Export got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmExport.ExportMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListChatMessages.ListChatMessagesMock.defaultExpectation.results + mm_results := mmExport.ExportMock.defaultExpectation.results if mm_results == nil { - mmListChatMessages.t.Fatal("No results are set for the AppPublicServiceServerMock.ListChatMessages") + mmExport.t.Fatal("No results are set for the AppPublicServiceServerMock.Export") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).ep2, (*mm_results).err } - if mmListChatMessages.funcListChatMessages != nil { - return mmListChatMessages.funcListChatMessages(ctx, lp1) + if mmExport.funcExport != nil { + return mmExport.funcExport(ctx, ep1) } - mmListChatMessages.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListChatMessages. %v %v", ctx, lp1) + mmExport.t.Fatalf("Unexpected call to AppPublicServiceServerMock.Export. %v %v", ctx, ep1) return } -// ListChatMessagesAfterCounter returns a count of finished AppPublicServiceServerMock.ListChatMessages invocations -func (mmListChatMessages *AppPublicServiceServerMock) ListChatMessagesAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListChatMessages.afterListChatMessagesCounter) +// ExportAfterCounter returns a count of finished AppPublicServiceServerMock.Export invocations +func (mmExport *AppPublicServiceServerMock) ExportAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmExport.afterExportCounter) } -// ListChatMessagesBeforeCounter returns a count of AppPublicServiceServerMock.ListChatMessages invocations -func (mmListChatMessages *AppPublicServiceServerMock) ListChatMessagesBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListChatMessages.beforeListChatMessagesCounter) +// ExportBeforeCounter returns a count of AppPublicServiceServerMock.Export invocations +func (mmExport *AppPublicServiceServerMock) ExportBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmExport.beforeExportCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListChatMessages. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.Export. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Calls() []*AppPublicServiceServerMockListChatMessagesParams { - mmListChatMessages.mutex.RLock() +func (mmExport *mAppPublicServiceServerMockExport) Calls() []*AppPublicServiceServerMockExportParams { + mmExport.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListChatMessagesParams, len(mmListChatMessages.callArgs)) - copy(argCopy, mmListChatMessages.callArgs) + argCopy := make([]*AppPublicServiceServerMockExportParams, len(mmExport.callArgs)) + copy(argCopy, mmExport.callArgs) - mmListChatMessages.mutex.RUnlock() + mmExport.mutex.RUnlock() return argCopy } -// MinimockListChatMessagesDone returns true if the count of the ListChatMessages invocations corresponds +// MinimockExportDone returns true if the count of the Export invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListChatMessagesDone() bool { - if m.ListChatMessagesMock.optional { +func (m *AppPublicServiceServerMock) MinimockExportDone() bool { + if m.ExportMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListChatMessagesMock.expectations { + for _, e := range m.ExportMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListChatMessagesMock.invocationsDone() + return m.ExportMock.invocationsDone() } -// MinimockListChatMessagesInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListChatMessagesInspect() { - for _, e := range m.ListChatMessagesMock.expectations { +// MinimockExportInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockExportInspect() { + for _, e := range m.ExportMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.Export at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListChatMessagesCounter := mm_atomic.LoadUint64(&m.afterListChatMessagesCounter) + afterExportCounter := mm_atomic.LoadUint64(&m.afterExportCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListChatMessagesMock.defaultExpectation != nil && afterListChatMessagesCounter < 1 { - if m.ListChatMessagesMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s", m.ListChatMessagesMock.defaultExpectation.returnOrigin) + if m.ExportMock.defaultExpectation != nil && afterExportCounter < 1 { + if m.ExportMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Export at\n%s", m.ExportMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s with params: %#v", m.ListChatMessagesMock.defaultExpectation.expectationOrigins.origin, *m.ListChatMessagesMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.Export at\n%s with params: %#v", m.ExportMock.defaultExpectation.expectationOrigins.origin, *m.ExportMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListChatMessages != nil && afterListChatMessagesCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s", m.funcListChatMessagesOrigin) + if m.funcExport != nil && afterExportCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Export at\n%s", m.funcExportOrigin) } - if !m.ListChatMessagesMock.invocationsDone() && afterListChatMessagesCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListChatMessages at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListChatMessagesMock.expectedInvocations), m.ListChatMessagesMock.expectedInvocationsOrigin, afterListChatMessagesCounter) + if !m.ExportMock.invocationsDone() && afterExportCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.Export at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ExportMock.expectedInvocations), m.ExportMock.expectedInvocationsOrigin, afterExportCounter) } } -type mAppPublicServiceServerMockListChats struct { +type mAppPublicServiceServerMockGetColumnDefinitions struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListChatsExpectation - expectations []*AppPublicServiceServerMockListChatsExpectation + defaultExpectation *AppPublicServiceServerMockGetColumnDefinitionsExpectation + expectations []*AppPublicServiceServerMockGetColumnDefinitionsExpectation - callArgs []*AppPublicServiceServerMockListChatsParams + callArgs []*AppPublicServiceServerMockGetColumnDefinitionsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListChatsExpectation specifies expectation struct of the AppPublicServiceServer.ListChats -type AppPublicServiceServerMockListChatsExpectation struct { +// AppPublicServiceServerMockGetColumnDefinitionsExpectation specifies expectation struct of the AppPublicServiceServer.GetColumnDefinitions +type AppPublicServiceServerMockGetColumnDefinitionsExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListChatsParams - paramPtrs *AppPublicServiceServerMockListChatsParamPtrs - expectationOrigins AppPublicServiceServerMockListChatsExpectationOrigins - results *AppPublicServiceServerMockListChatsResults + params *AppPublicServiceServerMockGetColumnDefinitionsParams + paramPtrs *AppPublicServiceServerMockGetColumnDefinitionsParamPtrs + expectationOrigins AppPublicServiceServerMockGetColumnDefinitionsExpectationOrigins + results *AppPublicServiceServerMockGetColumnDefinitionsResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListChatsParams contains parameters of the AppPublicServiceServer.ListChats -type AppPublicServiceServerMockListChatsParams struct { +// AppPublicServiceServerMockGetColumnDefinitionsParams contains parameters of the AppPublicServiceServer.GetColumnDefinitions +type AppPublicServiceServerMockGetColumnDefinitionsParams struct { ctx context.Context - lp1 *mm_appv1alpha.ListChatsRequest + gp1 *mm_appv1alpha.GetColumnDefinitionsRequest } -// AppPublicServiceServerMockListChatsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListChats -type AppPublicServiceServerMockListChatsParamPtrs struct { +// AppPublicServiceServerMockGetColumnDefinitionsParamPtrs contains pointers to parameters of the AppPublicServiceServer.GetColumnDefinitions +type AppPublicServiceServerMockGetColumnDefinitionsParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.ListChatsRequest + gp1 **mm_appv1alpha.GetColumnDefinitionsRequest } -// AppPublicServiceServerMockListChatsResults contains results of the AppPublicServiceServer.ListChats -type AppPublicServiceServerMockListChatsResults struct { - lp2 *mm_appv1alpha.ListChatsResponse +// AppPublicServiceServerMockGetColumnDefinitionsResults contains results of the AppPublicServiceServer.GetColumnDefinitions +type AppPublicServiceServerMockGetColumnDefinitionsResults struct { + gp2 *mm_appv1alpha.GetColumnDefinitionsResponse err error } -// AppPublicServiceServerMockListChatsOrigins contains origins of expectations of the AppPublicServiceServer.ListChats -type AppPublicServiceServerMockListChatsExpectationOrigins struct { +// AppPublicServiceServerMockGetColumnDefinitionsOrigins contains origins of expectations of the AppPublicServiceServer.GetColumnDefinitions +type AppPublicServiceServerMockGetColumnDefinitionsExpectationOrigins struct { origin string originCtx string - originLp1 string + originGp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -5500,342 +6003,342 @@ type AppPublicServiceServerMockListChatsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListChats *mAppPublicServiceServerMockListChats) Optional() *mAppPublicServiceServerMockListChats { - mmListChats.optional = true - return mmListChats +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Optional() *mAppPublicServiceServerMockGetColumnDefinitions { + mmGetColumnDefinitions.optional = true + return mmGetColumnDefinitions } -// Expect sets up expected params for AppPublicServiceServer.ListChats -func (mmListChats *mAppPublicServiceServerMockListChats) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) *mAppPublicServiceServerMockListChats { - if mmListChats.mock.funcListChats != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.GetColumnDefinitions +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Expect(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) *mAppPublicServiceServerMockGetColumnDefinitions { + if mmGetColumnDefinitions.mock.funcGetColumnDefinitions != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Set") } - if mmListChats.defaultExpectation == nil { - mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{} + if mmGetColumnDefinitions.defaultExpectation == nil { + mmGetColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockGetColumnDefinitionsExpectation{} } - if mmListChats.defaultExpectation.paramPtrs != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by ExpectParams functions") + if mmGetColumnDefinitions.defaultExpectation.paramPtrs != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by ExpectParams functions") } - mmListChats.defaultExpectation.params = &AppPublicServiceServerMockListChatsParams{ctx, lp1} - mmListChats.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListChats.expectations { - if minimock.Equal(e.params, mmListChats.defaultExpectation.params) { - mmListChats.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListChats.defaultExpectation.params) + mmGetColumnDefinitions.defaultExpectation.params = &AppPublicServiceServerMockGetColumnDefinitionsParams{ctx, gp1} + mmGetColumnDefinitions.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetColumnDefinitions.expectations { + if minimock.Equal(e.params, mmGetColumnDefinitions.defaultExpectation.params) { + mmGetColumnDefinitions.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetColumnDefinitions.defaultExpectation.params) } } - return mmListChats + return mmGetColumnDefinitions } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListChats -func (mmListChats *mAppPublicServiceServerMockListChats) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListChats { - if mmListChats.mock.funcListChats != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.GetColumnDefinitions +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockGetColumnDefinitions { + if mmGetColumnDefinitions.mock.funcGetColumnDefinitions != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Set") } - if mmListChats.defaultExpectation == nil { - mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{} + if mmGetColumnDefinitions.defaultExpectation == nil { + mmGetColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockGetColumnDefinitionsExpectation{} } - if mmListChats.defaultExpectation.params != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Expect") + if mmGetColumnDefinitions.defaultExpectation.params != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Expect") } - if mmListChats.defaultExpectation.paramPtrs == nil { - mmListChats.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatsParamPtrs{} + if mmGetColumnDefinitions.defaultExpectation.paramPtrs == nil { + mmGetColumnDefinitions.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetColumnDefinitionsParamPtrs{} } - mmListChats.defaultExpectation.paramPtrs.ctx = &ctx - mmListChats.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetColumnDefinitions.defaultExpectation.paramPtrs.ctx = &ctx + mmGetColumnDefinitions.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmListChats + return mmGetColumnDefinitions } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListChats -func (mmListChats *mAppPublicServiceServerMockListChats) ExpectLp1Param2(lp1 *mm_appv1alpha.ListChatsRequest) *mAppPublicServiceServerMockListChats { - if mmListChats.mock.funcListChats != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") +// ExpectGp1Param2 sets up expected param gp1 for AppPublicServiceServer.GetColumnDefinitions +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) ExpectGp1Param2(gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) *mAppPublicServiceServerMockGetColumnDefinitions { + if mmGetColumnDefinitions.mock.funcGetColumnDefinitions != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Set") } - if mmListChats.defaultExpectation == nil { - mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{} + if mmGetColumnDefinitions.defaultExpectation == nil { + mmGetColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockGetColumnDefinitionsExpectation{} } - if mmListChats.defaultExpectation.params != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Expect") + if mmGetColumnDefinitions.defaultExpectation.params != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Expect") } - if mmListChats.defaultExpectation.paramPtrs == nil { - mmListChats.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatsParamPtrs{} + if mmGetColumnDefinitions.defaultExpectation.paramPtrs == nil { + mmGetColumnDefinitions.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetColumnDefinitionsParamPtrs{} } - mmListChats.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListChats.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmGetColumnDefinitions.defaultExpectation.paramPtrs.gp1 = &gp1 + mmGetColumnDefinitions.defaultExpectation.expectationOrigins.originGp1 = minimock.CallerInfo(1) - return mmListChats + return mmGetColumnDefinitions } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListChats -func (mmListChats *mAppPublicServiceServerMockListChats) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest)) *mAppPublicServiceServerMockListChats { - if mmListChats.mock.inspectFuncListChats != nil { - mmListChats.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListChats") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.GetColumnDefinitions +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Inspect(f func(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest)) *mAppPublicServiceServerMockGetColumnDefinitions { + if mmGetColumnDefinitions.mock.inspectFuncGetColumnDefinitions != nil { + mmGetColumnDefinitions.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.GetColumnDefinitions") } - mmListChats.mock.inspectFuncListChats = f + mmGetColumnDefinitions.mock.inspectFuncGetColumnDefinitions = f - return mmListChats + return mmGetColumnDefinitions } -// Return sets up results that will be returned by AppPublicServiceServer.ListChats -func (mmListChats *mAppPublicServiceServerMockListChats) Return(lp2 *mm_appv1alpha.ListChatsResponse, err error) *AppPublicServiceServerMock { - if mmListChats.mock.funcListChats != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.GetColumnDefinitions +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Return(gp2 *mm_appv1alpha.GetColumnDefinitionsResponse, err error) *AppPublicServiceServerMock { + if mmGetColumnDefinitions.mock.funcGetColumnDefinitions != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Set") } - if mmListChats.defaultExpectation == nil { - mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{mock: mmListChats.mock} + if mmGetColumnDefinitions.defaultExpectation == nil { + mmGetColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockGetColumnDefinitionsExpectation{mock: mmGetColumnDefinitions.mock} } - mmListChats.defaultExpectation.results = &AppPublicServiceServerMockListChatsResults{lp2, err} - mmListChats.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListChats.mock + mmGetColumnDefinitions.defaultExpectation.results = &AppPublicServiceServerMockGetColumnDefinitionsResults{gp2, err} + mmGetColumnDefinitions.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetColumnDefinitions.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListChats method -func (mmListChats *mAppPublicServiceServerMockListChats) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) (lp2 *mm_appv1alpha.ListChatsResponse, err error)) *AppPublicServiceServerMock { - if mmListChats.defaultExpectation != nil { - mmListChats.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListChats method") +// Set uses given function f to mock the AppPublicServiceServer.GetColumnDefinitions method +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Set(f func(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) (gp2 *mm_appv1alpha.GetColumnDefinitionsResponse, err error)) *AppPublicServiceServerMock { + if mmGetColumnDefinitions.defaultExpectation != nil { + mmGetColumnDefinitions.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.GetColumnDefinitions method") } - if len(mmListChats.expectations) > 0 { - mmListChats.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListChats method") + if len(mmGetColumnDefinitions.expectations) > 0 { + mmGetColumnDefinitions.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.GetColumnDefinitions method") } - mmListChats.mock.funcListChats = f - mmListChats.mock.funcListChatsOrigin = minimock.CallerInfo(1) - return mmListChats.mock + mmGetColumnDefinitions.mock.funcGetColumnDefinitions = f + mmGetColumnDefinitions.mock.funcGetColumnDefinitionsOrigin = minimock.CallerInfo(1) + return mmGetColumnDefinitions.mock } -// When sets expectation for the AppPublicServiceServer.ListChats which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.GetColumnDefinitions which will trigger the result defined by the following // Then helper -func (mmListChats *mAppPublicServiceServerMockListChats) When(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) *AppPublicServiceServerMockListChatsExpectation { - if mmListChats.mock.funcListChats != nil { - mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) When(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) *AppPublicServiceServerMockGetColumnDefinitionsExpectation { + if mmGetColumnDefinitions.mock.funcGetColumnDefinitions != nil { + mmGetColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.GetColumnDefinitions mock is already set by Set") } - expectation := &AppPublicServiceServerMockListChatsExpectation{ - mock: mmListChats.mock, - params: &AppPublicServiceServerMockListChatsParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListChatsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockGetColumnDefinitionsExpectation{ + mock: mmGetColumnDefinitions.mock, + params: &AppPublicServiceServerMockGetColumnDefinitionsParams{ctx, gp1}, + expectationOrigins: AppPublicServiceServerMockGetColumnDefinitionsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListChats.expectations = append(mmListChats.expectations, expectation) + mmGetColumnDefinitions.expectations = append(mmGetColumnDefinitions.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListChats return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListChatsExpectation) Then(lp2 *mm_appv1alpha.ListChatsResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListChatsResults{lp2, err} +// Then sets up AppPublicServiceServer.GetColumnDefinitions return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockGetColumnDefinitionsExpectation) Then(gp2 *mm_appv1alpha.GetColumnDefinitionsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockGetColumnDefinitionsResults{gp2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListChats should be invoked -func (mmListChats *mAppPublicServiceServerMockListChats) Times(n uint64) *mAppPublicServiceServerMockListChats { +// Times sets number of times AppPublicServiceServer.GetColumnDefinitions should be invoked +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Times(n uint64) *mAppPublicServiceServerMockGetColumnDefinitions { if n == 0 { - mmListChats.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListChats mock can not be zero") + mmGetColumnDefinitions.mock.t.Fatalf("Times of AppPublicServiceServerMock.GetColumnDefinitions mock can not be zero") } - mm_atomic.StoreUint64(&mmListChats.expectedInvocations, n) - mmListChats.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListChats + mm_atomic.StoreUint64(&mmGetColumnDefinitions.expectedInvocations, n) + mmGetColumnDefinitions.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetColumnDefinitions } -func (mmListChats *mAppPublicServiceServerMockListChats) invocationsDone() bool { - if len(mmListChats.expectations) == 0 && mmListChats.defaultExpectation == nil && mmListChats.mock.funcListChats == nil { +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) invocationsDone() bool { + if len(mmGetColumnDefinitions.expectations) == 0 && mmGetColumnDefinitions.defaultExpectation == nil && mmGetColumnDefinitions.mock.funcGetColumnDefinitions == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListChats.mock.afterListChatsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListChats.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetColumnDefinitions.mock.afterGetColumnDefinitionsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetColumnDefinitions.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListChats implements mm_appv1alpha.AppPublicServiceServer -func (mmListChats *AppPublicServiceServerMock) ListChats(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) (lp2 *mm_appv1alpha.ListChatsResponse, err error) { - mm_atomic.AddUint64(&mmListChats.beforeListChatsCounter, 1) - defer mm_atomic.AddUint64(&mmListChats.afterListChatsCounter, 1) +// GetColumnDefinitions implements mm_appv1alpha.AppPublicServiceServer +func (mmGetColumnDefinitions *AppPublicServiceServerMock) GetColumnDefinitions(ctx context.Context, gp1 *mm_appv1alpha.GetColumnDefinitionsRequest) (gp2 *mm_appv1alpha.GetColumnDefinitionsResponse, err error) { + mm_atomic.AddUint64(&mmGetColumnDefinitions.beforeGetColumnDefinitionsCounter, 1) + defer mm_atomic.AddUint64(&mmGetColumnDefinitions.afterGetColumnDefinitionsCounter, 1) - mmListChats.t.Helper() + mmGetColumnDefinitions.t.Helper() - if mmListChats.inspectFuncListChats != nil { - mmListChats.inspectFuncListChats(ctx, lp1) + if mmGetColumnDefinitions.inspectFuncGetColumnDefinitions != nil { + mmGetColumnDefinitions.inspectFuncGetColumnDefinitions(ctx, gp1) } - mm_params := AppPublicServiceServerMockListChatsParams{ctx, lp1} + mm_params := AppPublicServiceServerMockGetColumnDefinitionsParams{ctx, gp1} // Record call args - mmListChats.ListChatsMock.mutex.Lock() - mmListChats.ListChatsMock.callArgs = append(mmListChats.ListChatsMock.callArgs, &mm_params) - mmListChats.ListChatsMock.mutex.Unlock() + mmGetColumnDefinitions.GetColumnDefinitionsMock.mutex.Lock() + mmGetColumnDefinitions.GetColumnDefinitionsMock.callArgs = append(mmGetColumnDefinitions.GetColumnDefinitionsMock.callArgs, &mm_params) + mmGetColumnDefinitions.GetColumnDefinitionsMock.mutex.Unlock() - for _, e := range mmListChats.ListChatsMock.expectations { + for _, e := range mmGetColumnDefinitions.GetColumnDefinitionsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.gp2, e.results.err } } - if mmListChats.ListChatsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListChats.ListChatsMock.defaultExpectation.Counter, 1) - mm_want := mmListChats.ListChatsMock.defaultExpectation.params - mm_want_ptrs := mmListChats.ListChatsMock.defaultExpectation.paramPtrs + if mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.Counter, 1) + mm_want := mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.params + mm_want_ptrs := mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListChatsParams{ctx, lp1} + mm_got := AppPublicServiceServerMockGetColumnDefinitionsParams{ctx, gp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListChats.t.Errorf("AppPublicServiceServerMock.ListChats got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListChats.ListChatsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetColumnDefinitions.t.Errorf("AppPublicServiceServerMock.GetColumnDefinitions got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListChats.t.Errorf("AppPublicServiceServerMock.ListChats got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListChats.ListChatsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.gp1 != nil && !minimock.Equal(*mm_want_ptrs.gp1, mm_got.gp1) { + mmGetColumnDefinitions.t.Errorf("AppPublicServiceServerMock.GetColumnDefinitions got unexpected parameter gp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.expectationOrigins.originGp1, *mm_want_ptrs.gp1, mm_got.gp1, minimock.Diff(*mm_want_ptrs.gp1, mm_got.gp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListChats.t.Errorf("AppPublicServiceServerMock.ListChats got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListChats.ListChatsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetColumnDefinitions.t.Errorf("AppPublicServiceServerMock.GetColumnDefinitions got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListChats.ListChatsMock.defaultExpectation.results + mm_results := mmGetColumnDefinitions.GetColumnDefinitionsMock.defaultExpectation.results if mm_results == nil { - mmListChats.t.Fatal("No results are set for the AppPublicServiceServerMock.ListChats") + mmGetColumnDefinitions.t.Fatal("No results are set for the AppPublicServiceServerMock.GetColumnDefinitions") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).gp2, (*mm_results).err } - if mmListChats.funcListChats != nil { - return mmListChats.funcListChats(ctx, lp1) + if mmGetColumnDefinitions.funcGetColumnDefinitions != nil { + return mmGetColumnDefinitions.funcGetColumnDefinitions(ctx, gp1) } - mmListChats.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListChats. %v %v", ctx, lp1) + mmGetColumnDefinitions.t.Fatalf("Unexpected call to AppPublicServiceServerMock.GetColumnDefinitions. %v %v", ctx, gp1) return } -// ListChatsAfterCounter returns a count of finished AppPublicServiceServerMock.ListChats invocations -func (mmListChats *AppPublicServiceServerMock) ListChatsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListChats.afterListChatsCounter) +// GetColumnDefinitionsAfterCounter returns a count of finished AppPublicServiceServerMock.GetColumnDefinitions invocations +func (mmGetColumnDefinitions *AppPublicServiceServerMock) GetColumnDefinitionsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetColumnDefinitions.afterGetColumnDefinitionsCounter) } -// ListChatsBeforeCounter returns a count of AppPublicServiceServerMock.ListChats invocations -func (mmListChats *AppPublicServiceServerMock) ListChatsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListChats.beforeListChatsCounter) +// GetColumnDefinitionsBeforeCounter returns a count of AppPublicServiceServerMock.GetColumnDefinitions invocations +func (mmGetColumnDefinitions *AppPublicServiceServerMock) GetColumnDefinitionsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetColumnDefinitions.beforeGetColumnDefinitionsCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListChats. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.GetColumnDefinitions. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListChats *mAppPublicServiceServerMockListChats) Calls() []*AppPublicServiceServerMockListChatsParams { - mmListChats.mutex.RLock() +func (mmGetColumnDefinitions *mAppPublicServiceServerMockGetColumnDefinitions) Calls() []*AppPublicServiceServerMockGetColumnDefinitionsParams { + mmGetColumnDefinitions.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListChatsParams, len(mmListChats.callArgs)) - copy(argCopy, mmListChats.callArgs) + argCopy := make([]*AppPublicServiceServerMockGetColumnDefinitionsParams, len(mmGetColumnDefinitions.callArgs)) + copy(argCopy, mmGetColumnDefinitions.callArgs) - mmListChats.mutex.RUnlock() + mmGetColumnDefinitions.mutex.RUnlock() return argCopy } -// MinimockListChatsDone returns true if the count of the ListChats invocations corresponds +// MinimockGetColumnDefinitionsDone returns true if the count of the GetColumnDefinitions invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListChatsDone() bool { - if m.ListChatsMock.optional { +func (m *AppPublicServiceServerMock) MinimockGetColumnDefinitionsDone() bool { + if m.GetColumnDefinitionsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListChatsMock.expectations { + for _, e := range m.GetColumnDefinitionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListChatsMock.invocationsDone() + return m.GetColumnDefinitionsMock.invocationsDone() } -// MinimockListChatsInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListChatsInspect() { - for _, e := range m.ListChatsMock.expectations { +// MinimockGetColumnDefinitionsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockGetColumnDefinitionsInspect() { + for _, e := range m.GetColumnDefinitionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetColumnDefinitions at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListChatsCounter := mm_atomic.LoadUint64(&m.afterListChatsCounter) + afterGetColumnDefinitionsCounter := mm_atomic.LoadUint64(&m.afterGetColumnDefinitionsCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListChatsMock.defaultExpectation != nil && afterListChatsCounter < 1 { - if m.ListChatsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s", m.ListChatsMock.defaultExpectation.returnOrigin) + if m.GetColumnDefinitionsMock.defaultExpectation != nil && afterGetColumnDefinitionsCounter < 1 { + if m.GetColumnDefinitionsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetColumnDefinitions at\n%s", m.GetColumnDefinitionsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s with params: %#v", m.ListChatsMock.defaultExpectation.expectationOrigins.origin, *m.ListChatsMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetColumnDefinitions at\n%s with params: %#v", m.GetColumnDefinitionsMock.defaultExpectation.expectationOrigins.origin, *m.GetColumnDefinitionsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListChats != nil && afterListChatsCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s", m.funcListChatsOrigin) + if m.funcGetColumnDefinitions != nil && afterGetColumnDefinitionsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetColumnDefinitions at\n%s", m.funcGetColumnDefinitionsOrigin) } - if !m.ListChatsMock.invocationsDone() && afterListChatsCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListChats at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListChatsMock.expectedInvocations), m.ListChatsMock.expectedInvocationsOrigin, afterListChatsCounter) + if !m.GetColumnDefinitionsMock.invocationsDone() && afterGetColumnDefinitionsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.GetColumnDefinitions at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetColumnDefinitionsMock.expectedInvocations), m.GetColumnDefinitionsMock.expectedInvocationsOrigin, afterGetColumnDefinitionsCounter) } } -type mAppPublicServiceServerMockListConversations struct { +type mAppPublicServiceServerMockGetPlaygroundConversation struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListConversationsExpectation - expectations []*AppPublicServiceServerMockListConversationsExpectation + defaultExpectation *AppPublicServiceServerMockGetPlaygroundConversationExpectation + expectations []*AppPublicServiceServerMockGetPlaygroundConversationExpectation - callArgs []*AppPublicServiceServerMockListConversationsParams + callArgs []*AppPublicServiceServerMockGetPlaygroundConversationParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListConversationsExpectation specifies expectation struct of the AppPublicServiceServer.ListConversations -type AppPublicServiceServerMockListConversationsExpectation struct { +// AppPublicServiceServerMockGetPlaygroundConversationExpectation specifies expectation struct of the AppPublicServiceServer.GetPlaygroundConversation +type AppPublicServiceServerMockGetPlaygroundConversationExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListConversationsParams - paramPtrs *AppPublicServiceServerMockListConversationsParamPtrs - expectationOrigins AppPublicServiceServerMockListConversationsExpectationOrigins - results *AppPublicServiceServerMockListConversationsResults + params *AppPublicServiceServerMockGetPlaygroundConversationParams + paramPtrs *AppPublicServiceServerMockGetPlaygroundConversationParamPtrs + expectationOrigins AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins + results *AppPublicServiceServerMockGetPlaygroundConversationResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListConversationsParams contains parameters of the AppPublicServiceServer.ListConversations -type AppPublicServiceServerMockListConversationsParams struct { +// AppPublicServiceServerMockGetPlaygroundConversationParams contains parameters of the AppPublicServiceServer.GetPlaygroundConversation +type AppPublicServiceServerMockGetPlaygroundConversationParams struct { ctx context.Context - lp1 *mm_appv1alpha.ListConversationsRequest + gp1 *mm_appv1alpha.GetPlaygroundConversationRequest } -// AppPublicServiceServerMockListConversationsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListConversations -type AppPublicServiceServerMockListConversationsParamPtrs struct { +// AppPublicServiceServerMockGetPlaygroundConversationParamPtrs contains pointers to parameters of the AppPublicServiceServer.GetPlaygroundConversation +type AppPublicServiceServerMockGetPlaygroundConversationParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.ListConversationsRequest + gp1 **mm_appv1alpha.GetPlaygroundConversationRequest } -// AppPublicServiceServerMockListConversationsResults contains results of the AppPublicServiceServer.ListConversations -type AppPublicServiceServerMockListConversationsResults struct { - lp2 *mm_appv1alpha.ListConversationsResponse +// AppPublicServiceServerMockGetPlaygroundConversationResults contains results of the AppPublicServiceServer.GetPlaygroundConversation +type AppPublicServiceServerMockGetPlaygroundConversationResults struct { + gp2 *mm_appv1alpha.GetPlaygroundConversationResponse err error } -// AppPublicServiceServerMockListConversationsOrigins contains origins of expectations of the AppPublicServiceServer.ListConversations -type AppPublicServiceServerMockListConversationsExpectationOrigins struct { +// AppPublicServiceServerMockGetPlaygroundConversationOrigins contains origins of expectations of the AppPublicServiceServer.GetPlaygroundConversation +type AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins struct { origin string originCtx string - originLp1 string + originGp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -5843,342 +6346,342 @@ type AppPublicServiceServerMockListConversationsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListConversations *mAppPublicServiceServerMockListConversations) Optional() *mAppPublicServiceServerMockListConversations { - mmListConversations.optional = true - return mmListConversations +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Optional() *mAppPublicServiceServerMockGetPlaygroundConversation { + mmGetPlaygroundConversation.optional = true + return mmGetPlaygroundConversation } -// Expect sets up expected params for AppPublicServiceServer.ListConversations -func (mmListConversations *mAppPublicServiceServerMockListConversations) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) *mAppPublicServiceServerMockListConversations { - if mmListConversations.mock.funcListConversations != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.GetPlaygroundConversation +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Expect(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) *mAppPublicServiceServerMockGetPlaygroundConversation { + if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") } - if mmListConversations.defaultExpectation == nil { - mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{} + if mmGetPlaygroundConversation.defaultExpectation == nil { + mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{} } - if mmListConversations.defaultExpectation.paramPtrs != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by ExpectParams functions") + if mmGetPlaygroundConversation.defaultExpectation.paramPtrs != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by ExpectParams functions") } - mmListConversations.defaultExpectation.params = &AppPublicServiceServerMockListConversationsParams{ctx, lp1} - mmListConversations.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListConversations.expectations { - if minimock.Equal(e.params, mmListConversations.defaultExpectation.params) { - mmListConversations.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListConversations.defaultExpectation.params) + mmGetPlaygroundConversation.defaultExpectation.params = &AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1} + mmGetPlaygroundConversation.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPlaygroundConversation.expectations { + if minimock.Equal(e.params, mmGetPlaygroundConversation.defaultExpectation.params) { + mmGetPlaygroundConversation.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPlaygroundConversation.defaultExpectation.params) } } - return mmListConversations + return mmGetPlaygroundConversation } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListConversations -func (mmListConversations *mAppPublicServiceServerMockListConversations) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListConversations { - if mmListConversations.mock.funcListConversations != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.GetPlaygroundConversation +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockGetPlaygroundConversation { + if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") } - if mmListConversations.defaultExpectation == nil { - mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{} + if mmGetPlaygroundConversation.defaultExpectation == nil { + mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{} } - if mmListConversations.defaultExpectation.params != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Expect") + if mmGetPlaygroundConversation.defaultExpectation.params != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Expect") } - if mmListConversations.defaultExpectation.paramPtrs == nil { - mmListConversations.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListConversationsParamPtrs{} + if mmGetPlaygroundConversation.defaultExpectation.paramPtrs == nil { + mmGetPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetPlaygroundConversationParamPtrs{} } - mmListConversations.defaultExpectation.paramPtrs.ctx = &ctx - mmListConversations.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetPlaygroundConversation.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPlaygroundConversation.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmListConversations + return mmGetPlaygroundConversation } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListConversations -func (mmListConversations *mAppPublicServiceServerMockListConversations) ExpectLp1Param2(lp1 *mm_appv1alpha.ListConversationsRequest) *mAppPublicServiceServerMockListConversations { - if mmListConversations.mock.funcListConversations != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") +// ExpectGp1Param2 sets up expected param gp1 for AppPublicServiceServer.GetPlaygroundConversation +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) ExpectGp1Param2(gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) *mAppPublicServiceServerMockGetPlaygroundConversation { + if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") } - if mmListConversations.defaultExpectation == nil { - mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{} + if mmGetPlaygroundConversation.defaultExpectation == nil { + mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{} } - if mmListConversations.defaultExpectation.params != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Expect") + if mmGetPlaygroundConversation.defaultExpectation.params != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Expect") } - if mmListConversations.defaultExpectation.paramPtrs == nil { - mmListConversations.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListConversationsParamPtrs{} + if mmGetPlaygroundConversation.defaultExpectation.paramPtrs == nil { + mmGetPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetPlaygroundConversationParamPtrs{} } - mmListConversations.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListConversations.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmGetPlaygroundConversation.defaultExpectation.paramPtrs.gp1 = &gp1 + mmGetPlaygroundConversation.defaultExpectation.expectationOrigins.originGp1 = minimock.CallerInfo(1) - return mmListConversations + return mmGetPlaygroundConversation } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListConversations -func (mmListConversations *mAppPublicServiceServerMockListConversations) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest)) *mAppPublicServiceServerMockListConversations { - if mmListConversations.mock.inspectFuncListConversations != nil { - mmListConversations.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListConversations") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.GetPlaygroundConversation +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Inspect(f func(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest)) *mAppPublicServiceServerMockGetPlaygroundConversation { + if mmGetPlaygroundConversation.mock.inspectFuncGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.GetPlaygroundConversation") } - mmListConversations.mock.inspectFuncListConversations = f + mmGetPlaygroundConversation.mock.inspectFuncGetPlaygroundConversation = f - return mmListConversations + return mmGetPlaygroundConversation } -// Return sets up results that will be returned by AppPublicServiceServer.ListConversations -func (mmListConversations *mAppPublicServiceServerMockListConversations) Return(lp2 *mm_appv1alpha.ListConversationsResponse, err error) *AppPublicServiceServerMock { - if mmListConversations.mock.funcListConversations != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.GetPlaygroundConversation +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Return(gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { + if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") } - if mmListConversations.defaultExpectation == nil { - mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{mock: mmListConversations.mock} + if mmGetPlaygroundConversation.defaultExpectation == nil { + mmGetPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockGetPlaygroundConversationExpectation{mock: mmGetPlaygroundConversation.mock} } - mmListConversations.defaultExpectation.results = &AppPublicServiceServerMockListConversationsResults{lp2, err} - mmListConversations.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListConversations.mock + mmGetPlaygroundConversation.defaultExpectation.results = &AppPublicServiceServerMockGetPlaygroundConversationResults{gp2, err} + mmGetPlaygroundConversation.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPlaygroundConversation.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListConversations method -func (mmListConversations *mAppPublicServiceServerMockListConversations) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) (lp2 *mm_appv1alpha.ListConversationsResponse, err error)) *AppPublicServiceServerMock { - if mmListConversations.defaultExpectation != nil { - mmListConversations.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListConversations method") +// Set uses given function f to mock the AppPublicServiceServer.GetPlaygroundConversation method +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Set(f func(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) (gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error)) *AppPublicServiceServerMock { + if mmGetPlaygroundConversation.defaultExpectation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.GetPlaygroundConversation method") } - if len(mmListConversations.expectations) > 0 { - mmListConversations.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListConversations method") + if len(mmGetPlaygroundConversation.expectations) > 0 { + mmGetPlaygroundConversation.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.GetPlaygroundConversation method") } - mmListConversations.mock.funcListConversations = f - mmListConversations.mock.funcListConversationsOrigin = minimock.CallerInfo(1) - return mmListConversations.mock + mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation = f + mmGetPlaygroundConversation.mock.funcGetPlaygroundConversationOrigin = minimock.CallerInfo(1) + return mmGetPlaygroundConversation.mock } -// When sets expectation for the AppPublicServiceServer.ListConversations which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.GetPlaygroundConversation which will trigger the result defined by the following // Then helper -func (mmListConversations *mAppPublicServiceServerMockListConversations) When(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) *AppPublicServiceServerMockListConversationsExpectation { - if mmListConversations.mock.funcListConversations != nil { - mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) When(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) *AppPublicServiceServerMockGetPlaygroundConversationExpectation { + if mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.GetPlaygroundConversation mock is already set by Set") } - expectation := &AppPublicServiceServerMockListConversationsExpectation{ - mock: mmListConversations.mock, - params: &AppPublicServiceServerMockListConversationsParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListConversationsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockGetPlaygroundConversationExpectation{ + mock: mmGetPlaygroundConversation.mock, + params: &AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1}, + expectationOrigins: AppPublicServiceServerMockGetPlaygroundConversationExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListConversations.expectations = append(mmListConversations.expectations, expectation) + mmGetPlaygroundConversation.expectations = append(mmGetPlaygroundConversation.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListConversations return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListConversationsExpectation) Then(lp2 *mm_appv1alpha.ListConversationsResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListConversationsResults{lp2, err} +// Then sets up AppPublicServiceServer.GetPlaygroundConversation return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockGetPlaygroundConversationExpectation) Then(gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockGetPlaygroundConversationResults{gp2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListConversations should be invoked -func (mmListConversations *mAppPublicServiceServerMockListConversations) Times(n uint64) *mAppPublicServiceServerMockListConversations { +// Times sets number of times AppPublicServiceServer.GetPlaygroundConversation should be invoked +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Times(n uint64) *mAppPublicServiceServerMockGetPlaygroundConversation { if n == 0 { - mmListConversations.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListConversations mock can not be zero") + mmGetPlaygroundConversation.mock.t.Fatalf("Times of AppPublicServiceServerMock.GetPlaygroundConversation mock can not be zero") } - mm_atomic.StoreUint64(&mmListConversations.expectedInvocations, n) - mmListConversations.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListConversations + mm_atomic.StoreUint64(&mmGetPlaygroundConversation.expectedInvocations, n) + mmGetPlaygroundConversation.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPlaygroundConversation } -func (mmListConversations *mAppPublicServiceServerMockListConversations) invocationsDone() bool { - if len(mmListConversations.expectations) == 0 && mmListConversations.defaultExpectation == nil && mmListConversations.mock.funcListConversations == nil { +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) invocationsDone() bool { + if len(mmGetPlaygroundConversation.expectations) == 0 && mmGetPlaygroundConversation.defaultExpectation == nil && mmGetPlaygroundConversation.mock.funcGetPlaygroundConversation == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListConversations.mock.afterListConversationsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListConversations.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPlaygroundConversation.mock.afterGetPlaygroundConversationCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPlaygroundConversation.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListConversations implements mm_appv1alpha.AppPublicServiceServer -func (mmListConversations *AppPublicServiceServerMock) ListConversations(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) (lp2 *mm_appv1alpha.ListConversationsResponse, err error) { - mm_atomic.AddUint64(&mmListConversations.beforeListConversationsCounter, 1) - defer mm_atomic.AddUint64(&mmListConversations.afterListConversationsCounter, 1) +// GetPlaygroundConversation implements mm_appv1alpha.AppPublicServiceServer +func (mmGetPlaygroundConversation *AppPublicServiceServerMock) GetPlaygroundConversation(ctx context.Context, gp1 *mm_appv1alpha.GetPlaygroundConversationRequest) (gp2 *mm_appv1alpha.GetPlaygroundConversationResponse, err error) { + mm_atomic.AddUint64(&mmGetPlaygroundConversation.beforeGetPlaygroundConversationCounter, 1) + defer mm_atomic.AddUint64(&mmGetPlaygroundConversation.afterGetPlaygroundConversationCounter, 1) - mmListConversations.t.Helper() + mmGetPlaygroundConversation.t.Helper() - if mmListConversations.inspectFuncListConversations != nil { - mmListConversations.inspectFuncListConversations(ctx, lp1) + if mmGetPlaygroundConversation.inspectFuncGetPlaygroundConversation != nil { + mmGetPlaygroundConversation.inspectFuncGetPlaygroundConversation(ctx, gp1) } - mm_params := AppPublicServiceServerMockListConversationsParams{ctx, lp1} + mm_params := AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1} // Record call args - mmListConversations.ListConversationsMock.mutex.Lock() - mmListConversations.ListConversationsMock.callArgs = append(mmListConversations.ListConversationsMock.callArgs, &mm_params) - mmListConversations.ListConversationsMock.mutex.Unlock() + mmGetPlaygroundConversation.GetPlaygroundConversationMock.mutex.Lock() + mmGetPlaygroundConversation.GetPlaygroundConversationMock.callArgs = append(mmGetPlaygroundConversation.GetPlaygroundConversationMock.callArgs, &mm_params) + mmGetPlaygroundConversation.GetPlaygroundConversationMock.mutex.Unlock() - for _, e := range mmListConversations.ListConversationsMock.expectations { + for _, e := range mmGetPlaygroundConversation.GetPlaygroundConversationMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.gp2, e.results.err } } - if mmListConversations.ListConversationsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListConversations.ListConversationsMock.defaultExpectation.Counter, 1) - mm_want := mmListConversations.ListConversationsMock.defaultExpectation.params - mm_want_ptrs := mmListConversations.ListConversationsMock.defaultExpectation.paramPtrs + if mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.Counter, 1) + mm_want := mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.params + mm_want_ptrs := mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListConversationsParams{ctx, lp1} + mm_got := AppPublicServiceServerMockGetPlaygroundConversationParams{ctx, gp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListConversations.t.Errorf("AppPublicServiceServerMock.ListConversations got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListConversations.ListConversationsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.GetPlaygroundConversation got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListConversations.t.Errorf("AppPublicServiceServerMock.ListConversations got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListConversations.ListConversationsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.gp1 != nil && !minimock.Equal(*mm_want_ptrs.gp1, mm_got.gp1) { + mmGetPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.GetPlaygroundConversation got unexpected parameter gp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.originGp1, *mm_want_ptrs.gp1, mm_got.gp1, minimock.Diff(*mm_want_ptrs.gp1, mm_got.gp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListConversations.t.Errorf("AppPublicServiceServerMock.ListConversations got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListConversations.ListConversationsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.GetPlaygroundConversation got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListConversations.ListConversationsMock.defaultExpectation.results + mm_results := mmGetPlaygroundConversation.GetPlaygroundConversationMock.defaultExpectation.results if mm_results == nil { - mmListConversations.t.Fatal("No results are set for the AppPublicServiceServerMock.ListConversations") + mmGetPlaygroundConversation.t.Fatal("No results are set for the AppPublicServiceServerMock.GetPlaygroundConversation") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).gp2, (*mm_results).err } - if mmListConversations.funcListConversations != nil { - return mmListConversations.funcListConversations(ctx, lp1) + if mmGetPlaygroundConversation.funcGetPlaygroundConversation != nil { + return mmGetPlaygroundConversation.funcGetPlaygroundConversation(ctx, gp1) } - mmListConversations.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListConversations. %v %v", ctx, lp1) + mmGetPlaygroundConversation.t.Fatalf("Unexpected call to AppPublicServiceServerMock.GetPlaygroundConversation. %v %v", ctx, gp1) return } -// ListConversationsAfterCounter returns a count of finished AppPublicServiceServerMock.ListConversations invocations -func (mmListConversations *AppPublicServiceServerMock) ListConversationsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListConversations.afterListConversationsCounter) +// GetPlaygroundConversationAfterCounter returns a count of finished AppPublicServiceServerMock.GetPlaygroundConversation invocations +func (mmGetPlaygroundConversation *AppPublicServiceServerMock) GetPlaygroundConversationAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPlaygroundConversation.afterGetPlaygroundConversationCounter) } -// ListConversationsBeforeCounter returns a count of AppPublicServiceServerMock.ListConversations invocations -func (mmListConversations *AppPublicServiceServerMock) ListConversationsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListConversations.beforeListConversationsCounter) +// GetPlaygroundConversationBeforeCounter returns a count of AppPublicServiceServerMock.GetPlaygroundConversation invocations +func (mmGetPlaygroundConversation *AppPublicServiceServerMock) GetPlaygroundConversationBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPlaygroundConversation.beforeGetPlaygroundConversationCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListConversations. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.GetPlaygroundConversation. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListConversations *mAppPublicServiceServerMockListConversations) Calls() []*AppPublicServiceServerMockListConversationsParams { - mmListConversations.mutex.RLock() +func (mmGetPlaygroundConversation *mAppPublicServiceServerMockGetPlaygroundConversation) Calls() []*AppPublicServiceServerMockGetPlaygroundConversationParams { + mmGetPlaygroundConversation.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListConversationsParams, len(mmListConversations.callArgs)) - copy(argCopy, mmListConversations.callArgs) + argCopy := make([]*AppPublicServiceServerMockGetPlaygroundConversationParams, len(mmGetPlaygroundConversation.callArgs)) + copy(argCopy, mmGetPlaygroundConversation.callArgs) - mmListConversations.mutex.RUnlock() + mmGetPlaygroundConversation.mutex.RUnlock() return argCopy } -// MinimockListConversationsDone returns true if the count of the ListConversations invocations corresponds +// MinimockGetPlaygroundConversationDone returns true if the count of the GetPlaygroundConversation invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListConversationsDone() bool { - if m.ListConversationsMock.optional { +func (m *AppPublicServiceServerMock) MinimockGetPlaygroundConversationDone() bool { + if m.GetPlaygroundConversationMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListConversationsMock.expectations { + for _, e := range m.GetPlaygroundConversationMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListConversationsMock.invocationsDone() + return m.GetPlaygroundConversationMock.invocationsDone() } -// MinimockListConversationsInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListConversationsInspect() { - for _, e := range m.ListConversationsMock.expectations { +// MinimockGetPlaygroundConversationInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockGetPlaygroundConversationInspect() { + for _, e := range m.GetPlaygroundConversationMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListConversationsCounter := mm_atomic.LoadUint64(&m.afterListConversationsCounter) + afterGetPlaygroundConversationCounter := mm_atomic.LoadUint64(&m.afterGetPlaygroundConversationCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListConversationsMock.defaultExpectation != nil && afterListConversationsCounter < 1 { - if m.ListConversationsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s", m.ListConversationsMock.defaultExpectation.returnOrigin) + if m.GetPlaygroundConversationMock.defaultExpectation != nil && afterGetPlaygroundConversationCounter < 1 { + if m.GetPlaygroundConversationMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s", m.GetPlaygroundConversationMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s with params: %#v", m.ListConversationsMock.defaultExpectation.expectationOrigins.origin, *m.ListConversationsMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s with params: %#v", m.GetPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *m.GetPlaygroundConversationMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListConversations != nil && afterListConversationsCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s", m.funcListConversationsOrigin) + if m.funcGetPlaygroundConversation != nil && afterGetPlaygroundConversationCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s", m.funcGetPlaygroundConversationOrigin) } - if !m.ListConversationsMock.invocationsDone() && afterListConversationsCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListConversations at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListConversationsMock.expectedInvocations), m.ListConversationsMock.expectedInvocationsOrigin, afterListConversationsCounter) + if !m.GetPlaygroundConversationMock.invocationsDone() && afterGetPlaygroundConversationCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.GetPlaygroundConversation at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPlaygroundConversationMock.expectedInvocations), m.GetPlaygroundConversationMock.expectedInvocationsOrigin, afterGetPlaygroundConversationCounter) } } -type mAppPublicServiceServerMockListMessages struct { +type mAppPublicServiceServerMockGetTable struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListMessagesExpectation - expectations []*AppPublicServiceServerMockListMessagesExpectation + defaultExpectation *AppPublicServiceServerMockGetTableExpectation + expectations []*AppPublicServiceServerMockGetTableExpectation - callArgs []*AppPublicServiceServerMockListMessagesParams + callArgs []*AppPublicServiceServerMockGetTableParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListMessagesExpectation specifies expectation struct of the AppPublicServiceServer.ListMessages -type AppPublicServiceServerMockListMessagesExpectation struct { +// AppPublicServiceServerMockGetTableExpectation specifies expectation struct of the AppPublicServiceServer.GetTable +type AppPublicServiceServerMockGetTableExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListMessagesParams - paramPtrs *AppPublicServiceServerMockListMessagesParamPtrs - expectationOrigins AppPublicServiceServerMockListMessagesExpectationOrigins - results *AppPublicServiceServerMockListMessagesResults + params *AppPublicServiceServerMockGetTableParams + paramPtrs *AppPublicServiceServerMockGetTableParamPtrs + expectationOrigins AppPublicServiceServerMockGetTableExpectationOrigins + results *AppPublicServiceServerMockGetTableResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListMessagesParams contains parameters of the AppPublicServiceServer.ListMessages -type AppPublicServiceServerMockListMessagesParams struct { +// AppPublicServiceServerMockGetTableParams contains parameters of the AppPublicServiceServer.GetTable +type AppPublicServiceServerMockGetTableParams struct { ctx context.Context - lp1 *mm_appv1alpha.ListMessagesRequest + gp1 *mm_appv1alpha.GetTableRequest } -// AppPublicServiceServerMockListMessagesParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListMessages -type AppPublicServiceServerMockListMessagesParamPtrs struct { +// AppPublicServiceServerMockGetTableParamPtrs contains pointers to parameters of the AppPublicServiceServer.GetTable +type AppPublicServiceServerMockGetTableParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.ListMessagesRequest + gp1 **mm_appv1alpha.GetTableRequest } -// AppPublicServiceServerMockListMessagesResults contains results of the AppPublicServiceServer.ListMessages -type AppPublicServiceServerMockListMessagesResults struct { - lp2 *mm_appv1alpha.ListMessagesResponse +// AppPublicServiceServerMockGetTableResults contains results of the AppPublicServiceServer.GetTable +type AppPublicServiceServerMockGetTableResults struct { + gp2 *mm_appv1alpha.GetTableResponse err error } -// AppPublicServiceServerMockListMessagesOrigins contains origins of expectations of the AppPublicServiceServer.ListMessages -type AppPublicServiceServerMockListMessagesExpectationOrigins struct { +// AppPublicServiceServerMockGetTableOrigins contains origins of expectations of the AppPublicServiceServer.GetTable +type AppPublicServiceServerMockGetTableExpectationOrigins struct { origin string originCtx string - originLp1 string + originGp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -6186,342 +6689,341 @@ type AppPublicServiceServerMockListMessagesExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListMessages *mAppPublicServiceServerMockListMessages) Optional() *mAppPublicServiceServerMockListMessages { - mmListMessages.optional = true - return mmListMessages +func (mmGetTable *mAppPublicServiceServerMockGetTable) Optional() *mAppPublicServiceServerMockGetTable { + mmGetTable.optional = true + return mmGetTable } -// Expect sets up expected params for AppPublicServiceServer.ListMessages -func (mmListMessages *mAppPublicServiceServerMockListMessages) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) *mAppPublicServiceServerMockListMessages { - if mmListMessages.mock.funcListMessages != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.GetTable +func (mmGetTable *mAppPublicServiceServerMockGetTable) Expect(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest) *mAppPublicServiceServerMockGetTable { + if mmGetTable.mock.funcGetTable != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Set") } - if mmListMessages.defaultExpectation == nil { - mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{} + if mmGetTable.defaultExpectation == nil { + mmGetTable.defaultExpectation = &AppPublicServiceServerMockGetTableExpectation{} } - if mmListMessages.defaultExpectation.paramPtrs != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by ExpectParams functions") + if mmGetTable.defaultExpectation.paramPtrs != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by ExpectParams functions") } - mmListMessages.defaultExpectation.params = &AppPublicServiceServerMockListMessagesParams{ctx, lp1} - mmListMessages.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListMessages.expectations { - if minimock.Equal(e.params, mmListMessages.defaultExpectation.params) { - mmListMessages.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListMessages.defaultExpectation.params) + mmGetTable.defaultExpectation.params = &AppPublicServiceServerMockGetTableParams{ctx, gp1} + mmGetTable.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetTable.expectations { + if minimock.Equal(e.params, mmGetTable.defaultExpectation.params) { + mmGetTable.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetTable.defaultExpectation.params) } } - return mmListMessages + return mmGetTable } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListMessages -func (mmListMessages *mAppPublicServiceServerMockListMessages) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListMessages { - if mmListMessages.mock.funcListMessages != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.GetTable +func (mmGetTable *mAppPublicServiceServerMockGetTable) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockGetTable { + if mmGetTable.mock.funcGetTable != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Set") } - if mmListMessages.defaultExpectation == nil { - mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{} + if mmGetTable.defaultExpectation == nil { + mmGetTable.defaultExpectation = &AppPublicServiceServerMockGetTableExpectation{} } - if mmListMessages.defaultExpectation.params != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Expect") + if mmGetTable.defaultExpectation.params != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Expect") } - if mmListMessages.defaultExpectation.paramPtrs == nil { - mmListMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListMessagesParamPtrs{} + if mmGetTable.defaultExpectation.paramPtrs == nil { + mmGetTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetTableParamPtrs{} } - mmListMessages.defaultExpectation.paramPtrs.ctx = &ctx - mmListMessages.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetTable.defaultExpectation.paramPtrs.ctx = &ctx + mmGetTable.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmListMessages + return mmGetTable } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListMessages -func (mmListMessages *mAppPublicServiceServerMockListMessages) ExpectLp1Param2(lp1 *mm_appv1alpha.ListMessagesRequest) *mAppPublicServiceServerMockListMessages { - if mmListMessages.mock.funcListMessages != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") +// ExpectGp1Param2 sets up expected param gp1 for AppPublicServiceServer.GetTable +func (mmGetTable *mAppPublicServiceServerMockGetTable) ExpectGp1Param2(gp1 *mm_appv1alpha.GetTableRequest) *mAppPublicServiceServerMockGetTable { + if mmGetTable.mock.funcGetTable != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Set") } - if mmListMessages.defaultExpectation == nil { - mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{} + if mmGetTable.defaultExpectation == nil { + mmGetTable.defaultExpectation = &AppPublicServiceServerMockGetTableExpectation{} } - if mmListMessages.defaultExpectation.params != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Expect") + if mmGetTable.defaultExpectation.params != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Expect") } - if mmListMessages.defaultExpectation.paramPtrs == nil { - mmListMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListMessagesParamPtrs{} + if mmGetTable.defaultExpectation.paramPtrs == nil { + mmGetTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetTableParamPtrs{} } - mmListMessages.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListMessages.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmGetTable.defaultExpectation.paramPtrs.gp1 = &gp1 + mmGetTable.defaultExpectation.expectationOrigins.originGp1 = minimock.CallerInfo(1) - return mmListMessages + return mmGetTable } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListMessages -func (mmListMessages *mAppPublicServiceServerMockListMessages) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest)) *mAppPublicServiceServerMockListMessages { - if mmListMessages.mock.inspectFuncListMessages != nil { - mmListMessages.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListMessages") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.GetTable +func (mmGetTable *mAppPublicServiceServerMockGetTable) Inspect(f func(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest)) *mAppPublicServiceServerMockGetTable { + if mmGetTable.mock.inspectFuncGetTable != nil { + mmGetTable.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.GetTable") } - mmListMessages.mock.inspectFuncListMessages = f + mmGetTable.mock.inspectFuncGetTable = f - return mmListMessages + return mmGetTable } -// Return sets up results that will be returned by AppPublicServiceServer.ListMessages -func (mmListMessages *mAppPublicServiceServerMockListMessages) Return(lp2 *mm_appv1alpha.ListMessagesResponse, err error) *AppPublicServiceServerMock { - if mmListMessages.mock.funcListMessages != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.GetTable +func (mmGetTable *mAppPublicServiceServerMockGetTable) Return(gp2 *mm_appv1alpha.GetTableResponse, err error) *AppPublicServiceServerMock { + if mmGetTable.mock.funcGetTable != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Set") } - if mmListMessages.defaultExpectation == nil { - mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{mock: mmListMessages.mock} + if mmGetTable.defaultExpectation == nil { + mmGetTable.defaultExpectation = &AppPublicServiceServerMockGetTableExpectation{mock: mmGetTable.mock} } - mmListMessages.defaultExpectation.results = &AppPublicServiceServerMockListMessagesResults{lp2, err} - mmListMessages.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListMessages.mock + mmGetTable.defaultExpectation.results = &AppPublicServiceServerMockGetTableResults{gp2, err} + mmGetTable.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetTable.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListMessages method -func (mmListMessages *mAppPublicServiceServerMockListMessages) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) (lp2 *mm_appv1alpha.ListMessagesResponse, err error)) *AppPublicServiceServerMock { - if mmListMessages.defaultExpectation != nil { - mmListMessages.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListMessages method") +// Set uses given function f to mock the AppPublicServiceServer.GetTable method +func (mmGetTable *mAppPublicServiceServerMockGetTable) Set(f func(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest) (gp2 *mm_appv1alpha.GetTableResponse, err error)) *AppPublicServiceServerMock { + if mmGetTable.defaultExpectation != nil { + mmGetTable.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.GetTable method") } - if len(mmListMessages.expectations) > 0 { - mmListMessages.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListMessages method") + if len(mmGetTable.expectations) > 0 { + mmGetTable.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.GetTable method") } - mmListMessages.mock.funcListMessages = f - mmListMessages.mock.funcListMessagesOrigin = minimock.CallerInfo(1) - return mmListMessages.mock + mmGetTable.mock.funcGetTable = f + mmGetTable.mock.funcGetTableOrigin = minimock.CallerInfo(1) + return mmGetTable.mock } -// When sets expectation for the AppPublicServiceServer.ListMessages which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.GetTable which will trigger the result defined by the following // Then helper -func (mmListMessages *mAppPublicServiceServerMockListMessages) When(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) *AppPublicServiceServerMockListMessagesExpectation { - if mmListMessages.mock.funcListMessages != nil { - mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") +func (mmGetTable *mAppPublicServiceServerMockGetTable) When(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest) *AppPublicServiceServerMockGetTableExpectation { + if mmGetTable.mock.funcGetTable != nil { + mmGetTable.mock.t.Fatalf("AppPublicServiceServerMock.GetTable mock is already set by Set") } - expectation := &AppPublicServiceServerMockListMessagesExpectation{ - mock: mmListMessages.mock, - params: &AppPublicServiceServerMockListMessagesParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListMessagesExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockGetTableExpectation{ + mock: mmGetTable.mock, + params: &AppPublicServiceServerMockGetTableParams{ctx, gp1}, + expectationOrigins: AppPublicServiceServerMockGetTableExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListMessages.expectations = append(mmListMessages.expectations, expectation) + mmGetTable.expectations = append(mmGetTable.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListMessages return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListMessagesExpectation) Then(lp2 *mm_appv1alpha.ListMessagesResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListMessagesResults{lp2, err} +// Then sets up AppPublicServiceServer.GetTable return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockGetTableExpectation) Then(gp2 *mm_appv1alpha.GetTableResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockGetTableResults{gp2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListMessages should be invoked -func (mmListMessages *mAppPublicServiceServerMockListMessages) Times(n uint64) *mAppPublicServiceServerMockListMessages { +// Times sets number of times AppPublicServiceServer.GetTable should be invoked +func (mmGetTable *mAppPublicServiceServerMockGetTable) Times(n uint64) *mAppPublicServiceServerMockGetTable { if n == 0 { - mmListMessages.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListMessages mock can not be zero") + mmGetTable.mock.t.Fatalf("Times of AppPublicServiceServerMock.GetTable mock can not be zero") } - mm_atomic.StoreUint64(&mmListMessages.expectedInvocations, n) - mmListMessages.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListMessages + mm_atomic.StoreUint64(&mmGetTable.expectedInvocations, n) + mmGetTable.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetTable } -func (mmListMessages *mAppPublicServiceServerMockListMessages) invocationsDone() bool { - if len(mmListMessages.expectations) == 0 && mmListMessages.defaultExpectation == nil && mmListMessages.mock.funcListMessages == nil { +func (mmGetTable *mAppPublicServiceServerMockGetTable) invocationsDone() bool { + if len(mmGetTable.expectations) == 0 && mmGetTable.defaultExpectation == nil && mmGetTable.mock.funcGetTable == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListMessages.mock.afterListMessagesCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListMessages.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetTable.mock.afterGetTableCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetTable.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListMessages implements mm_appv1alpha.AppPublicServiceServer -func (mmListMessages *AppPublicServiceServerMock) ListMessages(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) (lp2 *mm_appv1alpha.ListMessagesResponse, err error) { - mm_atomic.AddUint64(&mmListMessages.beforeListMessagesCounter, 1) - defer mm_atomic.AddUint64(&mmListMessages.afterListMessagesCounter, 1) +// GetTable implements mm_appv1alpha.AppPublicServiceServer +func (mmGetTable *AppPublicServiceServerMock) GetTable(ctx context.Context, gp1 *mm_appv1alpha.GetTableRequest) (gp2 *mm_appv1alpha.GetTableResponse, err error) { + mm_atomic.AddUint64(&mmGetTable.beforeGetTableCounter, 1) + defer mm_atomic.AddUint64(&mmGetTable.afterGetTableCounter, 1) - mmListMessages.t.Helper() + mmGetTable.t.Helper() - if mmListMessages.inspectFuncListMessages != nil { - mmListMessages.inspectFuncListMessages(ctx, lp1) + if mmGetTable.inspectFuncGetTable != nil { + mmGetTable.inspectFuncGetTable(ctx, gp1) } - mm_params := AppPublicServiceServerMockListMessagesParams{ctx, lp1} + mm_params := AppPublicServiceServerMockGetTableParams{ctx, gp1} // Record call args - mmListMessages.ListMessagesMock.mutex.Lock() - mmListMessages.ListMessagesMock.callArgs = append(mmListMessages.ListMessagesMock.callArgs, &mm_params) - mmListMessages.ListMessagesMock.mutex.Unlock() + mmGetTable.GetTableMock.mutex.Lock() + mmGetTable.GetTableMock.callArgs = append(mmGetTable.GetTableMock.callArgs, &mm_params) + mmGetTable.GetTableMock.mutex.Unlock() - for _, e := range mmListMessages.ListMessagesMock.expectations { + for _, e := range mmGetTable.GetTableMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.gp2, e.results.err } } - if mmListMessages.ListMessagesMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListMessages.ListMessagesMock.defaultExpectation.Counter, 1) - mm_want := mmListMessages.ListMessagesMock.defaultExpectation.params - mm_want_ptrs := mmListMessages.ListMessagesMock.defaultExpectation.paramPtrs + if mmGetTable.GetTableMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetTable.GetTableMock.defaultExpectation.Counter, 1) + mm_want := mmGetTable.GetTableMock.defaultExpectation.params + mm_want_ptrs := mmGetTable.GetTableMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListMessagesParams{ctx, lp1} + mm_got := AppPublicServiceServerMockGetTableParams{ctx, gp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListMessages.t.Errorf("AppPublicServiceServerMock.ListMessages got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListMessages.ListMessagesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetTable.t.Errorf("AppPublicServiceServerMock.GetTable got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetTable.GetTableMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListMessages.t.Errorf("AppPublicServiceServerMock.ListMessages got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListMessages.ListMessagesMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.gp1 != nil && !minimock.Equal(*mm_want_ptrs.gp1, mm_got.gp1) { + mmGetTable.t.Errorf("AppPublicServiceServerMock.GetTable got unexpected parameter gp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetTable.GetTableMock.defaultExpectation.expectationOrigins.originGp1, *mm_want_ptrs.gp1, mm_got.gp1, minimock.Diff(*mm_want_ptrs.gp1, mm_got.gp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListMessages.t.Errorf("AppPublicServiceServerMock.ListMessages got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListMessages.ListMessagesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetTable.t.Errorf("AppPublicServiceServerMock.GetTable got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetTable.GetTableMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListMessages.ListMessagesMock.defaultExpectation.results + mm_results := mmGetTable.GetTableMock.defaultExpectation.results if mm_results == nil { - mmListMessages.t.Fatal("No results are set for the AppPublicServiceServerMock.ListMessages") + mmGetTable.t.Fatal("No results are set for the AppPublicServiceServerMock.GetTable") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).gp2, (*mm_results).err } - if mmListMessages.funcListMessages != nil { - return mmListMessages.funcListMessages(ctx, lp1) + if mmGetTable.funcGetTable != nil { + return mmGetTable.funcGetTable(ctx, gp1) } - mmListMessages.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListMessages. %v %v", ctx, lp1) + mmGetTable.t.Fatalf("Unexpected call to AppPublicServiceServerMock.GetTable. %v %v", ctx, gp1) return } -// ListMessagesAfterCounter returns a count of finished AppPublicServiceServerMock.ListMessages invocations -func (mmListMessages *AppPublicServiceServerMock) ListMessagesAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListMessages.afterListMessagesCounter) +// GetTableAfterCounter returns a count of finished AppPublicServiceServerMock.GetTable invocations +func (mmGetTable *AppPublicServiceServerMock) GetTableAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetTable.afterGetTableCounter) } -// ListMessagesBeforeCounter returns a count of AppPublicServiceServerMock.ListMessages invocations -func (mmListMessages *AppPublicServiceServerMock) ListMessagesBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListMessages.beforeListMessagesCounter) +// GetTableBeforeCounter returns a count of AppPublicServiceServerMock.GetTable invocations +func (mmGetTable *AppPublicServiceServerMock) GetTableBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetTable.beforeGetTableCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListMessages. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.GetTable. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListMessages *mAppPublicServiceServerMockListMessages) Calls() []*AppPublicServiceServerMockListMessagesParams { - mmListMessages.mutex.RLock() +func (mmGetTable *mAppPublicServiceServerMockGetTable) Calls() []*AppPublicServiceServerMockGetTableParams { + mmGetTable.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListMessagesParams, len(mmListMessages.callArgs)) - copy(argCopy, mmListMessages.callArgs) + argCopy := make([]*AppPublicServiceServerMockGetTableParams, len(mmGetTable.callArgs)) + copy(argCopy, mmGetTable.callArgs) - mmListMessages.mutex.RUnlock() + mmGetTable.mutex.RUnlock() return argCopy } -// MinimockListMessagesDone returns true if the count of the ListMessages invocations corresponds +// MinimockGetTableDone returns true if the count of the GetTable invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListMessagesDone() bool { - if m.ListMessagesMock.optional { +func (m *AppPublicServiceServerMock) MinimockGetTableDone() bool { + if m.GetTableMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListMessagesMock.expectations { + for _, e := range m.GetTableMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListMessagesMock.invocationsDone() + return m.GetTableMock.invocationsDone() } -// MinimockListMessagesInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListMessagesInspect() { - for _, e := range m.ListMessagesMock.expectations { +// MinimockGetTableInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockGetTableInspect() { + for _, e := range m.GetTableMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTable at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListMessagesCounter := mm_atomic.LoadUint64(&m.afterListMessagesCounter) + afterGetTableCounter := mm_atomic.LoadUint64(&m.afterGetTableCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListMessagesMock.defaultExpectation != nil && afterListMessagesCounter < 1 { - if m.ListMessagesMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s", m.ListMessagesMock.defaultExpectation.returnOrigin) + if m.GetTableMock.defaultExpectation != nil && afterGetTableCounter < 1 { + if m.GetTableMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTable at\n%s", m.GetTableMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s with params: %#v", m.ListMessagesMock.defaultExpectation.expectationOrigins.origin, *m.ListMessagesMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTable at\n%s with params: %#v", m.GetTableMock.defaultExpectation.expectationOrigins.origin, *m.GetTableMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListMessages != nil && afterListMessagesCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s", m.funcListMessagesOrigin) + if m.funcGetTable != nil && afterGetTableCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTable at\n%s", m.funcGetTableOrigin) } - if !m.ListMessagesMock.invocationsDone() && afterListMessagesCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListMessages at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListMessagesMock.expectedInvocations), m.ListMessagesMock.expectedInvocationsOrigin, afterListMessagesCounter) + if !m.GetTableMock.invocationsDone() && afterGetTableCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.GetTable at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetTableMock.expectedInvocations), m.GetTableMock.expectedInvocationsOrigin, afterGetTableCounter) } } -type mAppPublicServiceServerMockListTools struct { +type mAppPublicServiceServerMockGetTableEvents struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockListToolsExpectation - expectations []*AppPublicServiceServerMockListToolsExpectation + defaultExpectation *AppPublicServiceServerMockGetTableEventsExpectation + expectations []*AppPublicServiceServerMockGetTableEventsExpectation - callArgs []*AppPublicServiceServerMockListToolsParams + callArgs []*AppPublicServiceServerMockGetTableEventsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockListToolsExpectation specifies expectation struct of the AppPublicServiceServer.ListTools -type AppPublicServiceServerMockListToolsExpectation struct { +// AppPublicServiceServerMockGetTableEventsExpectation specifies expectation struct of the AppPublicServiceServer.GetTableEvents +type AppPublicServiceServerMockGetTableEventsExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockListToolsParams - paramPtrs *AppPublicServiceServerMockListToolsParamPtrs - expectationOrigins AppPublicServiceServerMockListToolsExpectationOrigins - results *AppPublicServiceServerMockListToolsResults + params *AppPublicServiceServerMockGetTableEventsParams + paramPtrs *AppPublicServiceServerMockGetTableEventsParamPtrs + expectationOrigins AppPublicServiceServerMockGetTableEventsExpectationOrigins + results *AppPublicServiceServerMockGetTableEventsResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockListToolsParams contains parameters of the AppPublicServiceServer.ListTools -type AppPublicServiceServerMockListToolsParams struct { - ctx context.Context - lp1 *mm_appv1alpha.ListToolsRequest +// AppPublicServiceServerMockGetTableEventsParams contains parameters of the AppPublicServiceServer.GetTableEvents +type AppPublicServiceServerMockGetTableEventsParams struct { + gp1 *mm_appv1alpha.GetTableEventsRequest + a1 mm_appv1alpha.AppPublicService_GetTableEventsServer } -// AppPublicServiceServerMockListToolsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListTools -type AppPublicServiceServerMockListToolsParamPtrs struct { - ctx *context.Context - lp1 **mm_appv1alpha.ListToolsRequest +// AppPublicServiceServerMockGetTableEventsParamPtrs contains pointers to parameters of the AppPublicServiceServer.GetTableEvents +type AppPublicServiceServerMockGetTableEventsParamPtrs struct { + gp1 **mm_appv1alpha.GetTableEventsRequest + a1 *mm_appv1alpha.AppPublicService_GetTableEventsServer } -// AppPublicServiceServerMockListToolsResults contains results of the AppPublicServiceServer.ListTools -type AppPublicServiceServerMockListToolsResults struct { - lp2 *mm_appv1alpha.ListToolsResponse +// AppPublicServiceServerMockGetTableEventsResults contains results of the AppPublicServiceServer.GetTableEvents +type AppPublicServiceServerMockGetTableEventsResults struct { err error } -// AppPublicServiceServerMockListToolsOrigins contains origins of expectations of the AppPublicServiceServer.ListTools -type AppPublicServiceServerMockListToolsExpectationOrigins struct { +// AppPublicServiceServerMockGetTableEventsOrigins contains origins of expectations of the AppPublicServiceServer.GetTableEvents +type AppPublicServiceServerMockGetTableEventsExpectationOrigins struct { origin string - originCtx string - originLp1 string + originGp1 string + originA1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -6529,342 +7031,342 @@ type AppPublicServiceServerMockListToolsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmListTools *mAppPublicServiceServerMockListTools) Optional() *mAppPublicServiceServerMockListTools { - mmListTools.optional = true - return mmListTools +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Optional() *mAppPublicServiceServerMockGetTableEvents { + mmGetTableEvents.optional = true + return mmGetTableEvents } -// Expect sets up expected params for AppPublicServiceServer.ListTools -func (mmListTools *mAppPublicServiceServerMockListTools) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) *mAppPublicServiceServerMockListTools { - if mmListTools.mock.funcListTools != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.GetTableEvents +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Expect(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) *mAppPublicServiceServerMockGetTableEvents { + if mmGetTableEvents.mock.funcGetTableEvents != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Set") } - if mmListTools.defaultExpectation == nil { - mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{} + if mmGetTableEvents.defaultExpectation == nil { + mmGetTableEvents.defaultExpectation = &AppPublicServiceServerMockGetTableEventsExpectation{} } - if mmListTools.defaultExpectation.paramPtrs != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by ExpectParams functions") + if mmGetTableEvents.defaultExpectation.paramPtrs != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by ExpectParams functions") } - mmListTools.defaultExpectation.params = &AppPublicServiceServerMockListToolsParams{ctx, lp1} - mmListTools.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmListTools.expectations { - if minimock.Equal(e.params, mmListTools.defaultExpectation.params) { - mmListTools.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListTools.defaultExpectation.params) + mmGetTableEvents.defaultExpectation.params = &AppPublicServiceServerMockGetTableEventsParams{gp1, a1} + mmGetTableEvents.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetTableEvents.expectations { + if minimock.Equal(e.params, mmGetTableEvents.defaultExpectation.params) { + mmGetTableEvents.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetTableEvents.defaultExpectation.params) } } - return mmListTools + return mmGetTableEvents } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListTools -func (mmListTools *mAppPublicServiceServerMockListTools) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListTools { - if mmListTools.mock.funcListTools != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") +// ExpectGp1Param1 sets up expected param gp1 for AppPublicServiceServer.GetTableEvents +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) ExpectGp1Param1(gp1 *mm_appv1alpha.GetTableEventsRequest) *mAppPublicServiceServerMockGetTableEvents { + if mmGetTableEvents.mock.funcGetTableEvents != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Set") } - if mmListTools.defaultExpectation == nil { - mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{} + if mmGetTableEvents.defaultExpectation == nil { + mmGetTableEvents.defaultExpectation = &AppPublicServiceServerMockGetTableEventsExpectation{} } - if mmListTools.defaultExpectation.params != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Expect") + if mmGetTableEvents.defaultExpectation.params != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Expect") } - if mmListTools.defaultExpectation.paramPtrs == nil { - mmListTools.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListToolsParamPtrs{} + if mmGetTableEvents.defaultExpectation.paramPtrs == nil { + mmGetTableEvents.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetTableEventsParamPtrs{} } - mmListTools.defaultExpectation.paramPtrs.ctx = &ctx - mmListTools.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetTableEvents.defaultExpectation.paramPtrs.gp1 = &gp1 + mmGetTableEvents.defaultExpectation.expectationOrigins.originGp1 = minimock.CallerInfo(1) - return mmListTools + return mmGetTableEvents } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListTools -func (mmListTools *mAppPublicServiceServerMockListTools) ExpectLp1Param2(lp1 *mm_appv1alpha.ListToolsRequest) *mAppPublicServiceServerMockListTools { - if mmListTools.mock.funcListTools != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") +// ExpectA1Param2 sets up expected param a1 for AppPublicServiceServer.GetTableEvents +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) ExpectA1Param2(a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) *mAppPublicServiceServerMockGetTableEvents { + if mmGetTableEvents.mock.funcGetTableEvents != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Set") } - if mmListTools.defaultExpectation == nil { - mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{} + if mmGetTableEvents.defaultExpectation == nil { + mmGetTableEvents.defaultExpectation = &AppPublicServiceServerMockGetTableEventsExpectation{} } - if mmListTools.defaultExpectation.params != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Expect") + if mmGetTableEvents.defaultExpectation.params != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Expect") } - if mmListTools.defaultExpectation.paramPtrs == nil { - mmListTools.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListToolsParamPtrs{} + if mmGetTableEvents.defaultExpectation.paramPtrs == nil { + mmGetTableEvents.defaultExpectation.paramPtrs = &AppPublicServiceServerMockGetTableEventsParamPtrs{} } - mmListTools.defaultExpectation.paramPtrs.lp1 = &lp1 - mmListTools.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmGetTableEvents.defaultExpectation.paramPtrs.a1 = &a1 + mmGetTableEvents.defaultExpectation.expectationOrigins.originA1 = minimock.CallerInfo(1) - return mmListTools + return mmGetTableEvents } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListTools -func (mmListTools *mAppPublicServiceServerMockListTools) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest)) *mAppPublicServiceServerMockListTools { - if mmListTools.mock.inspectFuncListTools != nil { - mmListTools.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListTools") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.GetTableEvents +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Inspect(f func(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer)) *mAppPublicServiceServerMockGetTableEvents { + if mmGetTableEvents.mock.inspectFuncGetTableEvents != nil { + mmGetTableEvents.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.GetTableEvents") } - mmListTools.mock.inspectFuncListTools = f + mmGetTableEvents.mock.inspectFuncGetTableEvents = f - return mmListTools + return mmGetTableEvents } -// Return sets up results that will be returned by AppPublicServiceServer.ListTools -func (mmListTools *mAppPublicServiceServerMockListTools) Return(lp2 *mm_appv1alpha.ListToolsResponse, err error) *AppPublicServiceServerMock { - if mmListTools.mock.funcListTools != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.GetTableEvents +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Return(err error) *AppPublicServiceServerMock { + if mmGetTableEvents.mock.funcGetTableEvents != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Set") } - if mmListTools.defaultExpectation == nil { - mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{mock: mmListTools.mock} + if mmGetTableEvents.defaultExpectation == nil { + mmGetTableEvents.defaultExpectation = &AppPublicServiceServerMockGetTableEventsExpectation{mock: mmGetTableEvents.mock} } - mmListTools.defaultExpectation.results = &AppPublicServiceServerMockListToolsResults{lp2, err} - mmListTools.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmListTools.mock + mmGetTableEvents.defaultExpectation.results = &AppPublicServiceServerMockGetTableEventsResults{err} + mmGetTableEvents.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetTableEvents.mock } -// Set uses given function f to mock the AppPublicServiceServer.ListTools method -func (mmListTools *mAppPublicServiceServerMockListTools) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) (lp2 *mm_appv1alpha.ListToolsResponse, err error)) *AppPublicServiceServerMock { - if mmListTools.defaultExpectation != nil { - mmListTools.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListTools method") +// Set uses given function f to mock the AppPublicServiceServer.GetTableEvents method +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Set(f func(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) (err error)) *AppPublicServiceServerMock { + if mmGetTableEvents.defaultExpectation != nil { + mmGetTableEvents.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.GetTableEvents method") } - if len(mmListTools.expectations) > 0 { - mmListTools.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListTools method") + if len(mmGetTableEvents.expectations) > 0 { + mmGetTableEvents.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.GetTableEvents method") } - mmListTools.mock.funcListTools = f - mmListTools.mock.funcListToolsOrigin = minimock.CallerInfo(1) - return mmListTools.mock + mmGetTableEvents.mock.funcGetTableEvents = f + mmGetTableEvents.mock.funcGetTableEventsOrigin = minimock.CallerInfo(1) + return mmGetTableEvents.mock } -// When sets expectation for the AppPublicServiceServer.ListTools which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.GetTableEvents which will trigger the result defined by the following // Then helper -func (mmListTools *mAppPublicServiceServerMockListTools) When(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) *AppPublicServiceServerMockListToolsExpectation { - if mmListTools.mock.funcListTools != nil { - mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) When(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) *AppPublicServiceServerMockGetTableEventsExpectation { + if mmGetTableEvents.mock.funcGetTableEvents != nil { + mmGetTableEvents.mock.t.Fatalf("AppPublicServiceServerMock.GetTableEvents mock is already set by Set") } - expectation := &AppPublicServiceServerMockListToolsExpectation{ - mock: mmListTools.mock, - params: &AppPublicServiceServerMockListToolsParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockListToolsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockGetTableEventsExpectation{ + mock: mmGetTableEvents.mock, + params: &AppPublicServiceServerMockGetTableEventsParams{gp1, a1}, + expectationOrigins: AppPublicServiceServerMockGetTableEventsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmListTools.expectations = append(mmListTools.expectations, expectation) + mmGetTableEvents.expectations = append(mmGetTableEvents.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.ListTools return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockListToolsExpectation) Then(lp2 *mm_appv1alpha.ListToolsResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockListToolsResults{lp2, err} +// Then sets up AppPublicServiceServer.GetTableEvents return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockGetTableEventsExpectation) Then(err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockGetTableEventsResults{err} return e.mock } -// Times sets number of times AppPublicServiceServer.ListTools should be invoked -func (mmListTools *mAppPublicServiceServerMockListTools) Times(n uint64) *mAppPublicServiceServerMockListTools { +// Times sets number of times AppPublicServiceServer.GetTableEvents should be invoked +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Times(n uint64) *mAppPublicServiceServerMockGetTableEvents { if n == 0 { - mmListTools.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListTools mock can not be zero") + mmGetTableEvents.mock.t.Fatalf("Times of AppPublicServiceServerMock.GetTableEvents mock can not be zero") } - mm_atomic.StoreUint64(&mmListTools.expectedInvocations, n) - mmListTools.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmListTools + mm_atomic.StoreUint64(&mmGetTableEvents.expectedInvocations, n) + mmGetTableEvents.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetTableEvents } -func (mmListTools *mAppPublicServiceServerMockListTools) invocationsDone() bool { - if len(mmListTools.expectations) == 0 && mmListTools.defaultExpectation == nil && mmListTools.mock.funcListTools == nil { +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) invocationsDone() bool { + if len(mmGetTableEvents.expectations) == 0 && mmGetTableEvents.defaultExpectation == nil && mmGetTableEvents.mock.funcGetTableEvents == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmListTools.mock.afterListToolsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmListTools.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetTableEvents.mock.afterGetTableEventsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetTableEvents.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// ListTools implements mm_appv1alpha.AppPublicServiceServer -func (mmListTools *AppPublicServiceServerMock) ListTools(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) (lp2 *mm_appv1alpha.ListToolsResponse, err error) { - mm_atomic.AddUint64(&mmListTools.beforeListToolsCounter, 1) - defer mm_atomic.AddUint64(&mmListTools.afterListToolsCounter, 1) +// GetTableEvents implements mm_appv1alpha.AppPublicServiceServer +func (mmGetTableEvents *AppPublicServiceServerMock) GetTableEvents(gp1 *mm_appv1alpha.GetTableEventsRequest, a1 mm_appv1alpha.AppPublicService_GetTableEventsServer) (err error) { + mm_atomic.AddUint64(&mmGetTableEvents.beforeGetTableEventsCounter, 1) + defer mm_atomic.AddUint64(&mmGetTableEvents.afterGetTableEventsCounter, 1) - mmListTools.t.Helper() + mmGetTableEvents.t.Helper() - if mmListTools.inspectFuncListTools != nil { - mmListTools.inspectFuncListTools(ctx, lp1) + if mmGetTableEvents.inspectFuncGetTableEvents != nil { + mmGetTableEvents.inspectFuncGetTableEvents(gp1, a1) } - mm_params := AppPublicServiceServerMockListToolsParams{ctx, lp1} + mm_params := AppPublicServiceServerMockGetTableEventsParams{gp1, a1} // Record call args - mmListTools.ListToolsMock.mutex.Lock() - mmListTools.ListToolsMock.callArgs = append(mmListTools.ListToolsMock.callArgs, &mm_params) - mmListTools.ListToolsMock.mutex.Unlock() + mmGetTableEvents.GetTableEventsMock.mutex.Lock() + mmGetTableEvents.GetTableEventsMock.callArgs = append(mmGetTableEvents.GetTableEventsMock.callArgs, &mm_params) + mmGetTableEvents.GetTableEventsMock.mutex.Unlock() - for _, e := range mmListTools.ListToolsMock.expectations { + for _, e := range mmGetTableEvents.GetTableEventsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.err } } - if mmListTools.ListToolsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmListTools.ListToolsMock.defaultExpectation.Counter, 1) - mm_want := mmListTools.ListToolsMock.defaultExpectation.params - mm_want_ptrs := mmListTools.ListToolsMock.defaultExpectation.paramPtrs + if mmGetTableEvents.GetTableEventsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetTableEvents.GetTableEventsMock.defaultExpectation.Counter, 1) + mm_want := mmGetTableEvents.GetTableEventsMock.defaultExpectation.params + mm_want_ptrs := mmGetTableEvents.GetTableEventsMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockListToolsParams{ctx, lp1} + mm_got := AppPublicServiceServerMockGetTableEventsParams{gp1, a1} if mm_want_ptrs != nil { - if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmListTools.t.Errorf("AppPublicServiceServerMock.ListTools got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListTools.ListToolsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + if mm_want_ptrs.gp1 != nil && !minimock.Equal(*mm_want_ptrs.gp1, mm_got.gp1) { + mmGetTableEvents.t.Errorf("AppPublicServiceServerMock.GetTableEvents got unexpected parameter gp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetTableEvents.GetTableEventsMock.defaultExpectation.expectationOrigins.originGp1, *mm_want_ptrs.gp1, mm_got.gp1, minimock.Diff(*mm_want_ptrs.gp1, mm_got.gp1)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmListTools.t.Errorf("AppPublicServiceServerMock.ListTools got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListTools.ListToolsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.a1 != nil && !minimock.Equal(*mm_want_ptrs.a1, mm_got.a1) { + mmGetTableEvents.t.Errorf("AppPublicServiceServerMock.GetTableEvents got unexpected parameter a1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetTableEvents.GetTableEventsMock.defaultExpectation.expectationOrigins.originA1, *mm_want_ptrs.a1, mm_got.a1, minimock.Diff(*mm_want_ptrs.a1, mm_got.a1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmListTools.t.Errorf("AppPublicServiceServerMock.ListTools got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmListTools.ListToolsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetTableEvents.t.Errorf("AppPublicServiceServerMock.GetTableEvents got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetTableEvents.GetTableEventsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmListTools.ListToolsMock.defaultExpectation.results + mm_results := mmGetTableEvents.GetTableEventsMock.defaultExpectation.results if mm_results == nil { - mmListTools.t.Fatal("No results are set for the AppPublicServiceServerMock.ListTools") + mmGetTableEvents.t.Fatal("No results are set for the AppPublicServiceServerMock.GetTableEvents") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).err } - if mmListTools.funcListTools != nil { - return mmListTools.funcListTools(ctx, lp1) + if mmGetTableEvents.funcGetTableEvents != nil { + return mmGetTableEvents.funcGetTableEvents(gp1, a1) } - mmListTools.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListTools. %v %v", ctx, lp1) + mmGetTableEvents.t.Fatalf("Unexpected call to AppPublicServiceServerMock.GetTableEvents. %v %v", gp1, a1) return } -// ListToolsAfterCounter returns a count of finished AppPublicServiceServerMock.ListTools invocations -func (mmListTools *AppPublicServiceServerMock) ListToolsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmListTools.afterListToolsCounter) +// GetTableEventsAfterCounter returns a count of finished AppPublicServiceServerMock.GetTableEvents invocations +func (mmGetTableEvents *AppPublicServiceServerMock) GetTableEventsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetTableEvents.afterGetTableEventsCounter) } -// ListToolsBeforeCounter returns a count of AppPublicServiceServerMock.ListTools invocations -func (mmListTools *AppPublicServiceServerMock) ListToolsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmListTools.beforeListToolsCounter) +// GetTableEventsBeforeCounter returns a count of AppPublicServiceServerMock.GetTableEvents invocations +func (mmGetTableEvents *AppPublicServiceServerMock) GetTableEventsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetTableEvents.beforeGetTableEventsCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListTools. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.GetTableEvents. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmListTools *mAppPublicServiceServerMockListTools) Calls() []*AppPublicServiceServerMockListToolsParams { - mmListTools.mutex.RLock() +func (mmGetTableEvents *mAppPublicServiceServerMockGetTableEvents) Calls() []*AppPublicServiceServerMockGetTableEventsParams { + mmGetTableEvents.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockListToolsParams, len(mmListTools.callArgs)) - copy(argCopy, mmListTools.callArgs) + argCopy := make([]*AppPublicServiceServerMockGetTableEventsParams, len(mmGetTableEvents.callArgs)) + copy(argCopy, mmGetTableEvents.callArgs) - mmListTools.mutex.RUnlock() + mmGetTableEvents.mutex.RUnlock() return argCopy } -// MinimockListToolsDone returns true if the count of the ListTools invocations corresponds +// MinimockGetTableEventsDone returns true if the count of the GetTableEvents invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockListToolsDone() bool { - if m.ListToolsMock.optional { +func (m *AppPublicServiceServerMock) MinimockGetTableEventsDone() bool { + if m.GetTableEventsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ListToolsMock.expectations { + for _, e := range m.GetTableEventsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ListToolsMock.invocationsDone() + return m.GetTableEventsMock.invocationsDone() } -// MinimockListToolsInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockListToolsInspect() { - for _, e := range m.ListToolsMock.expectations { +// MinimockGetTableEventsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockGetTableEventsInspect() { + for _, e := range m.GetTableEventsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTableEvents at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterListToolsCounter := mm_atomic.LoadUint64(&m.afterListToolsCounter) + afterGetTableEventsCounter := mm_atomic.LoadUint64(&m.afterGetTableEventsCounter) // if default expectation was set then invocations count should be greater than zero - if m.ListToolsMock.defaultExpectation != nil && afterListToolsCounter < 1 { - if m.ListToolsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s", m.ListToolsMock.defaultExpectation.returnOrigin) + if m.GetTableEventsMock.defaultExpectation != nil && afterGetTableEventsCounter < 1 { + if m.GetTableEventsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTableEvents at\n%s", m.GetTableEventsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s with params: %#v", m.ListToolsMock.defaultExpectation.expectationOrigins.origin, *m.ListToolsMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTableEvents at\n%s with params: %#v", m.GetTableEventsMock.defaultExpectation.expectationOrigins.origin, *m.GetTableEventsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcListTools != nil && afterListToolsCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s", m.funcListToolsOrigin) + if m.funcGetTableEvents != nil && afterGetTableEventsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.GetTableEvents at\n%s", m.funcGetTableEventsOrigin) } - if !m.ListToolsMock.invocationsDone() && afterListToolsCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListTools at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ListToolsMock.expectedInvocations), m.ListToolsMock.expectedInvocationsOrigin, afterListToolsCounter) + if !m.GetTableEventsMock.invocationsDone() && afterGetTableEventsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.GetTableEvents at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetTableEventsMock.expectedInvocations), m.GetTableEventsMock.expectedInvocationsOrigin, afterGetTableEventsCounter) } } -type mAppPublicServiceServerMockLiveness struct { +type mAppPublicServiceServerMockInsertRow struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockLivenessExpectation - expectations []*AppPublicServiceServerMockLivenessExpectation + defaultExpectation *AppPublicServiceServerMockInsertRowExpectation + expectations []*AppPublicServiceServerMockInsertRowExpectation - callArgs []*AppPublicServiceServerMockLivenessParams + callArgs []*AppPublicServiceServerMockInsertRowParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockLivenessExpectation specifies expectation struct of the AppPublicServiceServer.Liveness -type AppPublicServiceServerMockLivenessExpectation struct { +// AppPublicServiceServerMockInsertRowExpectation specifies expectation struct of the AppPublicServiceServer.InsertRow +type AppPublicServiceServerMockInsertRowExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockLivenessParams - paramPtrs *AppPublicServiceServerMockLivenessParamPtrs - expectationOrigins AppPublicServiceServerMockLivenessExpectationOrigins - results *AppPublicServiceServerMockLivenessResults + params *AppPublicServiceServerMockInsertRowParams + paramPtrs *AppPublicServiceServerMockInsertRowParamPtrs + expectationOrigins AppPublicServiceServerMockInsertRowExpectationOrigins + results *AppPublicServiceServerMockInsertRowResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockLivenessParams contains parameters of the AppPublicServiceServer.Liveness -type AppPublicServiceServerMockLivenessParams struct { +// AppPublicServiceServerMockInsertRowParams contains parameters of the AppPublicServiceServer.InsertRow +type AppPublicServiceServerMockInsertRowParams struct { ctx context.Context - lp1 *mm_appv1alpha.LivenessRequest + ip1 *mm_appv1alpha.InsertRowRequest } -// AppPublicServiceServerMockLivenessParamPtrs contains pointers to parameters of the AppPublicServiceServer.Liveness -type AppPublicServiceServerMockLivenessParamPtrs struct { +// AppPublicServiceServerMockInsertRowParamPtrs contains pointers to parameters of the AppPublicServiceServer.InsertRow +type AppPublicServiceServerMockInsertRowParamPtrs struct { ctx *context.Context - lp1 **mm_appv1alpha.LivenessRequest + ip1 **mm_appv1alpha.InsertRowRequest } -// AppPublicServiceServerMockLivenessResults contains results of the AppPublicServiceServer.Liveness -type AppPublicServiceServerMockLivenessResults struct { - lp2 *mm_appv1alpha.LivenessResponse +// AppPublicServiceServerMockInsertRowResults contains results of the AppPublicServiceServer.InsertRow +type AppPublicServiceServerMockInsertRowResults struct { + ip2 *mm_appv1alpha.InsertRowResponse err error } -// AppPublicServiceServerMockLivenessOrigins contains origins of expectations of the AppPublicServiceServer.Liveness -type AppPublicServiceServerMockLivenessExpectationOrigins struct { +// AppPublicServiceServerMockInsertRowOrigins contains origins of expectations of the AppPublicServiceServer.InsertRow +type AppPublicServiceServerMockInsertRowExpectationOrigins struct { origin string originCtx string - originLp1 string + originIp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -6872,342 +7374,342 @@ type AppPublicServiceServerMockLivenessExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmLiveness *mAppPublicServiceServerMockLiveness) Optional() *mAppPublicServiceServerMockLiveness { - mmLiveness.optional = true - return mmLiveness +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Optional() *mAppPublicServiceServerMockInsertRow { + mmInsertRow.optional = true + return mmInsertRow } -// Expect sets up expected params for AppPublicServiceServer.Liveness -func (mmLiveness *mAppPublicServiceServerMockLiveness) Expect(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) *mAppPublicServiceServerMockLiveness { - if mmLiveness.mock.funcLiveness != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.InsertRow +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Expect(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest) *mAppPublicServiceServerMockInsertRow { + if mmInsertRow.mock.funcInsertRow != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Set") } - if mmLiveness.defaultExpectation == nil { - mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{} + if mmInsertRow.defaultExpectation == nil { + mmInsertRow.defaultExpectation = &AppPublicServiceServerMockInsertRowExpectation{} } - if mmLiveness.defaultExpectation.paramPtrs != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by ExpectParams functions") + if mmInsertRow.defaultExpectation.paramPtrs != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by ExpectParams functions") } - mmLiveness.defaultExpectation.params = &AppPublicServiceServerMockLivenessParams{ctx, lp1} - mmLiveness.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmLiveness.expectations { - if minimock.Equal(e.params, mmLiveness.defaultExpectation.params) { - mmLiveness.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmLiveness.defaultExpectation.params) + mmInsertRow.defaultExpectation.params = &AppPublicServiceServerMockInsertRowParams{ctx, ip1} + mmInsertRow.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmInsertRow.expectations { + if minimock.Equal(e.params, mmInsertRow.defaultExpectation.params) { + mmInsertRow.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmInsertRow.defaultExpectation.params) } } - return mmLiveness + return mmInsertRow } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.Liveness -func (mmLiveness *mAppPublicServiceServerMockLiveness) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockLiveness { - if mmLiveness.mock.funcLiveness != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.InsertRow +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockInsertRow { + if mmInsertRow.mock.funcInsertRow != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Set") } - if mmLiveness.defaultExpectation == nil { - mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{} + if mmInsertRow.defaultExpectation == nil { + mmInsertRow.defaultExpectation = &AppPublicServiceServerMockInsertRowExpectation{} } - if mmLiveness.defaultExpectation.params != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Expect") + if mmInsertRow.defaultExpectation.params != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Expect") } - if mmLiveness.defaultExpectation.paramPtrs == nil { - mmLiveness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockLivenessParamPtrs{} + if mmInsertRow.defaultExpectation.paramPtrs == nil { + mmInsertRow.defaultExpectation.paramPtrs = &AppPublicServiceServerMockInsertRowParamPtrs{} } - mmLiveness.defaultExpectation.paramPtrs.ctx = &ctx - mmLiveness.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmInsertRow.defaultExpectation.paramPtrs.ctx = &ctx + mmInsertRow.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmLiveness + return mmInsertRow } -// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.Liveness -func (mmLiveness *mAppPublicServiceServerMockLiveness) ExpectLp1Param2(lp1 *mm_appv1alpha.LivenessRequest) *mAppPublicServiceServerMockLiveness { - if mmLiveness.mock.funcLiveness != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") +// ExpectIp1Param2 sets up expected param ip1 for AppPublicServiceServer.InsertRow +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) ExpectIp1Param2(ip1 *mm_appv1alpha.InsertRowRequest) *mAppPublicServiceServerMockInsertRow { + if mmInsertRow.mock.funcInsertRow != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Set") } - if mmLiveness.defaultExpectation == nil { - mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{} + if mmInsertRow.defaultExpectation == nil { + mmInsertRow.defaultExpectation = &AppPublicServiceServerMockInsertRowExpectation{} } - if mmLiveness.defaultExpectation.params != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Expect") + if mmInsertRow.defaultExpectation.params != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Expect") } - if mmLiveness.defaultExpectation.paramPtrs == nil { - mmLiveness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockLivenessParamPtrs{} + if mmInsertRow.defaultExpectation.paramPtrs == nil { + mmInsertRow.defaultExpectation.paramPtrs = &AppPublicServiceServerMockInsertRowParamPtrs{} } - mmLiveness.defaultExpectation.paramPtrs.lp1 = &lp1 - mmLiveness.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + mmInsertRow.defaultExpectation.paramPtrs.ip1 = &ip1 + mmInsertRow.defaultExpectation.expectationOrigins.originIp1 = minimock.CallerInfo(1) - return mmLiveness + return mmInsertRow } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.Liveness -func (mmLiveness *mAppPublicServiceServerMockLiveness) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest)) *mAppPublicServiceServerMockLiveness { - if mmLiveness.mock.inspectFuncLiveness != nil { - mmLiveness.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.Liveness") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.InsertRow +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Inspect(f func(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest)) *mAppPublicServiceServerMockInsertRow { + if mmInsertRow.mock.inspectFuncInsertRow != nil { + mmInsertRow.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.InsertRow") } - mmLiveness.mock.inspectFuncLiveness = f + mmInsertRow.mock.inspectFuncInsertRow = f - return mmLiveness + return mmInsertRow } -// Return sets up results that will be returned by AppPublicServiceServer.Liveness -func (mmLiveness *mAppPublicServiceServerMockLiveness) Return(lp2 *mm_appv1alpha.LivenessResponse, err error) *AppPublicServiceServerMock { - if mmLiveness.mock.funcLiveness != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.InsertRow +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Return(ip2 *mm_appv1alpha.InsertRowResponse, err error) *AppPublicServiceServerMock { + if mmInsertRow.mock.funcInsertRow != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Set") } - if mmLiveness.defaultExpectation == nil { - mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{mock: mmLiveness.mock} + if mmInsertRow.defaultExpectation == nil { + mmInsertRow.defaultExpectation = &AppPublicServiceServerMockInsertRowExpectation{mock: mmInsertRow.mock} } - mmLiveness.defaultExpectation.results = &AppPublicServiceServerMockLivenessResults{lp2, err} - mmLiveness.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmLiveness.mock + mmInsertRow.defaultExpectation.results = &AppPublicServiceServerMockInsertRowResults{ip2, err} + mmInsertRow.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmInsertRow.mock } -// Set uses given function f to mock the AppPublicServiceServer.Liveness method -func (mmLiveness *mAppPublicServiceServerMockLiveness) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) (lp2 *mm_appv1alpha.LivenessResponse, err error)) *AppPublicServiceServerMock { - if mmLiveness.defaultExpectation != nil { - mmLiveness.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.Liveness method") +// Set uses given function f to mock the AppPublicServiceServer.InsertRow method +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Set(f func(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest) (ip2 *mm_appv1alpha.InsertRowResponse, err error)) *AppPublicServiceServerMock { + if mmInsertRow.defaultExpectation != nil { + mmInsertRow.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.InsertRow method") } - if len(mmLiveness.expectations) > 0 { - mmLiveness.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.Liveness method") + if len(mmInsertRow.expectations) > 0 { + mmInsertRow.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.InsertRow method") } - mmLiveness.mock.funcLiveness = f - mmLiveness.mock.funcLivenessOrigin = minimock.CallerInfo(1) - return mmLiveness.mock + mmInsertRow.mock.funcInsertRow = f + mmInsertRow.mock.funcInsertRowOrigin = minimock.CallerInfo(1) + return mmInsertRow.mock } -// When sets expectation for the AppPublicServiceServer.Liveness which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.InsertRow which will trigger the result defined by the following // Then helper -func (mmLiveness *mAppPublicServiceServerMockLiveness) When(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) *AppPublicServiceServerMockLivenessExpectation { - if mmLiveness.mock.funcLiveness != nil { - mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) When(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest) *AppPublicServiceServerMockInsertRowExpectation { + if mmInsertRow.mock.funcInsertRow != nil { + mmInsertRow.mock.t.Fatalf("AppPublicServiceServerMock.InsertRow mock is already set by Set") } - expectation := &AppPublicServiceServerMockLivenessExpectation{ - mock: mmLiveness.mock, - params: &AppPublicServiceServerMockLivenessParams{ctx, lp1}, - expectationOrigins: AppPublicServiceServerMockLivenessExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockInsertRowExpectation{ + mock: mmInsertRow.mock, + params: &AppPublicServiceServerMockInsertRowParams{ctx, ip1}, + expectationOrigins: AppPublicServiceServerMockInsertRowExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmLiveness.expectations = append(mmLiveness.expectations, expectation) + mmInsertRow.expectations = append(mmInsertRow.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.Liveness return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockLivenessExpectation) Then(lp2 *mm_appv1alpha.LivenessResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockLivenessResults{lp2, err} +// Then sets up AppPublicServiceServer.InsertRow return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockInsertRowExpectation) Then(ip2 *mm_appv1alpha.InsertRowResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockInsertRowResults{ip2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.Liveness should be invoked -func (mmLiveness *mAppPublicServiceServerMockLiveness) Times(n uint64) *mAppPublicServiceServerMockLiveness { +// Times sets number of times AppPublicServiceServer.InsertRow should be invoked +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Times(n uint64) *mAppPublicServiceServerMockInsertRow { if n == 0 { - mmLiveness.mock.t.Fatalf("Times of AppPublicServiceServerMock.Liveness mock can not be zero") + mmInsertRow.mock.t.Fatalf("Times of AppPublicServiceServerMock.InsertRow mock can not be zero") } - mm_atomic.StoreUint64(&mmLiveness.expectedInvocations, n) - mmLiveness.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmLiveness + mm_atomic.StoreUint64(&mmInsertRow.expectedInvocations, n) + mmInsertRow.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmInsertRow } -func (mmLiveness *mAppPublicServiceServerMockLiveness) invocationsDone() bool { - if len(mmLiveness.expectations) == 0 && mmLiveness.defaultExpectation == nil && mmLiveness.mock.funcLiveness == nil { +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) invocationsDone() bool { + if len(mmInsertRow.expectations) == 0 && mmInsertRow.defaultExpectation == nil && mmInsertRow.mock.funcInsertRow == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmLiveness.mock.afterLivenessCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmLiveness.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmInsertRow.mock.afterInsertRowCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmInsertRow.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// Liveness implements mm_appv1alpha.AppPublicServiceServer -func (mmLiveness *AppPublicServiceServerMock) Liveness(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) (lp2 *mm_appv1alpha.LivenessResponse, err error) { - mm_atomic.AddUint64(&mmLiveness.beforeLivenessCounter, 1) - defer mm_atomic.AddUint64(&mmLiveness.afterLivenessCounter, 1) +// InsertRow implements mm_appv1alpha.AppPublicServiceServer +func (mmInsertRow *AppPublicServiceServerMock) InsertRow(ctx context.Context, ip1 *mm_appv1alpha.InsertRowRequest) (ip2 *mm_appv1alpha.InsertRowResponse, err error) { + mm_atomic.AddUint64(&mmInsertRow.beforeInsertRowCounter, 1) + defer mm_atomic.AddUint64(&mmInsertRow.afterInsertRowCounter, 1) - mmLiveness.t.Helper() + mmInsertRow.t.Helper() - if mmLiveness.inspectFuncLiveness != nil { - mmLiveness.inspectFuncLiveness(ctx, lp1) + if mmInsertRow.inspectFuncInsertRow != nil { + mmInsertRow.inspectFuncInsertRow(ctx, ip1) } - mm_params := AppPublicServiceServerMockLivenessParams{ctx, lp1} + mm_params := AppPublicServiceServerMockInsertRowParams{ctx, ip1} // Record call args - mmLiveness.LivenessMock.mutex.Lock() - mmLiveness.LivenessMock.callArgs = append(mmLiveness.LivenessMock.callArgs, &mm_params) - mmLiveness.LivenessMock.mutex.Unlock() + mmInsertRow.InsertRowMock.mutex.Lock() + mmInsertRow.InsertRowMock.callArgs = append(mmInsertRow.InsertRowMock.callArgs, &mm_params) + mmInsertRow.InsertRowMock.mutex.Unlock() - for _, e := range mmLiveness.LivenessMock.expectations { + for _, e := range mmInsertRow.InsertRowMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.lp2, e.results.err + return e.results.ip2, e.results.err } } - if mmLiveness.LivenessMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmLiveness.LivenessMock.defaultExpectation.Counter, 1) - mm_want := mmLiveness.LivenessMock.defaultExpectation.params - mm_want_ptrs := mmLiveness.LivenessMock.defaultExpectation.paramPtrs + if mmInsertRow.InsertRowMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmInsertRow.InsertRowMock.defaultExpectation.Counter, 1) + mm_want := mmInsertRow.InsertRowMock.defaultExpectation.params + mm_want_ptrs := mmInsertRow.InsertRowMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockLivenessParams{ctx, lp1} + mm_got := AppPublicServiceServerMockInsertRowParams{ctx, ip1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmLiveness.t.Errorf("AppPublicServiceServerMock.Liveness got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmLiveness.LivenessMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmInsertRow.t.Errorf("AppPublicServiceServerMock.InsertRow got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmInsertRow.InsertRowMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { - mmLiveness.t.Errorf("AppPublicServiceServerMock.Liveness got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmLiveness.LivenessMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + if mm_want_ptrs.ip1 != nil && !minimock.Equal(*mm_want_ptrs.ip1, mm_got.ip1) { + mmInsertRow.t.Errorf("AppPublicServiceServerMock.InsertRow got unexpected parameter ip1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmInsertRow.InsertRowMock.defaultExpectation.expectationOrigins.originIp1, *mm_want_ptrs.ip1, mm_got.ip1, minimock.Diff(*mm_want_ptrs.ip1, mm_got.ip1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmLiveness.t.Errorf("AppPublicServiceServerMock.Liveness got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmLiveness.LivenessMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmInsertRow.t.Errorf("AppPublicServiceServerMock.InsertRow got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmInsertRow.InsertRowMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmLiveness.LivenessMock.defaultExpectation.results + mm_results := mmInsertRow.InsertRowMock.defaultExpectation.results if mm_results == nil { - mmLiveness.t.Fatal("No results are set for the AppPublicServiceServerMock.Liveness") + mmInsertRow.t.Fatal("No results are set for the AppPublicServiceServerMock.InsertRow") } - return (*mm_results).lp2, (*mm_results).err + return (*mm_results).ip2, (*mm_results).err } - if mmLiveness.funcLiveness != nil { - return mmLiveness.funcLiveness(ctx, lp1) + if mmInsertRow.funcInsertRow != nil { + return mmInsertRow.funcInsertRow(ctx, ip1) } - mmLiveness.t.Fatalf("Unexpected call to AppPublicServiceServerMock.Liveness. %v %v", ctx, lp1) + mmInsertRow.t.Fatalf("Unexpected call to AppPublicServiceServerMock.InsertRow. %v %v", ctx, ip1) return } -// LivenessAfterCounter returns a count of finished AppPublicServiceServerMock.Liveness invocations -func (mmLiveness *AppPublicServiceServerMock) LivenessAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmLiveness.afterLivenessCounter) +// InsertRowAfterCounter returns a count of finished AppPublicServiceServerMock.InsertRow invocations +func (mmInsertRow *AppPublicServiceServerMock) InsertRowAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmInsertRow.afterInsertRowCounter) } -// LivenessBeforeCounter returns a count of AppPublicServiceServerMock.Liveness invocations -func (mmLiveness *AppPublicServiceServerMock) LivenessBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmLiveness.beforeLivenessCounter) +// InsertRowBeforeCounter returns a count of AppPublicServiceServerMock.InsertRow invocations +func (mmInsertRow *AppPublicServiceServerMock) InsertRowBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmInsertRow.beforeInsertRowCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.Liveness. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.InsertRow. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmLiveness *mAppPublicServiceServerMockLiveness) Calls() []*AppPublicServiceServerMockLivenessParams { - mmLiveness.mutex.RLock() +func (mmInsertRow *mAppPublicServiceServerMockInsertRow) Calls() []*AppPublicServiceServerMockInsertRowParams { + mmInsertRow.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockLivenessParams, len(mmLiveness.callArgs)) - copy(argCopy, mmLiveness.callArgs) + argCopy := make([]*AppPublicServiceServerMockInsertRowParams, len(mmInsertRow.callArgs)) + copy(argCopy, mmInsertRow.callArgs) - mmLiveness.mutex.RUnlock() + mmInsertRow.mutex.RUnlock() return argCopy } -// MinimockLivenessDone returns true if the count of the Liveness invocations corresponds +// MinimockInsertRowDone returns true if the count of the InsertRow invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockLivenessDone() bool { - if m.LivenessMock.optional { +func (m *AppPublicServiceServerMock) MinimockInsertRowDone() bool { + if m.InsertRowMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.LivenessMock.expectations { + for _, e := range m.InsertRowMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.LivenessMock.invocationsDone() + return m.InsertRowMock.invocationsDone() } -// MinimockLivenessInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockLivenessInspect() { - for _, e := range m.LivenessMock.expectations { +// MinimockInsertRowInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockInsertRowInspect() { + for _, e := range m.InsertRowMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.InsertRow at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterLivenessCounter := mm_atomic.LoadUint64(&m.afterLivenessCounter) + afterInsertRowCounter := mm_atomic.LoadUint64(&m.afterInsertRowCounter) // if default expectation was set then invocations count should be greater than zero - if m.LivenessMock.defaultExpectation != nil && afterLivenessCounter < 1 { - if m.LivenessMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s", m.LivenessMock.defaultExpectation.returnOrigin) + if m.InsertRowMock.defaultExpectation != nil && afterInsertRowCounter < 1 { + if m.InsertRowMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.InsertRow at\n%s", m.InsertRowMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s with params: %#v", m.LivenessMock.defaultExpectation.expectationOrigins.origin, *m.LivenessMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.InsertRow at\n%s with params: %#v", m.InsertRowMock.defaultExpectation.expectationOrigins.origin, *m.InsertRowMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcLiveness != nil && afterLivenessCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s", m.funcLivenessOrigin) + if m.funcInsertRow != nil && afterInsertRowCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.InsertRow at\n%s", m.funcInsertRowOrigin) } - if !m.LivenessMock.invocationsDone() && afterLivenessCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.Liveness at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.LivenessMock.expectedInvocations), m.LivenessMock.expectedInvocationsOrigin, afterLivenessCounter) + if !m.InsertRowMock.invocationsDone() && afterInsertRowCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.InsertRow at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.InsertRowMock.expectedInvocations), m.InsertRowMock.expectedInvocationsOrigin, afterInsertRowCounter) } } -type mAppPublicServiceServerMockReadiness struct { +type mAppPublicServiceServerMockListAgents struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockReadinessExpectation - expectations []*AppPublicServiceServerMockReadinessExpectation + defaultExpectation *AppPublicServiceServerMockListAgentsExpectation + expectations []*AppPublicServiceServerMockListAgentsExpectation - callArgs []*AppPublicServiceServerMockReadinessParams + callArgs []*AppPublicServiceServerMockListAgentsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockReadinessExpectation specifies expectation struct of the AppPublicServiceServer.Readiness -type AppPublicServiceServerMockReadinessExpectation struct { +// AppPublicServiceServerMockListAgentsExpectation specifies expectation struct of the AppPublicServiceServer.ListAgents +type AppPublicServiceServerMockListAgentsExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockReadinessParams - paramPtrs *AppPublicServiceServerMockReadinessParamPtrs - expectationOrigins AppPublicServiceServerMockReadinessExpectationOrigins - results *AppPublicServiceServerMockReadinessResults + params *AppPublicServiceServerMockListAgentsParams + paramPtrs *AppPublicServiceServerMockListAgentsParamPtrs + expectationOrigins AppPublicServiceServerMockListAgentsExpectationOrigins + results *AppPublicServiceServerMockListAgentsResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockReadinessParams contains parameters of the AppPublicServiceServer.Readiness -type AppPublicServiceServerMockReadinessParams struct { +// AppPublicServiceServerMockListAgentsParams contains parameters of the AppPublicServiceServer.ListAgents +type AppPublicServiceServerMockListAgentsParams struct { ctx context.Context - rp1 *mm_appv1alpha.ReadinessRequest + lp1 *mm_appv1alpha.ListAgentsRequest } -// AppPublicServiceServerMockReadinessParamPtrs contains pointers to parameters of the AppPublicServiceServer.Readiness -type AppPublicServiceServerMockReadinessParamPtrs struct { +// AppPublicServiceServerMockListAgentsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListAgents +type AppPublicServiceServerMockListAgentsParamPtrs struct { ctx *context.Context - rp1 **mm_appv1alpha.ReadinessRequest + lp1 **mm_appv1alpha.ListAgentsRequest } -// AppPublicServiceServerMockReadinessResults contains results of the AppPublicServiceServer.Readiness -type AppPublicServiceServerMockReadinessResults struct { - rp2 *mm_appv1alpha.ReadinessResponse +// AppPublicServiceServerMockListAgentsResults contains results of the AppPublicServiceServer.ListAgents +type AppPublicServiceServerMockListAgentsResults struct { + lp2 *mm_appv1alpha.ListAgentsResponse err error } -// AppPublicServiceServerMockReadinessOrigins contains origins of expectations of the AppPublicServiceServer.Readiness -type AppPublicServiceServerMockReadinessExpectationOrigins struct { +// AppPublicServiceServerMockListAgentsOrigins contains origins of expectations of the AppPublicServiceServer.ListAgents +type AppPublicServiceServerMockListAgentsExpectationOrigins struct { origin string originCtx string - originRp1 string + originLp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -7215,342 +7717,5487 @@ type AppPublicServiceServerMockReadinessExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmReadiness *mAppPublicServiceServerMockReadiness) Optional() *mAppPublicServiceServerMockReadiness { - mmReadiness.optional = true - return mmReadiness +func (mmListAgents *mAppPublicServiceServerMockListAgents) Optional() *mAppPublicServiceServerMockListAgents { + mmListAgents.optional = true + return mmListAgents } -// Expect sets up expected params for AppPublicServiceServer.Readiness -func (mmReadiness *mAppPublicServiceServerMockReadiness) Expect(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) *mAppPublicServiceServerMockReadiness { - if mmReadiness.mock.funcReadiness != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.ListAgents +func (mmListAgents *mAppPublicServiceServerMockListAgents) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) *mAppPublicServiceServerMockListAgents { + if mmListAgents.mock.funcListAgents != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") } - if mmReadiness.defaultExpectation == nil { - mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{} + if mmListAgents.defaultExpectation == nil { + mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{} } - if mmReadiness.defaultExpectation.paramPtrs != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by ExpectParams functions") + if mmListAgents.defaultExpectation.paramPtrs != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by ExpectParams functions") } - mmReadiness.defaultExpectation.params = &AppPublicServiceServerMockReadinessParams{ctx, rp1} - mmReadiness.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmReadiness.expectations { - if minimock.Equal(e.params, mmReadiness.defaultExpectation.params) { - mmReadiness.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmReadiness.defaultExpectation.params) + mmListAgents.defaultExpectation.params = &AppPublicServiceServerMockListAgentsParams{ctx, lp1} + mmListAgents.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListAgents.expectations { + if minimock.Equal(e.params, mmListAgents.defaultExpectation.params) { + mmListAgents.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListAgents.defaultExpectation.params) } } - return mmReadiness + return mmListAgents } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.Readiness -func (mmReadiness *mAppPublicServiceServerMockReadiness) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockReadiness { - if mmReadiness.mock.funcReadiness != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListAgents +func (mmListAgents *mAppPublicServiceServerMockListAgents) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListAgents { + if mmListAgents.mock.funcListAgents != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") } - if mmReadiness.defaultExpectation == nil { - mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{} + if mmListAgents.defaultExpectation == nil { + mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{} } - if mmReadiness.defaultExpectation.params != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Expect") + if mmListAgents.defaultExpectation.params != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Expect") + } + + if mmListAgents.defaultExpectation.paramPtrs == nil { + mmListAgents.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAgentsParamPtrs{} + } + mmListAgents.defaultExpectation.paramPtrs.ctx = &ctx + mmListAgents.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListAgents +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListAgents +func (mmListAgents *mAppPublicServiceServerMockListAgents) ExpectLp1Param2(lp1 *mm_appv1alpha.ListAgentsRequest) *mAppPublicServiceServerMockListAgents { + if mmListAgents.mock.funcListAgents != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") + } + + if mmListAgents.defaultExpectation == nil { + mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{} + } + + if mmListAgents.defaultExpectation.params != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Expect") + } + + if mmListAgents.defaultExpectation.paramPtrs == nil { + mmListAgents.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAgentsParamPtrs{} + } + mmListAgents.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListAgents.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListAgents +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListAgents +func (mmListAgents *mAppPublicServiceServerMockListAgents) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest)) *mAppPublicServiceServerMockListAgents { + if mmListAgents.mock.inspectFuncListAgents != nil { + mmListAgents.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListAgents") + } + + mmListAgents.mock.inspectFuncListAgents = f + + return mmListAgents +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListAgents +func (mmListAgents *mAppPublicServiceServerMockListAgents) Return(lp2 *mm_appv1alpha.ListAgentsResponse, err error) *AppPublicServiceServerMock { + if mmListAgents.mock.funcListAgents != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") + } + + if mmListAgents.defaultExpectation == nil { + mmListAgents.defaultExpectation = &AppPublicServiceServerMockListAgentsExpectation{mock: mmListAgents.mock} + } + mmListAgents.defaultExpectation.results = &AppPublicServiceServerMockListAgentsResults{lp2, err} + mmListAgents.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListAgents.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListAgents method +func (mmListAgents *mAppPublicServiceServerMockListAgents) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) (lp2 *mm_appv1alpha.ListAgentsResponse, err error)) *AppPublicServiceServerMock { + if mmListAgents.defaultExpectation != nil { + mmListAgents.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListAgents method") + } + + if len(mmListAgents.expectations) > 0 { + mmListAgents.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListAgents method") + } + + mmListAgents.mock.funcListAgents = f + mmListAgents.mock.funcListAgentsOrigin = minimock.CallerInfo(1) + return mmListAgents.mock +} + +// When sets expectation for the AppPublicServiceServer.ListAgents which will trigger the result defined by the following +// Then helper +func (mmListAgents *mAppPublicServiceServerMockListAgents) When(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) *AppPublicServiceServerMockListAgentsExpectation { + if mmListAgents.mock.funcListAgents != nil { + mmListAgents.mock.t.Fatalf("AppPublicServiceServerMock.ListAgents mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListAgentsExpectation{ + mock: mmListAgents.mock, + params: &AppPublicServiceServerMockListAgentsParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListAgentsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListAgents.expectations = append(mmListAgents.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListAgents return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListAgentsExpectation) Then(lp2 *mm_appv1alpha.ListAgentsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListAgentsResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListAgents should be invoked +func (mmListAgents *mAppPublicServiceServerMockListAgents) Times(n uint64) *mAppPublicServiceServerMockListAgents { + if n == 0 { + mmListAgents.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListAgents mock can not be zero") + } + mm_atomic.StoreUint64(&mmListAgents.expectedInvocations, n) + mmListAgents.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListAgents +} + +func (mmListAgents *mAppPublicServiceServerMockListAgents) invocationsDone() bool { + if len(mmListAgents.expectations) == 0 && mmListAgents.defaultExpectation == nil && mmListAgents.mock.funcListAgents == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListAgents.mock.afterListAgentsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListAgents.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListAgents implements mm_appv1alpha.AppPublicServiceServer +func (mmListAgents *AppPublicServiceServerMock) ListAgents(ctx context.Context, lp1 *mm_appv1alpha.ListAgentsRequest) (lp2 *mm_appv1alpha.ListAgentsResponse, err error) { + mm_atomic.AddUint64(&mmListAgents.beforeListAgentsCounter, 1) + defer mm_atomic.AddUint64(&mmListAgents.afterListAgentsCounter, 1) + + mmListAgents.t.Helper() + + if mmListAgents.inspectFuncListAgents != nil { + mmListAgents.inspectFuncListAgents(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListAgentsParams{ctx, lp1} + + // Record call args + mmListAgents.ListAgentsMock.mutex.Lock() + mmListAgents.ListAgentsMock.callArgs = append(mmListAgents.ListAgentsMock.callArgs, &mm_params) + mmListAgents.ListAgentsMock.mutex.Unlock() + + for _, e := range mmListAgents.ListAgentsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListAgents.ListAgentsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListAgents.ListAgentsMock.defaultExpectation.Counter, 1) + mm_want := mmListAgents.ListAgentsMock.defaultExpectation.params + mm_want_ptrs := mmListAgents.ListAgentsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListAgentsParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListAgents.t.Errorf("AppPublicServiceServerMock.ListAgents got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListAgents.ListAgentsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListAgents.t.Errorf("AppPublicServiceServerMock.ListAgents got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListAgents.ListAgentsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListAgents.t.Errorf("AppPublicServiceServerMock.ListAgents got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListAgents.ListAgentsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListAgents.ListAgentsMock.defaultExpectation.results + if mm_results == nil { + mmListAgents.t.Fatal("No results are set for the AppPublicServiceServerMock.ListAgents") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListAgents.funcListAgents != nil { + return mmListAgents.funcListAgents(ctx, lp1) + } + mmListAgents.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListAgents. %v %v", ctx, lp1) + return +} + +// ListAgentsAfterCounter returns a count of finished AppPublicServiceServerMock.ListAgents invocations +func (mmListAgents *AppPublicServiceServerMock) ListAgentsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListAgents.afterListAgentsCounter) +} + +// ListAgentsBeforeCounter returns a count of AppPublicServiceServerMock.ListAgents invocations +func (mmListAgents *AppPublicServiceServerMock) ListAgentsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListAgents.beforeListAgentsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListAgents. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListAgents *mAppPublicServiceServerMockListAgents) Calls() []*AppPublicServiceServerMockListAgentsParams { + mmListAgents.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListAgentsParams, len(mmListAgents.callArgs)) + copy(argCopy, mmListAgents.callArgs) + + mmListAgents.mutex.RUnlock() + + return argCopy +} + +// MinimockListAgentsDone returns true if the count of the ListAgents invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListAgentsDone() bool { + if m.ListAgentsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListAgentsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListAgentsMock.invocationsDone() +} + +// MinimockListAgentsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListAgentsInspect() { + for _, e := range m.ListAgentsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListAgentsCounter := mm_atomic.LoadUint64(&m.afterListAgentsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListAgentsMock.defaultExpectation != nil && afterListAgentsCounter < 1 { + if m.ListAgentsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s", m.ListAgentsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s with params: %#v", m.ListAgentsMock.defaultExpectation.expectationOrigins.origin, *m.ListAgentsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListAgents != nil && afterListAgentsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListAgents at\n%s", m.funcListAgentsOrigin) + } + + if !m.ListAgentsMock.invocationsDone() && afterListAgentsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListAgents at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListAgentsMock.expectedInvocations), m.ListAgentsMock.expectedInvocationsOrigin, afterListAgentsCounter) + } +} + +type mAppPublicServiceServerMockListApps struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListAppsExpectation + expectations []*AppPublicServiceServerMockListAppsExpectation + + callArgs []*AppPublicServiceServerMockListAppsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListAppsExpectation specifies expectation struct of the AppPublicServiceServer.ListApps +type AppPublicServiceServerMockListAppsExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListAppsParams + paramPtrs *AppPublicServiceServerMockListAppsParamPtrs + expectationOrigins AppPublicServiceServerMockListAppsExpectationOrigins + results *AppPublicServiceServerMockListAppsResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListAppsParams contains parameters of the AppPublicServiceServer.ListApps +type AppPublicServiceServerMockListAppsParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListAppsRequest +} + +// AppPublicServiceServerMockListAppsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListApps +type AppPublicServiceServerMockListAppsParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListAppsRequest +} + +// AppPublicServiceServerMockListAppsResults contains results of the AppPublicServiceServer.ListApps +type AppPublicServiceServerMockListAppsResults struct { + lp2 *mm_appv1alpha.ListAppsResponse + err error +} + +// AppPublicServiceServerMockListAppsOrigins contains origins of expectations of the AppPublicServiceServer.ListApps +type AppPublicServiceServerMockListAppsExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListApps *mAppPublicServiceServerMockListApps) Optional() *mAppPublicServiceServerMockListApps { + mmListApps.optional = true + return mmListApps +} + +// Expect sets up expected params for AppPublicServiceServer.ListApps +func (mmListApps *mAppPublicServiceServerMockListApps) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) *mAppPublicServiceServerMockListApps { + if mmListApps.mock.funcListApps != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") + } + + if mmListApps.defaultExpectation == nil { + mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{} + } + + if mmListApps.defaultExpectation.paramPtrs != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by ExpectParams functions") + } + + mmListApps.defaultExpectation.params = &AppPublicServiceServerMockListAppsParams{ctx, lp1} + mmListApps.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListApps.expectations { + if minimock.Equal(e.params, mmListApps.defaultExpectation.params) { + mmListApps.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListApps.defaultExpectation.params) + } + } + + return mmListApps +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListApps +func (mmListApps *mAppPublicServiceServerMockListApps) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListApps { + if mmListApps.mock.funcListApps != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") + } + + if mmListApps.defaultExpectation == nil { + mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{} + } + + if mmListApps.defaultExpectation.params != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Expect") + } + + if mmListApps.defaultExpectation.paramPtrs == nil { + mmListApps.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAppsParamPtrs{} + } + mmListApps.defaultExpectation.paramPtrs.ctx = &ctx + mmListApps.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListApps +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListApps +func (mmListApps *mAppPublicServiceServerMockListApps) ExpectLp1Param2(lp1 *mm_appv1alpha.ListAppsRequest) *mAppPublicServiceServerMockListApps { + if mmListApps.mock.funcListApps != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") + } + + if mmListApps.defaultExpectation == nil { + mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{} + } + + if mmListApps.defaultExpectation.params != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Expect") + } + + if mmListApps.defaultExpectation.paramPtrs == nil { + mmListApps.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListAppsParamPtrs{} + } + mmListApps.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListApps.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListApps +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListApps +func (mmListApps *mAppPublicServiceServerMockListApps) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest)) *mAppPublicServiceServerMockListApps { + if mmListApps.mock.inspectFuncListApps != nil { + mmListApps.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListApps") + } + + mmListApps.mock.inspectFuncListApps = f + + return mmListApps +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListApps +func (mmListApps *mAppPublicServiceServerMockListApps) Return(lp2 *mm_appv1alpha.ListAppsResponse, err error) *AppPublicServiceServerMock { + if mmListApps.mock.funcListApps != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") + } + + if mmListApps.defaultExpectation == nil { + mmListApps.defaultExpectation = &AppPublicServiceServerMockListAppsExpectation{mock: mmListApps.mock} + } + mmListApps.defaultExpectation.results = &AppPublicServiceServerMockListAppsResults{lp2, err} + mmListApps.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListApps.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListApps method +func (mmListApps *mAppPublicServiceServerMockListApps) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) (lp2 *mm_appv1alpha.ListAppsResponse, err error)) *AppPublicServiceServerMock { + if mmListApps.defaultExpectation != nil { + mmListApps.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListApps method") + } + + if len(mmListApps.expectations) > 0 { + mmListApps.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListApps method") + } + + mmListApps.mock.funcListApps = f + mmListApps.mock.funcListAppsOrigin = minimock.CallerInfo(1) + return mmListApps.mock +} + +// When sets expectation for the AppPublicServiceServer.ListApps which will trigger the result defined by the following +// Then helper +func (mmListApps *mAppPublicServiceServerMockListApps) When(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) *AppPublicServiceServerMockListAppsExpectation { + if mmListApps.mock.funcListApps != nil { + mmListApps.mock.t.Fatalf("AppPublicServiceServerMock.ListApps mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListAppsExpectation{ + mock: mmListApps.mock, + params: &AppPublicServiceServerMockListAppsParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListAppsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListApps.expectations = append(mmListApps.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListApps return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListAppsExpectation) Then(lp2 *mm_appv1alpha.ListAppsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListAppsResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListApps should be invoked +func (mmListApps *mAppPublicServiceServerMockListApps) Times(n uint64) *mAppPublicServiceServerMockListApps { + if n == 0 { + mmListApps.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListApps mock can not be zero") + } + mm_atomic.StoreUint64(&mmListApps.expectedInvocations, n) + mmListApps.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListApps +} + +func (mmListApps *mAppPublicServiceServerMockListApps) invocationsDone() bool { + if len(mmListApps.expectations) == 0 && mmListApps.defaultExpectation == nil && mmListApps.mock.funcListApps == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListApps.mock.afterListAppsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListApps.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListApps implements mm_appv1alpha.AppPublicServiceServer +func (mmListApps *AppPublicServiceServerMock) ListApps(ctx context.Context, lp1 *mm_appv1alpha.ListAppsRequest) (lp2 *mm_appv1alpha.ListAppsResponse, err error) { + mm_atomic.AddUint64(&mmListApps.beforeListAppsCounter, 1) + defer mm_atomic.AddUint64(&mmListApps.afterListAppsCounter, 1) + + mmListApps.t.Helper() + + if mmListApps.inspectFuncListApps != nil { + mmListApps.inspectFuncListApps(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListAppsParams{ctx, lp1} + + // Record call args + mmListApps.ListAppsMock.mutex.Lock() + mmListApps.ListAppsMock.callArgs = append(mmListApps.ListAppsMock.callArgs, &mm_params) + mmListApps.ListAppsMock.mutex.Unlock() + + for _, e := range mmListApps.ListAppsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListApps.ListAppsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListApps.ListAppsMock.defaultExpectation.Counter, 1) + mm_want := mmListApps.ListAppsMock.defaultExpectation.params + mm_want_ptrs := mmListApps.ListAppsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListAppsParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListApps.t.Errorf("AppPublicServiceServerMock.ListApps got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListApps.ListAppsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListApps.t.Errorf("AppPublicServiceServerMock.ListApps got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListApps.ListAppsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListApps.t.Errorf("AppPublicServiceServerMock.ListApps got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListApps.ListAppsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListApps.ListAppsMock.defaultExpectation.results + if mm_results == nil { + mmListApps.t.Fatal("No results are set for the AppPublicServiceServerMock.ListApps") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListApps.funcListApps != nil { + return mmListApps.funcListApps(ctx, lp1) + } + mmListApps.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListApps. %v %v", ctx, lp1) + return +} + +// ListAppsAfterCounter returns a count of finished AppPublicServiceServerMock.ListApps invocations +func (mmListApps *AppPublicServiceServerMock) ListAppsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListApps.afterListAppsCounter) +} + +// ListAppsBeforeCounter returns a count of AppPublicServiceServerMock.ListApps invocations +func (mmListApps *AppPublicServiceServerMock) ListAppsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListApps.beforeListAppsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListApps. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListApps *mAppPublicServiceServerMockListApps) Calls() []*AppPublicServiceServerMockListAppsParams { + mmListApps.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListAppsParams, len(mmListApps.callArgs)) + copy(argCopy, mmListApps.callArgs) + + mmListApps.mutex.RUnlock() + + return argCopy +} + +// MinimockListAppsDone returns true if the count of the ListApps invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListAppsDone() bool { + if m.ListAppsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListAppsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListAppsMock.invocationsDone() +} + +// MinimockListAppsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListAppsInspect() { + for _, e := range m.ListAppsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListAppsCounter := mm_atomic.LoadUint64(&m.afterListAppsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListAppsMock.defaultExpectation != nil && afterListAppsCounter < 1 { + if m.ListAppsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s", m.ListAppsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s with params: %#v", m.ListAppsMock.defaultExpectation.expectationOrigins.origin, *m.ListAppsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListApps != nil && afterListAppsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListApps at\n%s", m.funcListAppsOrigin) + } + + if !m.ListAppsMock.invocationsDone() && afterListAppsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListApps at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListAppsMock.expectedInvocations), m.ListAppsMock.expectedInvocationsOrigin, afterListAppsCounter) + } +} + +type mAppPublicServiceServerMockListChatMessages struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListChatMessagesExpectation + expectations []*AppPublicServiceServerMockListChatMessagesExpectation + + callArgs []*AppPublicServiceServerMockListChatMessagesParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListChatMessagesExpectation specifies expectation struct of the AppPublicServiceServer.ListChatMessages +type AppPublicServiceServerMockListChatMessagesExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListChatMessagesParams + paramPtrs *AppPublicServiceServerMockListChatMessagesParamPtrs + expectationOrigins AppPublicServiceServerMockListChatMessagesExpectationOrigins + results *AppPublicServiceServerMockListChatMessagesResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListChatMessagesParams contains parameters of the AppPublicServiceServer.ListChatMessages +type AppPublicServiceServerMockListChatMessagesParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListChatMessagesRequest +} + +// AppPublicServiceServerMockListChatMessagesParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListChatMessages +type AppPublicServiceServerMockListChatMessagesParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListChatMessagesRequest +} + +// AppPublicServiceServerMockListChatMessagesResults contains results of the AppPublicServiceServer.ListChatMessages +type AppPublicServiceServerMockListChatMessagesResults struct { + lp2 *mm_appv1alpha.ListChatMessagesResponse + err error +} + +// AppPublicServiceServerMockListChatMessagesOrigins contains origins of expectations of the AppPublicServiceServer.ListChatMessages +type AppPublicServiceServerMockListChatMessagesExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Optional() *mAppPublicServiceServerMockListChatMessages { + mmListChatMessages.optional = true + return mmListChatMessages +} + +// Expect sets up expected params for AppPublicServiceServer.ListChatMessages +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) *mAppPublicServiceServerMockListChatMessages { + if mmListChatMessages.mock.funcListChatMessages != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") + } + + if mmListChatMessages.defaultExpectation == nil { + mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{} + } + + if mmListChatMessages.defaultExpectation.paramPtrs != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by ExpectParams functions") + } + + mmListChatMessages.defaultExpectation.params = &AppPublicServiceServerMockListChatMessagesParams{ctx, lp1} + mmListChatMessages.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListChatMessages.expectations { + if minimock.Equal(e.params, mmListChatMessages.defaultExpectation.params) { + mmListChatMessages.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListChatMessages.defaultExpectation.params) + } + } + + return mmListChatMessages +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListChatMessages +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListChatMessages { + if mmListChatMessages.mock.funcListChatMessages != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") + } + + if mmListChatMessages.defaultExpectation == nil { + mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{} + } + + if mmListChatMessages.defaultExpectation.params != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Expect") + } + + if mmListChatMessages.defaultExpectation.paramPtrs == nil { + mmListChatMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatMessagesParamPtrs{} + } + mmListChatMessages.defaultExpectation.paramPtrs.ctx = &ctx + mmListChatMessages.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListChatMessages +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListChatMessages +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) ExpectLp1Param2(lp1 *mm_appv1alpha.ListChatMessagesRequest) *mAppPublicServiceServerMockListChatMessages { + if mmListChatMessages.mock.funcListChatMessages != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") + } + + if mmListChatMessages.defaultExpectation == nil { + mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{} + } + + if mmListChatMessages.defaultExpectation.params != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Expect") + } + + if mmListChatMessages.defaultExpectation.paramPtrs == nil { + mmListChatMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatMessagesParamPtrs{} + } + mmListChatMessages.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListChatMessages.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListChatMessages +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListChatMessages +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest)) *mAppPublicServiceServerMockListChatMessages { + if mmListChatMessages.mock.inspectFuncListChatMessages != nil { + mmListChatMessages.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListChatMessages") + } + + mmListChatMessages.mock.inspectFuncListChatMessages = f + + return mmListChatMessages +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListChatMessages +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Return(lp2 *mm_appv1alpha.ListChatMessagesResponse, err error) *AppPublicServiceServerMock { + if mmListChatMessages.mock.funcListChatMessages != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") + } + + if mmListChatMessages.defaultExpectation == nil { + mmListChatMessages.defaultExpectation = &AppPublicServiceServerMockListChatMessagesExpectation{mock: mmListChatMessages.mock} + } + mmListChatMessages.defaultExpectation.results = &AppPublicServiceServerMockListChatMessagesResults{lp2, err} + mmListChatMessages.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListChatMessages.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListChatMessages method +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) (lp2 *mm_appv1alpha.ListChatMessagesResponse, err error)) *AppPublicServiceServerMock { + if mmListChatMessages.defaultExpectation != nil { + mmListChatMessages.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListChatMessages method") + } + + if len(mmListChatMessages.expectations) > 0 { + mmListChatMessages.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListChatMessages method") + } + + mmListChatMessages.mock.funcListChatMessages = f + mmListChatMessages.mock.funcListChatMessagesOrigin = minimock.CallerInfo(1) + return mmListChatMessages.mock +} + +// When sets expectation for the AppPublicServiceServer.ListChatMessages which will trigger the result defined by the following +// Then helper +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) When(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) *AppPublicServiceServerMockListChatMessagesExpectation { + if mmListChatMessages.mock.funcListChatMessages != nil { + mmListChatMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListChatMessages mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListChatMessagesExpectation{ + mock: mmListChatMessages.mock, + params: &AppPublicServiceServerMockListChatMessagesParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListChatMessagesExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListChatMessages.expectations = append(mmListChatMessages.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListChatMessages return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListChatMessagesExpectation) Then(lp2 *mm_appv1alpha.ListChatMessagesResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListChatMessagesResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListChatMessages should be invoked +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Times(n uint64) *mAppPublicServiceServerMockListChatMessages { + if n == 0 { + mmListChatMessages.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListChatMessages mock can not be zero") + } + mm_atomic.StoreUint64(&mmListChatMessages.expectedInvocations, n) + mmListChatMessages.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListChatMessages +} + +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) invocationsDone() bool { + if len(mmListChatMessages.expectations) == 0 && mmListChatMessages.defaultExpectation == nil && mmListChatMessages.mock.funcListChatMessages == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListChatMessages.mock.afterListChatMessagesCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListChatMessages.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListChatMessages implements mm_appv1alpha.AppPublicServiceServer +func (mmListChatMessages *AppPublicServiceServerMock) ListChatMessages(ctx context.Context, lp1 *mm_appv1alpha.ListChatMessagesRequest) (lp2 *mm_appv1alpha.ListChatMessagesResponse, err error) { + mm_atomic.AddUint64(&mmListChatMessages.beforeListChatMessagesCounter, 1) + defer mm_atomic.AddUint64(&mmListChatMessages.afterListChatMessagesCounter, 1) + + mmListChatMessages.t.Helper() + + if mmListChatMessages.inspectFuncListChatMessages != nil { + mmListChatMessages.inspectFuncListChatMessages(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListChatMessagesParams{ctx, lp1} + + // Record call args + mmListChatMessages.ListChatMessagesMock.mutex.Lock() + mmListChatMessages.ListChatMessagesMock.callArgs = append(mmListChatMessages.ListChatMessagesMock.callArgs, &mm_params) + mmListChatMessages.ListChatMessagesMock.mutex.Unlock() + + for _, e := range mmListChatMessages.ListChatMessagesMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListChatMessages.ListChatMessagesMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListChatMessages.ListChatMessagesMock.defaultExpectation.Counter, 1) + mm_want := mmListChatMessages.ListChatMessagesMock.defaultExpectation.params + mm_want_ptrs := mmListChatMessages.ListChatMessagesMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListChatMessagesParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListChatMessages.t.Errorf("AppPublicServiceServerMock.ListChatMessages got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListChatMessages.ListChatMessagesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListChatMessages.t.Errorf("AppPublicServiceServerMock.ListChatMessages got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListChatMessages.ListChatMessagesMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListChatMessages.t.Errorf("AppPublicServiceServerMock.ListChatMessages got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListChatMessages.ListChatMessagesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListChatMessages.ListChatMessagesMock.defaultExpectation.results + if mm_results == nil { + mmListChatMessages.t.Fatal("No results are set for the AppPublicServiceServerMock.ListChatMessages") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListChatMessages.funcListChatMessages != nil { + return mmListChatMessages.funcListChatMessages(ctx, lp1) + } + mmListChatMessages.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListChatMessages. %v %v", ctx, lp1) + return +} + +// ListChatMessagesAfterCounter returns a count of finished AppPublicServiceServerMock.ListChatMessages invocations +func (mmListChatMessages *AppPublicServiceServerMock) ListChatMessagesAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListChatMessages.afterListChatMessagesCounter) +} + +// ListChatMessagesBeforeCounter returns a count of AppPublicServiceServerMock.ListChatMessages invocations +func (mmListChatMessages *AppPublicServiceServerMock) ListChatMessagesBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListChatMessages.beforeListChatMessagesCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListChatMessages. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListChatMessages *mAppPublicServiceServerMockListChatMessages) Calls() []*AppPublicServiceServerMockListChatMessagesParams { + mmListChatMessages.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListChatMessagesParams, len(mmListChatMessages.callArgs)) + copy(argCopy, mmListChatMessages.callArgs) + + mmListChatMessages.mutex.RUnlock() + + return argCopy +} + +// MinimockListChatMessagesDone returns true if the count of the ListChatMessages invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListChatMessagesDone() bool { + if m.ListChatMessagesMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListChatMessagesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListChatMessagesMock.invocationsDone() +} + +// MinimockListChatMessagesInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListChatMessagesInspect() { + for _, e := range m.ListChatMessagesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListChatMessagesCounter := mm_atomic.LoadUint64(&m.afterListChatMessagesCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListChatMessagesMock.defaultExpectation != nil && afterListChatMessagesCounter < 1 { + if m.ListChatMessagesMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s", m.ListChatMessagesMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s with params: %#v", m.ListChatMessagesMock.defaultExpectation.expectationOrigins.origin, *m.ListChatMessagesMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListChatMessages != nil && afterListChatMessagesCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChatMessages at\n%s", m.funcListChatMessagesOrigin) + } + + if !m.ListChatMessagesMock.invocationsDone() && afterListChatMessagesCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListChatMessages at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListChatMessagesMock.expectedInvocations), m.ListChatMessagesMock.expectedInvocationsOrigin, afterListChatMessagesCounter) + } +} + +type mAppPublicServiceServerMockListChats struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListChatsExpectation + expectations []*AppPublicServiceServerMockListChatsExpectation + + callArgs []*AppPublicServiceServerMockListChatsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListChatsExpectation specifies expectation struct of the AppPublicServiceServer.ListChats +type AppPublicServiceServerMockListChatsExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListChatsParams + paramPtrs *AppPublicServiceServerMockListChatsParamPtrs + expectationOrigins AppPublicServiceServerMockListChatsExpectationOrigins + results *AppPublicServiceServerMockListChatsResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListChatsParams contains parameters of the AppPublicServiceServer.ListChats +type AppPublicServiceServerMockListChatsParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListChatsRequest +} + +// AppPublicServiceServerMockListChatsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListChats +type AppPublicServiceServerMockListChatsParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListChatsRequest +} + +// AppPublicServiceServerMockListChatsResults contains results of the AppPublicServiceServer.ListChats +type AppPublicServiceServerMockListChatsResults struct { + lp2 *mm_appv1alpha.ListChatsResponse + err error +} + +// AppPublicServiceServerMockListChatsOrigins contains origins of expectations of the AppPublicServiceServer.ListChats +type AppPublicServiceServerMockListChatsExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListChats *mAppPublicServiceServerMockListChats) Optional() *mAppPublicServiceServerMockListChats { + mmListChats.optional = true + return mmListChats +} + +// Expect sets up expected params for AppPublicServiceServer.ListChats +func (mmListChats *mAppPublicServiceServerMockListChats) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) *mAppPublicServiceServerMockListChats { + if mmListChats.mock.funcListChats != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") + } + + if mmListChats.defaultExpectation == nil { + mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{} + } + + if mmListChats.defaultExpectation.paramPtrs != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by ExpectParams functions") + } + + mmListChats.defaultExpectation.params = &AppPublicServiceServerMockListChatsParams{ctx, lp1} + mmListChats.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListChats.expectations { + if minimock.Equal(e.params, mmListChats.defaultExpectation.params) { + mmListChats.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListChats.defaultExpectation.params) + } + } + + return mmListChats +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListChats +func (mmListChats *mAppPublicServiceServerMockListChats) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListChats { + if mmListChats.mock.funcListChats != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") + } + + if mmListChats.defaultExpectation == nil { + mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{} + } + + if mmListChats.defaultExpectation.params != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Expect") + } + + if mmListChats.defaultExpectation.paramPtrs == nil { + mmListChats.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatsParamPtrs{} + } + mmListChats.defaultExpectation.paramPtrs.ctx = &ctx + mmListChats.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListChats +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListChats +func (mmListChats *mAppPublicServiceServerMockListChats) ExpectLp1Param2(lp1 *mm_appv1alpha.ListChatsRequest) *mAppPublicServiceServerMockListChats { + if mmListChats.mock.funcListChats != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") + } + + if mmListChats.defaultExpectation == nil { + mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{} + } + + if mmListChats.defaultExpectation.params != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Expect") + } + + if mmListChats.defaultExpectation.paramPtrs == nil { + mmListChats.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListChatsParamPtrs{} + } + mmListChats.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListChats.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListChats +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListChats +func (mmListChats *mAppPublicServiceServerMockListChats) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest)) *mAppPublicServiceServerMockListChats { + if mmListChats.mock.inspectFuncListChats != nil { + mmListChats.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListChats") + } + + mmListChats.mock.inspectFuncListChats = f + + return mmListChats +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListChats +func (mmListChats *mAppPublicServiceServerMockListChats) Return(lp2 *mm_appv1alpha.ListChatsResponse, err error) *AppPublicServiceServerMock { + if mmListChats.mock.funcListChats != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") + } + + if mmListChats.defaultExpectation == nil { + mmListChats.defaultExpectation = &AppPublicServiceServerMockListChatsExpectation{mock: mmListChats.mock} + } + mmListChats.defaultExpectation.results = &AppPublicServiceServerMockListChatsResults{lp2, err} + mmListChats.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListChats.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListChats method +func (mmListChats *mAppPublicServiceServerMockListChats) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) (lp2 *mm_appv1alpha.ListChatsResponse, err error)) *AppPublicServiceServerMock { + if mmListChats.defaultExpectation != nil { + mmListChats.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListChats method") + } + + if len(mmListChats.expectations) > 0 { + mmListChats.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListChats method") + } + + mmListChats.mock.funcListChats = f + mmListChats.mock.funcListChatsOrigin = minimock.CallerInfo(1) + return mmListChats.mock +} + +// When sets expectation for the AppPublicServiceServer.ListChats which will trigger the result defined by the following +// Then helper +func (mmListChats *mAppPublicServiceServerMockListChats) When(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) *AppPublicServiceServerMockListChatsExpectation { + if mmListChats.mock.funcListChats != nil { + mmListChats.mock.t.Fatalf("AppPublicServiceServerMock.ListChats mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListChatsExpectation{ + mock: mmListChats.mock, + params: &AppPublicServiceServerMockListChatsParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListChatsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListChats.expectations = append(mmListChats.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListChats return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListChatsExpectation) Then(lp2 *mm_appv1alpha.ListChatsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListChatsResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListChats should be invoked +func (mmListChats *mAppPublicServiceServerMockListChats) Times(n uint64) *mAppPublicServiceServerMockListChats { + if n == 0 { + mmListChats.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListChats mock can not be zero") + } + mm_atomic.StoreUint64(&mmListChats.expectedInvocations, n) + mmListChats.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListChats +} + +func (mmListChats *mAppPublicServiceServerMockListChats) invocationsDone() bool { + if len(mmListChats.expectations) == 0 && mmListChats.defaultExpectation == nil && mmListChats.mock.funcListChats == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListChats.mock.afterListChatsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListChats.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListChats implements mm_appv1alpha.AppPublicServiceServer +func (mmListChats *AppPublicServiceServerMock) ListChats(ctx context.Context, lp1 *mm_appv1alpha.ListChatsRequest) (lp2 *mm_appv1alpha.ListChatsResponse, err error) { + mm_atomic.AddUint64(&mmListChats.beforeListChatsCounter, 1) + defer mm_atomic.AddUint64(&mmListChats.afterListChatsCounter, 1) + + mmListChats.t.Helper() + + if mmListChats.inspectFuncListChats != nil { + mmListChats.inspectFuncListChats(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListChatsParams{ctx, lp1} + + // Record call args + mmListChats.ListChatsMock.mutex.Lock() + mmListChats.ListChatsMock.callArgs = append(mmListChats.ListChatsMock.callArgs, &mm_params) + mmListChats.ListChatsMock.mutex.Unlock() + + for _, e := range mmListChats.ListChatsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListChats.ListChatsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListChats.ListChatsMock.defaultExpectation.Counter, 1) + mm_want := mmListChats.ListChatsMock.defaultExpectation.params + mm_want_ptrs := mmListChats.ListChatsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListChatsParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListChats.t.Errorf("AppPublicServiceServerMock.ListChats got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListChats.ListChatsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListChats.t.Errorf("AppPublicServiceServerMock.ListChats got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListChats.ListChatsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListChats.t.Errorf("AppPublicServiceServerMock.ListChats got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListChats.ListChatsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListChats.ListChatsMock.defaultExpectation.results + if mm_results == nil { + mmListChats.t.Fatal("No results are set for the AppPublicServiceServerMock.ListChats") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListChats.funcListChats != nil { + return mmListChats.funcListChats(ctx, lp1) + } + mmListChats.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListChats. %v %v", ctx, lp1) + return +} + +// ListChatsAfterCounter returns a count of finished AppPublicServiceServerMock.ListChats invocations +func (mmListChats *AppPublicServiceServerMock) ListChatsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListChats.afterListChatsCounter) +} + +// ListChatsBeforeCounter returns a count of AppPublicServiceServerMock.ListChats invocations +func (mmListChats *AppPublicServiceServerMock) ListChatsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListChats.beforeListChatsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListChats. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListChats *mAppPublicServiceServerMockListChats) Calls() []*AppPublicServiceServerMockListChatsParams { + mmListChats.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListChatsParams, len(mmListChats.callArgs)) + copy(argCopy, mmListChats.callArgs) + + mmListChats.mutex.RUnlock() + + return argCopy +} + +// MinimockListChatsDone returns true if the count of the ListChats invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListChatsDone() bool { + if m.ListChatsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListChatsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListChatsMock.invocationsDone() +} + +// MinimockListChatsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListChatsInspect() { + for _, e := range m.ListChatsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListChatsCounter := mm_atomic.LoadUint64(&m.afterListChatsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListChatsMock.defaultExpectation != nil && afterListChatsCounter < 1 { + if m.ListChatsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s", m.ListChatsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s with params: %#v", m.ListChatsMock.defaultExpectation.expectationOrigins.origin, *m.ListChatsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListChats != nil && afterListChatsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListChats at\n%s", m.funcListChatsOrigin) + } + + if !m.ListChatsMock.invocationsDone() && afterListChatsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListChats at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListChatsMock.expectedInvocations), m.ListChatsMock.expectedInvocationsOrigin, afterListChatsCounter) + } +} + +type mAppPublicServiceServerMockListConversations struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListConversationsExpectation + expectations []*AppPublicServiceServerMockListConversationsExpectation + + callArgs []*AppPublicServiceServerMockListConversationsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListConversationsExpectation specifies expectation struct of the AppPublicServiceServer.ListConversations +type AppPublicServiceServerMockListConversationsExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListConversationsParams + paramPtrs *AppPublicServiceServerMockListConversationsParamPtrs + expectationOrigins AppPublicServiceServerMockListConversationsExpectationOrigins + results *AppPublicServiceServerMockListConversationsResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListConversationsParams contains parameters of the AppPublicServiceServer.ListConversations +type AppPublicServiceServerMockListConversationsParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListConversationsRequest +} + +// AppPublicServiceServerMockListConversationsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListConversations +type AppPublicServiceServerMockListConversationsParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListConversationsRequest +} + +// AppPublicServiceServerMockListConversationsResults contains results of the AppPublicServiceServer.ListConversations +type AppPublicServiceServerMockListConversationsResults struct { + lp2 *mm_appv1alpha.ListConversationsResponse + err error +} + +// AppPublicServiceServerMockListConversationsOrigins contains origins of expectations of the AppPublicServiceServer.ListConversations +type AppPublicServiceServerMockListConversationsExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListConversations *mAppPublicServiceServerMockListConversations) Optional() *mAppPublicServiceServerMockListConversations { + mmListConversations.optional = true + return mmListConversations +} + +// Expect sets up expected params for AppPublicServiceServer.ListConversations +func (mmListConversations *mAppPublicServiceServerMockListConversations) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) *mAppPublicServiceServerMockListConversations { + if mmListConversations.mock.funcListConversations != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") + } + + if mmListConversations.defaultExpectation == nil { + mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{} + } + + if mmListConversations.defaultExpectation.paramPtrs != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by ExpectParams functions") + } + + mmListConversations.defaultExpectation.params = &AppPublicServiceServerMockListConversationsParams{ctx, lp1} + mmListConversations.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListConversations.expectations { + if minimock.Equal(e.params, mmListConversations.defaultExpectation.params) { + mmListConversations.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListConversations.defaultExpectation.params) + } + } + + return mmListConversations +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListConversations +func (mmListConversations *mAppPublicServiceServerMockListConversations) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListConversations { + if mmListConversations.mock.funcListConversations != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") + } + + if mmListConversations.defaultExpectation == nil { + mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{} + } + + if mmListConversations.defaultExpectation.params != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Expect") + } + + if mmListConversations.defaultExpectation.paramPtrs == nil { + mmListConversations.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListConversationsParamPtrs{} + } + mmListConversations.defaultExpectation.paramPtrs.ctx = &ctx + mmListConversations.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListConversations +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListConversations +func (mmListConversations *mAppPublicServiceServerMockListConversations) ExpectLp1Param2(lp1 *mm_appv1alpha.ListConversationsRequest) *mAppPublicServiceServerMockListConversations { + if mmListConversations.mock.funcListConversations != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") + } + + if mmListConversations.defaultExpectation == nil { + mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{} + } + + if mmListConversations.defaultExpectation.params != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Expect") + } + + if mmListConversations.defaultExpectation.paramPtrs == nil { + mmListConversations.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListConversationsParamPtrs{} + } + mmListConversations.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListConversations.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListConversations +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListConversations +func (mmListConversations *mAppPublicServiceServerMockListConversations) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest)) *mAppPublicServiceServerMockListConversations { + if mmListConversations.mock.inspectFuncListConversations != nil { + mmListConversations.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListConversations") + } + + mmListConversations.mock.inspectFuncListConversations = f + + return mmListConversations +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListConversations +func (mmListConversations *mAppPublicServiceServerMockListConversations) Return(lp2 *mm_appv1alpha.ListConversationsResponse, err error) *AppPublicServiceServerMock { + if mmListConversations.mock.funcListConversations != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") + } + + if mmListConversations.defaultExpectation == nil { + mmListConversations.defaultExpectation = &AppPublicServiceServerMockListConversationsExpectation{mock: mmListConversations.mock} + } + mmListConversations.defaultExpectation.results = &AppPublicServiceServerMockListConversationsResults{lp2, err} + mmListConversations.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListConversations.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListConversations method +func (mmListConversations *mAppPublicServiceServerMockListConversations) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) (lp2 *mm_appv1alpha.ListConversationsResponse, err error)) *AppPublicServiceServerMock { + if mmListConversations.defaultExpectation != nil { + mmListConversations.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListConversations method") + } + + if len(mmListConversations.expectations) > 0 { + mmListConversations.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListConversations method") + } + + mmListConversations.mock.funcListConversations = f + mmListConversations.mock.funcListConversationsOrigin = minimock.CallerInfo(1) + return mmListConversations.mock +} + +// When sets expectation for the AppPublicServiceServer.ListConversations which will trigger the result defined by the following +// Then helper +func (mmListConversations *mAppPublicServiceServerMockListConversations) When(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) *AppPublicServiceServerMockListConversationsExpectation { + if mmListConversations.mock.funcListConversations != nil { + mmListConversations.mock.t.Fatalf("AppPublicServiceServerMock.ListConversations mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListConversationsExpectation{ + mock: mmListConversations.mock, + params: &AppPublicServiceServerMockListConversationsParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListConversationsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListConversations.expectations = append(mmListConversations.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListConversations return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListConversationsExpectation) Then(lp2 *mm_appv1alpha.ListConversationsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListConversationsResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListConversations should be invoked +func (mmListConversations *mAppPublicServiceServerMockListConversations) Times(n uint64) *mAppPublicServiceServerMockListConversations { + if n == 0 { + mmListConversations.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListConversations mock can not be zero") + } + mm_atomic.StoreUint64(&mmListConversations.expectedInvocations, n) + mmListConversations.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListConversations +} + +func (mmListConversations *mAppPublicServiceServerMockListConversations) invocationsDone() bool { + if len(mmListConversations.expectations) == 0 && mmListConversations.defaultExpectation == nil && mmListConversations.mock.funcListConversations == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListConversations.mock.afterListConversationsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListConversations.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListConversations implements mm_appv1alpha.AppPublicServiceServer +func (mmListConversations *AppPublicServiceServerMock) ListConversations(ctx context.Context, lp1 *mm_appv1alpha.ListConversationsRequest) (lp2 *mm_appv1alpha.ListConversationsResponse, err error) { + mm_atomic.AddUint64(&mmListConversations.beforeListConversationsCounter, 1) + defer mm_atomic.AddUint64(&mmListConversations.afterListConversationsCounter, 1) + + mmListConversations.t.Helper() + + if mmListConversations.inspectFuncListConversations != nil { + mmListConversations.inspectFuncListConversations(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListConversationsParams{ctx, lp1} + + // Record call args + mmListConversations.ListConversationsMock.mutex.Lock() + mmListConversations.ListConversationsMock.callArgs = append(mmListConversations.ListConversationsMock.callArgs, &mm_params) + mmListConversations.ListConversationsMock.mutex.Unlock() + + for _, e := range mmListConversations.ListConversationsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListConversations.ListConversationsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListConversations.ListConversationsMock.defaultExpectation.Counter, 1) + mm_want := mmListConversations.ListConversationsMock.defaultExpectation.params + mm_want_ptrs := mmListConversations.ListConversationsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListConversationsParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListConversations.t.Errorf("AppPublicServiceServerMock.ListConversations got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListConversations.ListConversationsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListConversations.t.Errorf("AppPublicServiceServerMock.ListConversations got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListConversations.ListConversationsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListConversations.t.Errorf("AppPublicServiceServerMock.ListConversations got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListConversations.ListConversationsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListConversations.ListConversationsMock.defaultExpectation.results + if mm_results == nil { + mmListConversations.t.Fatal("No results are set for the AppPublicServiceServerMock.ListConversations") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListConversations.funcListConversations != nil { + return mmListConversations.funcListConversations(ctx, lp1) + } + mmListConversations.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListConversations. %v %v", ctx, lp1) + return +} + +// ListConversationsAfterCounter returns a count of finished AppPublicServiceServerMock.ListConversations invocations +func (mmListConversations *AppPublicServiceServerMock) ListConversationsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListConversations.afterListConversationsCounter) +} + +// ListConversationsBeforeCounter returns a count of AppPublicServiceServerMock.ListConversations invocations +func (mmListConversations *AppPublicServiceServerMock) ListConversationsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListConversations.beforeListConversationsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListConversations. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListConversations *mAppPublicServiceServerMockListConversations) Calls() []*AppPublicServiceServerMockListConversationsParams { + mmListConversations.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListConversationsParams, len(mmListConversations.callArgs)) + copy(argCopy, mmListConversations.callArgs) + + mmListConversations.mutex.RUnlock() + + return argCopy +} + +// MinimockListConversationsDone returns true if the count of the ListConversations invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListConversationsDone() bool { + if m.ListConversationsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListConversationsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListConversationsMock.invocationsDone() +} + +// MinimockListConversationsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListConversationsInspect() { + for _, e := range m.ListConversationsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListConversationsCounter := mm_atomic.LoadUint64(&m.afterListConversationsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListConversationsMock.defaultExpectation != nil && afterListConversationsCounter < 1 { + if m.ListConversationsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s", m.ListConversationsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s with params: %#v", m.ListConversationsMock.defaultExpectation.expectationOrigins.origin, *m.ListConversationsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListConversations != nil && afterListConversationsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListConversations at\n%s", m.funcListConversationsOrigin) + } + + if !m.ListConversationsMock.invocationsDone() && afterListConversationsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListConversations at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListConversationsMock.expectedInvocations), m.ListConversationsMock.expectedInvocationsOrigin, afterListConversationsCounter) + } +} + +type mAppPublicServiceServerMockListMessages struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListMessagesExpectation + expectations []*AppPublicServiceServerMockListMessagesExpectation + + callArgs []*AppPublicServiceServerMockListMessagesParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListMessagesExpectation specifies expectation struct of the AppPublicServiceServer.ListMessages +type AppPublicServiceServerMockListMessagesExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListMessagesParams + paramPtrs *AppPublicServiceServerMockListMessagesParamPtrs + expectationOrigins AppPublicServiceServerMockListMessagesExpectationOrigins + results *AppPublicServiceServerMockListMessagesResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListMessagesParams contains parameters of the AppPublicServiceServer.ListMessages +type AppPublicServiceServerMockListMessagesParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListMessagesRequest +} + +// AppPublicServiceServerMockListMessagesParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListMessages +type AppPublicServiceServerMockListMessagesParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListMessagesRequest +} + +// AppPublicServiceServerMockListMessagesResults contains results of the AppPublicServiceServer.ListMessages +type AppPublicServiceServerMockListMessagesResults struct { + lp2 *mm_appv1alpha.ListMessagesResponse + err error +} + +// AppPublicServiceServerMockListMessagesOrigins contains origins of expectations of the AppPublicServiceServer.ListMessages +type AppPublicServiceServerMockListMessagesExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListMessages *mAppPublicServiceServerMockListMessages) Optional() *mAppPublicServiceServerMockListMessages { + mmListMessages.optional = true + return mmListMessages +} + +// Expect sets up expected params for AppPublicServiceServer.ListMessages +func (mmListMessages *mAppPublicServiceServerMockListMessages) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) *mAppPublicServiceServerMockListMessages { + if mmListMessages.mock.funcListMessages != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") + } + + if mmListMessages.defaultExpectation == nil { + mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{} + } + + if mmListMessages.defaultExpectation.paramPtrs != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by ExpectParams functions") + } + + mmListMessages.defaultExpectation.params = &AppPublicServiceServerMockListMessagesParams{ctx, lp1} + mmListMessages.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListMessages.expectations { + if minimock.Equal(e.params, mmListMessages.defaultExpectation.params) { + mmListMessages.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListMessages.defaultExpectation.params) + } + } + + return mmListMessages +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListMessages +func (mmListMessages *mAppPublicServiceServerMockListMessages) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListMessages { + if mmListMessages.mock.funcListMessages != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") + } + + if mmListMessages.defaultExpectation == nil { + mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{} + } + + if mmListMessages.defaultExpectation.params != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Expect") + } + + if mmListMessages.defaultExpectation.paramPtrs == nil { + mmListMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListMessagesParamPtrs{} + } + mmListMessages.defaultExpectation.paramPtrs.ctx = &ctx + mmListMessages.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListMessages +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListMessages +func (mmListMessages *mAppPublicServiceServerMockListMessages) ExpectLp1Param2(lp1 *mm_appv1alpha.ListMessagesRequest) *mAppPublicServiceServerMockListMessages { + if mmListMessages.mock.funcListMessages != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") + } + + if mmListMessages.defaultExpectation == nil { + mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{} + } + + if mmListMessages.defaultExpectation.params != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Expect") + } + + if mmListMessages.defaultExpectation.paramPtrs == nil { + mmListMessages.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListMessagesParamPtrs{} + } + mmListMessages.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListMessages.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListMessages +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListMessages +func (mmListMessages *mAppPublicServiceServerMockListMessages) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest)) *mAppPublicServiceServerMockListMessages { + if mmListMessages.mock.inspectFuncListMessages != nil { + mmListMessages.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListMessages") + } + + mmListMessages.mock.inspectFuncListMessages = f + + return mmListMessages +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListMessages +func (mmListMessages *mAppPublicServiceServerMockListMessages) Return(lp2 *mm_appv1alpha.ListMessagesResponse, err error) *AppPublicServiceServerMock { + if mmListMessages.mock.funcListMessages != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") + } + + if mmListMessages.defaultExpectation == nil { + mmListMessages.defaultExpectation = &AppPublicServiceServerMockListMessagesExpectation{mock: mmListMessages.mock} + } + mmListMessages.defaultExpectation.results = &AppPublicServiceServerMockListMessagesResults{lp2, err} + mmListMessages.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListMessages.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListMessages method +func (mmListMessages *mAppPublicServiceServerMockListMessages) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) (lp2 *mm_appv1alpha.ListMessagesResponse, err error)) *AppPublicServiceServerMock { + if mmListMessages.defaultExpectation != nil { + mmListMessages.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListMessages method") + } + + if len(mmListMessages.expectations) > 0 { + mmListMessages.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListMessages method") + } + + mmListMessages.mock.funcListMessages = f + mmListMessages.mock.funcListMessagesOrigin = minimock.CallerInfo(1) + return mmListMessages.mock +} + +// When sets expectation for the AppPublicServiceServer.ListMessages which will trigger the result defined by the following +// Then helper +func (mmListMessages *mAppPublicServiceServerMockListMessages) When(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) *AppPublicServiceServerMockListMessagesExpectation { + if mmListMessages.mock.funcListMessages != nil { + mmListMessages.mock.t.Fatalf("AppPublicServiceServerMock.ListMessages mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListMessagesExpectation{ + mock: mmListMessages.mock, + params: &AppPublicServiceServerMockListMessagesParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListMessagesExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListMessages.expectations = append(mmListMessages.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListMessages return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListMessagesExpectation) Then(lp2 *mm_appv1alpha.ListMessagesResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListMessagesResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListMessages should be invoked +func (mmListMessages *mAppPublicServiceServerMockListMessages) Times(n uint64) *mAppPublicServiceServerMockListMessages { + if n == 0 { + mmListMessages.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListMessages mock can not be zero") + } + mm_atomic.StoreUint64(&mmListMessages.expectedInvocations, n) + mmListMessages.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListMessages +} + +func (mmListMessages *mAppPublicServiceServerMockListMessages) invocationsDone() bool { + if len(mmListMessages.expectations) == 0 && mmListMessages.defaultExpectation == nil && mmListMessages.mock.funcListMessages == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListMessages.mock.afterListMessagesCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListMessages.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListMessages implements mm_appv1alpha.AppPublicServiceServer +func (mmListMessages *AppPublicServiceServerMock) ListMessages(ctx context.Context, lp1 *mm_appv1alpha.ListMessagesRequest) (lp2 *mm_appv1alpha.ListMessagesResponse, err error) { + mm_atomic.AddUint64(&mmListMessages.beforeListMessagesCounter, 1) + defer mm_atomic.AddUint64(&mmListMessages.afterListMessagesCounter, 1) + + mmListMessages.t.Helper() + + if mmListMessages.inspectFuncListMessages != nil { + mmListMessages.inspectFuncListMessages(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListMessagesParams{ctx, lp1} + + // Record call args + mmListMessages.ListMessagesMock.mutex.Lock() + mmListMessages.ListMessagesMock.callArgs = append(mmListMessages.ListMessagesMock.callArgs, &mm_params) + mmListMessages.ListMessagesMock.mutex.Unlock() + + for _, e := range mmListMessages.ListMessagesMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListMessages.ListMessagesMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListMessages.ListMessagesMock.defaultExpectation.Counter, 1) + mm_want := mmListMessages.ListMessagesMock.defaultExpectation.params + mm_want_ptrs := mmListMessages.ListMessagesMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListMessagesParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListMessages.t.Errorf("AppPublicServiceServerMock.ListMessages got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListMessages.ListMessagesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListMessages.t.Errorf("AppPublicServiceServerMock.ListMessages got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListMessages.ListMessagesMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListMessages.t.Errorf("AppPublicServiceServerMock.ListMessages got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListMessages.ListMessagesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListMessages.ListMessagesMock.defaultExpectation.results + if mm_results == nil { + mmListMessages.t.Fatal("No results are set for the AppPublicServiceServerMock.ListMessages") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListMessages.funcListMessages != nil { + return mmListMessages.funcListMessages(ctx, lp1) + } + mmListMessages.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListMessages. %v %v", ctx, lp1) + return +} + +// ListMessagesAfterCounter returns a count of finished AppPublicServiceServerMock.ListMessages invocations +func (mmListMessages *AppPublicServiceServerMock) ListMessagesAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListMessages.afterListMessagesCounter) +} + +// ListMessagesBeforeCounter returns a count of AppPublicServiceServerMock.ListMessages invocations +func (mmListMessages *AppPublicServiceServerMock) ListMessagesBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListMessages.beforeListMessagesCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListMessages. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListMessages *mAppPublicServiceServerMockListMessages) Calls() []*AppPublicServiceServerMockListMessagesParams { + mmListMessages.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListMessagesParams, len(mmListMessages.callArgs)) + copy(argCopy, mmListMessages.callArgs) + + mmListMessages.mutex.RUnlock() + + return argCopy +} + +// MinimockListMessagesDone returns true if the count of the ListMessages invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListMessagesDone() bool { + if m.ListMessagesMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListMessagesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListMessagesMock.invocationsDone() +} + +// MinimockListMessagesInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListMessagesInspect() { + for _, e := range m.ListMessagesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListMessagesCounter := mm_atomic.LoadUint64(&m.afterListMessagesCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListMessagesMock.defaultExpectation != nil && afterListMessagesCounter < 1 { + if m.ListMessagesMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s", m.ListMessagesMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s with params: %#v", m.ListMessagesMock.defaultExpectation.expectationOrigins.origin, *m.ListMessagesMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListMessages != nil && afterListMessagesCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListMessages at\n%s", m.funcListMessagesOrigin) + } + + if !m.ListMessagesMock.invocationsDone() && afterListMessagesCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListMessages at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListMessagesMock.expectedInvocations), m.ListMessagesMock.expectedInvocationsOrigin, afterListMessagesCounter) + } +} + +type mAppPublicServiceServerMockListRows struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListRowsExpectation + expectations []*AppPublicServiceServerMockListRowsExpectation + + callArgs []*AppPublicServiceServerMockListRowsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListRowsExpectation specifies expectation struct of the AppPublicServiceServer.ListRows +type AppPublicServiceServerMockListRowsExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListRowsParams + paramPtrs *AppPublicServiceServerMockListRowsParamPtrs + expectationOrigins AppPublicServiceServerMockListRowsExpectationOrigins + results *AppPublicServiceServerMockListRowsResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListRowsParams contains parameters of the AppPublicServiceServer.ListRows +type AppPublicServiceServerMockListRowsParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListRowsRequest +} + +// AppPublicServiceServerMockListRowsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListRows +type AppPublicServiceServerMockListRowsParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListRowsRequest +} + +// AppPublicServiceServerMockListRowsResults contains results of the AppPublicServiceServer.ListRows +type AppPublicServiceServerMockListRowsResults struct { + lp2 *mm_appv1alpha.ListRowsResponse + err error +} + +// AppPublicServiceServerMockListRowsOrigins contains origins of expectations of the AppPublicServiceServer.ListRows +type AppPublicServiceServerMockListRowsExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListRows *mAppPublicServiceServerMockListRows) Optional() *mAppPublicServiceServerMockListRows { + mmListRows.optional = true + return mmListRows +} + +// Expect sets up expected params for AppPublicServiceServer.ListRows +func (mmListRows *mAppPublicServiceServerMockListRows) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest) *mAppPublicServiceServerMockListRows { + if mmListRows.mock.funcListRows != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Set") + } + + if mmListRows.defaultExpectation == nil { + mmListRows.defaultExpectation = &AppPublicServiceServerMockListRowsExpectation{} + } + + if mmListRows.defaultExpectation.paramPtrs != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by ExpectParams functions") + } + + mmListRows.defaultExpectation.params = &AppPublicServiceServerMockListRowsParams{ctx, lp1} + mmListRows.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListRows.expectations { + if minimock.Equal(e.params, mmListRows.defaultExpectation.params) { + mmListRows.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListRows.defaultExpectation.params) + } + } + + return mmListRows +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListRows +func (mmListRows *mAppPublicServiceServerMockListRows) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListRows { + if mmListRows.mock.funcListRows != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Set") + } + + if mmListRows.defaultExpectation == nil { + mmListRows.defaultExpectation = &AppPublicServiceServerMockListRowsExpectation{} + } + + if mmListRows.defaultExpectation.params != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Expect") + } + + if mmListRows.defaultExpectation.paramPtrs == nil { + mmListRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListRowsParamPtrs{} + } + mmListRows.defaultExpectation.paramPtrs.ctx = &ctx + mmListRows.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListRows +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListRows +func (mmListRows *mAppPublicServiceServerMockListRows) ExpectLp1Param2(lp1 *mm_appv1alpha.ListRowsRequest) *mAppPublicServiceServerMockListRows { + if mmListRows.mock.funcListRows != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Set") + } + + if mmListRows.defaultExpectation == nil { + mmListRows.defaultExpectation = &AppPublicServiceServerMockListRowsExpectation{} + } + + if mmListRows.defaultExpectation.params != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Expect") + } + + if mmListRows.defaultExpectation.paramPtrs == nil { + mmListRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListRowsParamPtrs{} + } + mmListRows.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListRows.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListRows +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListRows +func (mmListRows *mAppPublicServiceServerMockListRows) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest)) *mAppPublicServiceServerMockListRows { + if mmListRows.mock.inspectFuncListRows != nil { + mmListRows.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListRows") + } + + mmListRows.mock.inspectFuncListRows = f + + return mmListRows +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListRows +func (mmListRows *mAppPublicServiceServerMockListRows) Return(lp2 *mm_appv1alpha.ListRowsResponse, err error) *AppPublicServiceServerMock { + if mmListRows.mock.funcListRows != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Set") + } + + if mmListRows.defaultExpectation == nil { + mmListRows.defaultExpectation = &AppPublicServiceServerMockListRowsExpectation{mock: mmListRows.mock} + } + mmListRows.defaultExpectation.results = &AppPublicServiceServerMockListRowsResults{lp2, err} + mmListRows.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListRows.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListRows method +func (mmListRows *mAppPublicServiceServerMockListRows) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest) (lp2 *mm_appv1alpha.ListRowsResponse, err error)) *AppPublicServiceServerMock { + if mmListRows.defaultExpectation != nil { + mmListRows.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListRows method") + } + + if len(mmListRows.expectations) > 0 { + mmListRows.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListRows method") + } + + mmListRows.mock.funcListRows = f + mmListRows.mock.funcListRowsOrigin = minimock.CallerInfo(1) + return mmListRows.mock +} + +// When sets expectation for the AppPublicServiceServer.ListRows which will trigger the result defined by the following +// Then helper +func (mmListRows *mAppPublicServiceServerMockListRows) When(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest) *AppPublicServiceServerMockListRowsExpectation { + if mmListRows.mock.funcListRows != nil { + mmListRows.mock.t.Fatalf("AppPublicServiceServerMock.ListRows mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListRowsExpectation{ + mock: mmListRows.mock, + params: &AppPublicServiceServerMockListRowsParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListRowsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListRows.expectations = append(mmListRows.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListRows return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListRowsExpectation) Then(lp2 *mm_appv1alpha.ListRowsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListRowsResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListRows should be invoked +func (mmListRows *mAppPublicServiceServerMockListRows) Times(n uint64) *mAppPublicServiceServerMockListRows { + if n == 0 { + mmListRows.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListRows mock can not be zero") + } + mm_atomic.StoreUint64(&mmListRows.expectedInvocations, n) + mmListRows.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListRows +} + +func (mmListRows *mAppPublicServiceServerMockListRows) invocationsDone() bool { + if len(mmListRows.expectations) == 0 && mmListRows.defaultExpectation == nil && mmListRows.mock.funcListRows == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListRows.mock.afterListRowsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListRows.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListRows implements mm_appv1alpha.AppPublicServiceServer +func (mmListRows *AppPublicServiceServerMock) ListRows(ctx context.Context, lp1 *mm_appv1alpha.ListRowsRequest) (lp2 *mm_appv1alpha.ListRowsResponse, err error) { + mm_atomic.AddUint64(&mmListRows.beforeListRowsCounter, 1) + defer mm_atomic.AddUint64(&mmListRows.afterListRowsCounter, 1) + + mmListRows.t.Helper() + + if mmListRows.inspectFuncListRows != nil { + mmListRows.inspectFuncListRows(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListRowsParams{ctx, lp1} + + // Record call args + mmListRows.ListRowsMock.mutex.Lock() + mmListRows.ListRowsMock.callArgs = append(mmListRows.ListRowsMock.callArgs, &mm_params) + mmListRows.ListRowsMock.mutex.Unlock() + + for _, e := range mmListRows.ListRowsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListRows.ListRowsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListRows.ListRowsMock.defaultExpectation.Counter, 1) + mm_want := mmListRows.ListRowsMock.defaultExpectation.params + mm_want_ptrs := mmListRows.ListRowsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListRowsParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListRows.t.Errorf("AppPublicServiceServerMock.ListRows got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListRows.ListRowsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListRows.t.Errorf("AppPublicServiceServerMock.ListRows got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListRows.ListRowsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListRows.t.Errorf("AppPublicServiceServerMock.ListRows got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListRows.ListRowsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListRows.ListRowsMock.defaultExpectation.results + if mm_results == nil { + mmListRows.t.Fatal("No results are set for the AppPublicServiceServerMock.ListRows") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListRows.funcListRows != nil { + return mmListRows.funcListRows(ctx, lp1) + } + mmListRows.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListRows. %v %v", ctx, lp1) + return +} + +// ListRowsAfterCounter returns a count of finished AppPublicServiceServerMock.ListRows invocations +func (mmListRows *AppPublicServiceServerMock) ListRowsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListRows.afterListRowsCounter) +} + +// ListRowsBeforeCounter returns a count of AppPublicServiceServerMock.ListRows invocations +func (mmListRows *AppPublicServiceServerMock) ListRowsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListRows.beforeListRowsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListRows. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListRows *mAppPublicServiceServerMockListRows) Calls() []*AppPublicServiceServerMockListRowsParams { + mmListRows.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListRowsParams, len(mmListRows.callArgs)) + copy(argCopy, mmListRows.callArgs) + + mmListRows.mutex.RUnlock() + + return argCopy +} + +// MinimockListRowsDone returns true if the count of the ListRows invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListRowsDone() bool { + if m.ListRowsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListRowsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListRowsMock.invocationsDone() +} + +// MinimockListRowsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListRowsInspect() { + for _, e := range m.ListRowsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListRows at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListRowsCounter := mm_atomic.LoadUint64(&m.afterListRowsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListRowsMock.defaultExpectation != nil && afterListRowsCounter < 1 { + if m.ListRowsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListRows at\n%s", m.ListRowsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListRows at\n%s with params: %#v", m.ListRowsMock.defaultExpectation.expectationOrigins.origin, *m.ListRowsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListRows != nil && afterListRowsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListRows at\n%s", m.funcListRowsOrigin) + } + + if !m.ListRowsMock.invocationsDone() && afterListRowsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListRows at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListRowsMock.expectedInvocations), m.ListRowsMock.expectedInvocationsOrigin, afterListRowsCounter) + } +} + +type mAppPublicServiceServerMockListTables struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListTablesExpectation + expectations []*AppPublicServiceServerMockListTablesExpectation + + callArgs []*AppPublicServiceServerMockListTablesParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListTablesExpectation specifies expectation struct of the AppPublicServiceServer.ListTables +type AppPublicServiceServerMockListTablesExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListTablesParams + paramPtrs *AppPublicServiceServerMockListTablesParamPtrs + expectationOrigins AppPublicServiceServerMockListTablesExpectationOrigins + results *AppPublicServiceServerMockListTablesResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListTablesParams contains parameters of the AppPublicServiceServer.ListTables +type AppPublicServiceServerMockListTablesParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListTablesRequest +} + +// AppPublicServiceServerMockListTablesParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListTables +type AppPublicServiceServerMockListTablesParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListTablesRequest +} + +// AppPublicServiceServerMockListTablesResults contains results of the AppPublicServiceServer.ListTables +type AppPublicServiceServerMockListTablesResults struct { + lp2 *mm_appv1alpha.ListTablesResponse + err error +} + +// AppPublicServiceServerMockListTablesOrigins contains origins of expectations of the AppPublicServiceServer.ListTables +type AppPublicServiceServerMockListTablesExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListTables *mAppPublicServiceServerMockListTables) Optional() *mAppPublicServiceServerMockListTables { + mmListTables.optional = true + return mmListTables +} + +// Expect sets up expected params for AppPublicServiceServer.ListTables +func (mmListTables *mAppPublicServiceServerMockListTables) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest) *mAppPublicServiceServerMockListTables { + if mmListTables.mock.funcListTables != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Set") + } + + if mmListTables.defaultExpectation == nil { + mmListTables.defaultExpectation = &AppPublicServiceServerMockListTablesExpectation{} + } + + if mmListTables.defaultExpectation.paramPtrs != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by ExpectParams functions") + } + + mmListTables.defaultExpectation.params = &AppPublicServiceServerMockListTablesParams{ctx, lp1} + mmListTables.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListTables.expectations { + if minimock.Equal(e.params, mmListTables.defaultExpectation.params) { + mmListTables.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListTables.defaultExpectation.params) + } + } + + return mmListTables +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListTables +func (mmListTables *mAppPublicServiceServerMockListTables) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListTables { + if mmListTables.mock.funcListTables != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Set") + } + + if mmListTables.defaultExpectation == nil { + mmListTables.defaultExpectation = &AppPublicServiceServerMockListTablesExpectation{} + } + + if mmListTables.defaultExpectation.params != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Expect") + } + + if mmListTables.defaultExpectation.paramPtrs == nil { + mmListTables.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListTablesParamPtrs{} + } + mmListTables.defaultExpectation.paramPtrs.ctx = &ctx + mmListTables.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListTables +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListTables +func (mmListTables *mAppPublicServiceServerMockListTables) ExpectLp1Param2(lp1 *mm_appv1alpha.ListTablesRequest) *mAppPublicServiceServerMockListTables { + if mmListTables.mock.funcListTables != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Set") + } + + if mmListTables.defaultExpectation == nil { + mmListTables.defaultExpectation = &AppPublicServiceServerMockListTablesExpectation{} + } + + if mmListTables.defaultExpectation.params != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Expect") + } + + if mmListTables.defaultExpectation.paramPtrs == nil { + mmListTables.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListTablesParamPtrs{} + } + mmListTables.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListTables.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListTables +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListTables +func (mmListTables *mAppPublicServiceServerMockListTables) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest)) *mAppPublicServiceServerMockListTables { + if mmListTables.mock.inspectFuncListTables != nil { + mmListTables.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListTables") + } + + mmListTables.mock.inspectFuncListTables = f + + return mmListTables +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListTables +func (mmListTables *mAppPublicServiceServerMockListTables) Return(lp2 *mm_appv1alpha.ListTablesResponse, err error) *AppPublicServiceServerMock { + if mmListTables.mock.funcListTables != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Set") + } + + if mmListTables.defaultExpectation == nil { + mmListTables.defaultExpectation = &AppPublicServiceServerMockListTablesExpectation{mock: mmListTables.mock} + } + mmListTables.defaultExpectation.results = &AppPublicServiceServerMockListTablesResults{lp2, err} + mmListTables.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListTables.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListTables method +func (mmListTables *mAppPublicServiceServerMockListTables) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest) (lp2 *mm_appv1alpha.ListTablesResponse, err error)) *AppPublicServiceServerMock { + if mmListTables.defaultExpectation != nil { + mmListTables.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListTables method") + } + + if len(mmListTables.expectations) > 0 { + mmListTables.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListTables method") + } + + mmListTables.mock.funcListTables = f + mmListTables.mock.funcListTablesOrigin = minimock.CallerInfo(1) + return mmListTables.mock +} + +// When sets expectation for the AppPublicServiceServer.ListTables which will trigger the result defined by the following +// Then helper +func (mmListTables *mAppPublicServiceServerMockListTables) When(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest) *AppPublicServiceServerMockListTablesExpectation { + if mmListTables.mock.funcListTables != nil { + mmListTables.mock.t.Fatalf("AppPublicServiceServerMock.ListTables mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListTablesExpectation{ + mock: mmListTables.mock, + params: &AppPublicServiceServerMockListTablesParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListTablesExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListTables.expectations = append(mmListTables.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListTables return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListTablesExpectation) Then(lp2 *mm_appv1alpha.ListTablesResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListTablesResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListTables should be invoked +func (mmListTables *mAppPublicServiceServerMockListTables) Times(n uint64) *mAppPublicServiceServerMockListTables { + if n == 0 { + mmListTables.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListTables mock can not be zero") + } + mm_atomic.StoreUint64(&mmListTables.expectedInvocations, n) + mmListTables.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListTables +} + +func (mmListTables *mAppPublicServiceServerMockListTables) invocationsDone() bool { + if len(mmListTables.expectations) == 0 && mmListTables.defaultExpectation == nil && mmListTables.mock.funcListTables == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListTables.mock.afterListTablesCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListTables.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListTables implements mm_appv1alpha.AppPublicServiceServer +func (mmListTables *AppPublicServiceServerMock) ListTables(ctx context.Context, lp1 *mm_appv1alpha.ListTablesRequest) (lp2 *mm_appv1alpha.ListTablesResponse, err error) { + mm_atomic.AddUint64(&mmListTables.beforeListTablesCounter, 1) + defer mm_atomic.AddUint64(&mmListTables.afterListTablesCounter, 1) + + mmListTables.t.Helper() + + if mmListTables.inspectFuncListTables != nil { + mmListTables.inspectFuncListTables(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListTablesParams{ctx, lp1} + + // Record call args + mmListTables.ListTablesMock.mutex.Lock() + mmListTables.ListTablesMock.callArgs = append(mmListTables.ListTablesMock.callArgs, &mm_params) + mmListTables.ListTablesMock.mutex.Unlock() + + for _, e := range mmListTables.ListTablesMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListTables.ListTablesMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListTables.ListTablesMock.defaultExpectation.Counter, 1) + mm_want := mmListTables.ListTablesMock.defaultExpectation.params + mm_want_ptrs := mmListTables.ListTablesMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListTablesParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListTables.t.Errorf("AppPublicServiceServerMock.ListTables got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListTables.ListTablesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListTables.t.Errorf("AppPublicServiceServerMock.ListTables got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListTables.ListTablesMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListTables.t.Errorf("AppPublicServiceServerMock.ListTables got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListTables.ListTablesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListTables.ListTablesMock.defaultExpectation.results + if mm_results == nil { + mmListTables.t.Fatal("No results are set for the AppPublicServiceServerMock.ListTables") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListTables.funcListTables != nil { + return mmListTables.funcListTables(ctx, lp1) + } + mmListTables.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListTables. %v %v", ctx, lp1) + return +} + +// ListTablesAfterCounter returns a count of finished AppPublicServiceServerMock.ListTables invocations +func (mmListTables *AppPublicServiceServerMock) ListTablesAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListTables.afterListTablesCounter) +} + +// ListTablesBeforeCounter returns a count of AppPublicServiceServerMock.ListTables invocations +func (mmListTables *AppPublicServiceServerMock) ListTablesBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListTables.beforeListTablesCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListTables. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListTables *mAppPublicServiceServerMockListTables) Calls() []*AppPublicServiceServerMockListTablesParams { + mmListTables.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListTablesParams, len(mmListTables.callArgs)) + copy(argCopy, mmListTables.callArgs) + + mmListTables.mutex.RUnlock() + + return argCopy +} + +// MinimockListTablesDone returns true if the count of the ListTables invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListTablesDone() bool { + if m.ListTablesMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListTablesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListTablesMock.invocationsDone() +} + +// MinimockListTablesInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListTablesInspect() { + for _, e := range m.ListTablesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTables at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListTablesCounter := mm_atomic.LoadUint64(&m.afterListTablesCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListTablesMock.defaultExpectation != nil && afterListTablesCounter < 1 { + if m.ListTablesMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTables at\n%s", m.ListTablesMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTables at\n%s with params: %#v", m.ListTablesMock.defaultExpectation.expectationOrigins.origin, *m.ListTablesMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListTables != nil && afterListTablesCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTables at\n%s", m.funcListTablesOrigin) + } + + if !m.ListTablesMock.invocationsDone() && afterListTablesCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListTables at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListTablesMock.expectedInvocations), m.ListTablesMock.expectedInvocationsOrigin, afterListTablesCounter) + } +} + +type mAppPublicServiceServerMockListTools struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockListToolsExpectation + expectations []*AppPublicServiceServerMockListToolsExpectation + + callArgs []*AppPublicServiceServerMockListToolsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockListToolsExpectation specifies expectation struct of the AppPublicServiceServer.ListTools +type AppPublicServiceServerMockListToolsExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockListToolsParams + paramPtrs *AppPublicServiceServerMockListToolsParamPtrs + expectationOrigins AppPublicServiceServerMockListToolsExpectationOrigins + results *AppPublicServiceServerMockListToolsResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockListToolsParams contains parameters of the AppPublicServiceServer.ListTools +type AppPublicServiceServerMockListToolsParams struct { + ctx context.Context + lp1 *mm_appv1alpha.ListToolsRequest +} + +// AppPublicServiceServerMockListToolsParamPtrs contains pointers to parameters of the AppPublicServiceServer.ListTools +type AppPublicServiceServerMockListToolsParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.ListToolsRequest +} + +// AppPublicServiceServerMockListToolsResults contains results of the AppPublicServiceServer.ListTools +type AppPublicServiceServerMockListToolsResults struct { + lp2 *mm_appv1alpha.ListToolsResponse + err error +} + +// AppPublicServiceServerMockListToolsOrigins contains origins of expectations of the AppPublicServiceServer.ListTools +type AppPublicServiceServerMockListToolsExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListTools *mAppPublicServiceServerMockListTools) Optional() *mAppPublicServiceServerMockListTools { + mmListTools.optional = true + return mmListTools +} + +// Expect sets up expected params for AppPublicServiceServer.ListTools +func (mmListTools *mAppPublicServiceServerMockListTools) Expect(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) *mAppPublicServiceServerMockListTools { + if mmListTools.mock.funcListTools != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") + } + + if mmListTools.defaultExpectation == nil { + mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{} + } + + if mmListTools.defaultExpectation.paramPtrs != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by ExpectParams functions") + } + + mmListTools.defaultExpectation.params = &AppPublicServiceServerMockListToolsParams{ctx, lp1} + mmListTools.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListTools.expectations { + if minimock.Equal(e.params, mmListTools.defaultExpectation.params) { + mmListTools.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListTools.defaultExpectation.params) + } + } + + return mmListTools +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.ListTools +func (mmListTools *mAppPublicServiceServerMockListTools) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockListTools { + if mmListTools.mock.funcListTools != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") + } + + if mmListTools.defaultExpectation == nil { + mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{} + } + + if mmListTools.defaultExpectation.params != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Expect") + } + + if mmListTools.defaultExpectation.paramPtrs == nil { + mmListTools.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListToolsParamPtrs{} + } + mmListTools.defaultExpectation.paramPtrs.ctx = &ctx + mmListTools.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListTools +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.ListTools +func (mmListTools *mAppPublicServiceServerMockListTools) ExpectLp1Param2(lp1 *mm_appv1alpha.ListToolsRequest) *mAppPublicServiceServerMockListTools { + if mmListTools.mock.funcListTools != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") + } + + if mmListTools.defaultExpectation == nil { + mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{} + } + + if mmListTools.defaultExpectation.params != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Expect") + } + + if mmListTools.defaultExpectation.paramPtrs == nil { + mmListTools.defaultExpectation.paramPtrs = &AppPublicServiceServerMockListToolsParamPtrs{} + } + mmListTools.defaultExpectation.paramPtrs.lp1 = &lp1 + mmListTools.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmListTools +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.ListTools +func (mmListTools *mAppPublicServiceServerMockListTools) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest)) *mAppPublicServiceServerMockListTools { + if mmListTools.mock.inspectFuncListTools != nil { + mmListTools.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.ListTools") + } + + mmListTools.mock.inspectFuncListTools = f + + return mmListTools +} + +// Return sets up results that will be returned by AppPublicServiceServer.ListTools +func (mmListTools *mAppPublicServiceServerMockListTools) Return(lp2 *mm_appv1alpha.ListToolsResponse, err error) *AppPublicServiceServerMock { + if mmListTools.mock.funcListTools != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") + } + + if mmListTools.defaultExpectation == nil { + mmListTools.defaultExpectation = &AppPublicServiceServerMockListToolsExpectation{mock: mmListTools.mock} + } + mmListTools.defaultExpectation.results = &AppPublicServiceServerMockListToolsResults{lp2, err} + mmListTools.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListTools.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.ListTools method +func (mmListTools *mAppPublicServiceServerMockListTools) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) (lp2 *mm_appv1alpha.ListToolsResponse, err error)) *AppPublicServiceServerMock { + if mmListTools.defaultExpectation != nil { + mmListTools.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.ListTools method") + } + + if len(mmListTools.expectations) > 0 { + mmListTools.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.ListTools method") + } + + mmListTools.mock.funcListTools = f + mmListTools.mock.funcListToolsOrigin = minimock.CallerInfo(1) + return mmListTools.mock +} + +// When sets expectation for the AppPublicServiceServer.ListTools which will trigger the result defined by the following +// Then helper +func (mmListTools *mAppPublicServiceServerMockListTools) When(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) *AppPublicServiceServerMockListToolsExpectation { + if mmListTools.mock.funcListTools != nil { + mmListTools.mock.t.Fatalf("AppPublicServiceServerMock.ListTools mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockListToolsExpectation{ + mock: mmListTools.mock, + params: &AppPublicServiceServerMockListToolsParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockListToolsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListTools.expectations = append(mmListTools.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.ListTools return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockListToolsExpectation) Then(lp2 *mm_appv1alpha.ListToolsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockListToolsResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.ListTools should be invoked +func (mmListTools *mAppPublicServiceServerMockListTools) Times(n uint64) *mAppPublicServiceServerMockListTools { + if n == 0 { + mmListTools.mock.t.Fatalf("Times of AppPublicServiceServerMock.ListTools mock can not be zero") + } + mm_atomic.StoreUint64(&mmListTools.expectedInvocations, n) + mmListTools.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListTools +} + +func (mmListTools *mAppPublicServiceServerMockListTools) invocationsDone() bool { + if len(mmListTools.expectations) == 0 && mmListTools.defaultExpectation == nil && mmListTools.mock.funcListTools == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListTools.mock.afterListToolsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListTools.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListTools implements mm_appv1alpha.AppPublicServiceServer +func (mmListTools *AppPublicServiceServerMock) ListTools(ctx context.Context, lp1 *mm_appv1alpha.ListToolsRequest) (lp2 *mm_appv1alpha.ListToolsResponse, err error) { + mm_atomic.AddUint64(&mmListTools.beforeListToolsCounter, 1) + defer mm_atomic.AddUint64(&mmListTools.afterListToolsCounter, 1) + + mmListTools.t.Helper() + + if mmListTools.inspectFuncListTools != nil { + mmListTools.inspectFuncListTools(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockListToolsParams{ctx, lp1} + + // Record call args + mmListTools.ListToolsMock.mutex.Lock() + mmListTools.ListToolsMock.callArgs = append(mmListTools.ListToolsMock.callArgs, &mm_params) + mmListTools.ListToolsMock.mutex.Unlock() + + for _, e := range mmListTools.ListToolsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmListTools.ListToolsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListTools.ListToolsMock.defaultExpectation.Counter, 1) + mm_want := mmListTools.ListToolsMock.defaultExpectation.params + mm_want_ptrs := mmListTools.ListToolsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockListToolsParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListTools.t.Errorf("AppPublicServiceServerMock.ListTools got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListTools.ListToolsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmListTools.t.Errorf("AppPublicServiceServerMock.ListTools got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListTools.ListToolsMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListTools.t.Errorf("AppPublicServiceServerMock.ListTools got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListTools.ListToolsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListTools.ListToolsMock.defaultExpectation.results + if mm_results == nil { + mmListTools.t.Fatal("No results are set for the AppPublicServiceServerMock.ListTools") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmListTools.funcListTools != nil { + return mmListTools.funcListTools(ctx, lp1) + } + mmListTools.t.Fatalf("Unexpected call to AppPublicServiceServerMock.ListTools. %v %v", ctx, lp1) + return +} + +// ListToolsAfterCounter returns a count of finished AppPublicServiceServerMock.ListTools invocations +func (mmListTools *AppPublicServiceServerMock) ListToolsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListTools.afterListToolsCounter) +} + +// ListToolsBeforeCounter returns a count of AppPublicServiceServerMock.ListTools invocations +func (mmListTools *AppPublicServiceServerMock) ListToolsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListTools.beforeListToolsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.ListTools. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListTools *mAppPublicServiceServerMockListTools) Calls() []*AppPublicServiceServerMockListToolsParams { + mmListTools.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockListToolsParams, len(mmListTools.callArgs)) + copy(argCopy, mmListTools.callArgs) + + mmListTools.mutex.RUnlock() + + return argCopy +} + +// MinimockListToolsDone returns true if the count of the ListTools invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockListToolsDone() bool { + if m.ListToolsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListToolsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListToolsMock.invocationsDone() +} + +// MinimockListToolsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockListToolsInspect() { + for _, e := range m.ListToolsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterListToolsCounter := mm_atomic.LoadUint64(&m.afterListToolsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ListToolsMock.defaultExpectation != nil && afterListToolsCounter < 1 { + if m.ListToolsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s", m.ListToolsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s with params: %#v", m.ListToolsMock.defaultExpectation.expectationOrigins.origin, *m.ListToolsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcListTools != nil && afterListToolsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.ListTools at\n%s", m.funcListToolsOrigin) + } + + if !m.ListToolsMock.invocationsDone() && afterListToolsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.ListTools at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListToolsMock.expectedInvocations), m.ListToolsMock.expectedInvocationsOrigin, afterListToolsCounter) + } +} + +type mAppPublicServiceServerMockLiveness struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockLivenessExpectation + expectations []*AppPublicServiceServerMockLivenessExpectation + + callArgs []*AppPublicServiceServerMockLivenessParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockLivenessExpectation specifies expectation struct of the AppPublicServiceServer.Liveness +type AppPublicServiceServerMockLivenessExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockLivenessParams + paramPtrs *AppPublicServiceServerMockLivenessParamPtrs + expectationOrigins AppPublicServiceServerMockLivenessExpectationOrigins + results *AppPublicServiceServerMockLivenessResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockLivenessParams contains parameters of the AppPublicServiceServer.Liveness +type AppPublicServiceServerMockLivenessParams struct { + ctx context.Context + lp1 *mm_appv1alpha.LivenessRequest +} + +// AppPublicServiceServerMockLivenessParamPtrs contains pointers to parameters of the AppPublicServiceServer.Liveness +type AppPublicServiceServerMockLivenessParamPtrs struct { + ctx *context.Context + lp1 **mm_appv1alpha.LivenessRequest +} + +// AppPublicServiceServerMockLivenessResults contains results of the AppPublicServiceServer.Liveness +type AppPublicServiceServerMockLivenessResults struct { + lp2 *mm_appv1alpha.LivenessResponse + err error +} + +// AppPublicServiceServerMockLivenessOrigins contains origins of expectations of the AppPublicServiceServer.Liveness +type AppPublicServiceServerMockLivenessExpectationOrigins struct { + origin string + originCtx string + originLp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmLiveness *mAppPublicServiceServerMockLiveness) Optional() *mAppPublicServiceServerMockLiveness { + mmLiveness.optional = true + return mmLiveness +} + +// Expect sets up expected params for AppPublicServiceServer.Liveness +func (mmLiveness *mAppPublicServiceServerMockLiveness) Expect(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) *mAppPublicServiceServerMockLiveness { + if mmLiveness.mock.funcLiveness != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") + } + + if mmLiveness.defaultExpectation == nil { + mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{} + } + + if mmLiveness.defaultExpectation.paramPtrs != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by ExpectParams functions") + } + + mmLiveness.defaultExpectation.params = &AppPublicServiceServerMockLivenessParams{ctx, lp1} + mmLiveness.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmLiveness.expectations { + if minimock.Equal(e.params, mmLiveness.defaultExpectation.params) { + mmLiveness.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmLiveness.defaultExpectation.params) + } + } + + return mmLiveness +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.Liveness +func (mmLiveness *mAppPublicServiceServerMockLiveness) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockLiveness { + if mmLiveness.mock.funcLiveness != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") + } + + if mmLiveness.defaultExpectation == nil { + mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{} + } + + if mmLiveness.defaultExpectation.params != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Expect") + } + + if mmLiveness.defaultExpectation.paramPtrs == nil { + mmLiveness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockLivenessParamPtrs{} + } + mmLiveness.defaultExpectation.paramPtrs.ctx = &ctx + mmLiveness.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmLiveness +} + +// ExpectLp1Param2 sets up expected param lp1 for AppPublicServiceServer.Liveness +func (mmLiveness *mAppPublicServiceServerMockLiveness) ExpectLp1Param2(lp1 *mm_appv1alpha.LivenessRequest) *mAppPublicServiceServerMockLiveness { + if mmLiveness.mock.funcLiveness != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") + } + + if mmLiveness.defaultExpectation == nil { + mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{} + } + + if mmLiveness.defaultExpectation.params != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Expect") + } + + if mmLiveness.defaultExpectation.paramPtrs == nil { + mmLiveness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockLivenessParamPtrs{} + } + mmLiveness.defaultExpectation.paramPtrs.lp1 = &lp1 + mmLiveness.defaultExpectation.expectationOrigins.originLp1 = minimock.CallerInfo(1) + + return mmLiveness +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.Liveness +func (mmLiveness *mAppPublicServiceServerMockLiveness) Inspect(f func(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest)) *mAppPublicServiceServerMockLiveness { + if mmLiveness.mock.inspectFuncLiveness != nil { + mmLiveness.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.Liveness") + } + + mmLiveness.mock.inspectFuncLiveness = f + + return mmLiveness +} + +// Return sets up results that will be returned by AppPublicServiceServer.Liveness +func (mmLiveness *mAppPublicServiceServerMockLiveness) Return(lp2 *mm_appv1alpha.LivenessResponse, err error) *AppPublicServiceServerMock { + if mmLiveness.mock.funcLiveness != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") + } + + if mmLiveness.defaultExpectation == nil { + mmLiveness.defaultExpectation = &AppPublicServiceServerMockLivenessExpectation{mock: mmLiveness.mock} + } + mmLiveness.defaultExpectation.results = &AppPublicServiceServerMockLivenessResults{lp2, err} + mmLiveness.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmLiveness.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.Liveness method +func (mmLiveness *mAppPublicServiceServerMockLiveness) Set(f func(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) (lp2 *mm_appv1alpha.LivenessResponse, err error)) *AppPublicServiceServerMock { + if mmLiveness.defaultExpectation != nil { + mmLiveness.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.Liveness method") + } + + if len(mmLiveness.expectations) > 0 { + mmLiveness.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.Liveness method") + } + + mmLiveness.mock.funcLiveness = f + mmLiveness.mock.funcLivenessOrigin = minimock.CallerInfo(1) + return mmLiveness.mock +} + +// When sets expectation for the AppPublicServiceServer.Liveness which will trigger the result defined by the following +// Then helper +func (mmLiveness *mAppPublicServiceServerMockLiveness) When(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) *AppPublicServiceServerMockLivenessExpectation { + if mmLiveness.mock.funcLiveness != nil { + mmLiveness.mock.t.Fatalf("AppPublicServiceServerMock.Liveness mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockLivenessExpectation{ + mock: mmLiveness.mock, + params: &AppPublicServiceServerMockLivenessParams{ctx, lp1}, + expectationOrigins: AppPublicServiceServerMockLivenessExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmLiveness.expectations = append(mmLiveness.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.Liveness return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockLivenessExpectation) Then(lp2 *mm_appv1alpha.LivenessResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockLivenessResults{lp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.Liveness should be invoked +func (mmLiveness *mAppPublicServiceServerMockLiveness) Times(n uint64) *mAppPublicServiceServerMockLiveness { + if n == 0 { + mmLiveness.mock.t.Fatalf("Times of AppPublicServiceServerMock.Liveness mock can not be zero") + } + mm_atomic.StoreUint64(&mmLiveness.expectedInvocations, n) + mmLiveness.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmLiveness +} + +func (mmLiveness *mAppPublicServiceServerMockLiveness) invocationsDone() bool { + if len(mmLiveness.expectations) == 0 && mmLiveness.defaultExpectation == nil && mmLiveness.mock.funcLiveness == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmLiveness.mock.afterLivenessCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmLiveness.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// Liveness implements mm_appv1alpha.AppPublicServiceServer +func (mmLiveness *AppPublicServiceServerMock) Liveness(ctx context.Context, lp1 *mm_appv1alpha.LivenessRequest) (lp2 *mm_appv1alpha.LivenessResponse, err error) { + mm_atomic.AddUint64(&mmLiveness.beforeLivenessCounter, 1) + defer mm_atomic.AddUint64(&mmLiveness.afterLivenessCounter, 1) + + mmLiveness.t.Helper() + + if mmLiveness.inspectFuncLiveness != nil { + mmLiveness.inspectFuncLiveness(ctx, lp1) + } + + mm_params := AppPublicServiceServerMockLivenessParams{ctx, lp1} + + // Record call args + mmLiveness.LivenessMock.mutex.Lock() + mmLiveness.LivenessMock.callArgs = append(mmLiveness.LivenessMock.callArgs, &mm_params) + mmLiveness.LivenessMock.mutex.Unlock() + + for _, e := range mmLiveness.LivenessMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.lp2, e.results.err + } + } + + if mmLiveness.LivenessMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmLiveness.LivenessMock.defaultExpectation.Counter, 1) + mm_want := mmLiveness.LivenessMock.defaultExpectation.params + mm_want_ptrs := mmLiveness.LivenessMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockLivenessParams{ctx, lp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmLiveness.t.Errorf("AppPublicServiceServerMock.Liveness got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmLiveness.LivenessMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.lp1 != nil && !minimock.Equal(*mm_want_ptrs.lp1, mm_got.lp1) { + mmLiveness.t.Errorf("AppPublicServiceServerMock.Liveness got unexpected parameter lp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmLiveness.LivenessMock.defaultExpectation.expectationOrigins.originLp1, *mm_want_ptrs.lp1, mm_got.lp1, minimock.Diff(*mm_want_ptrs.lp1, mm_got.lp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmLiveness.t.Errorf("AppPublicServiceServerMock.Liveness got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmLiveness.LivenessMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmLiveness.LivenessMock.defaultExpectation.results + if mm_results == nil { + mmLiveness.t.Fatal("No results are set for the AppPublicServiceServerMock.Liveness") + } + return (*mm_results).lp2, (*mm_results).err + } + if mmLiveness.funcLiveness != nil { + return mmLiveness.funcLiveness(ctx, lp1) + } + mmLiveness.t.Fatalf("Unexpected call to AppPublicServiceServerMock.Liveness. %v %v", ctx, lp1) + return +} + +// LivenessAfterCounter returns a count of finished AppPublicServiceServerMock.Liveness invocations +func (mmLiveness *AppPublicServiceServerMock) LivenessAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmLiveness.afterLivenessCounter) +} + +// LivenessBeforeCounter returns a count of AppPublicServiceServerMock.Liveness invocations +func (mmLiveness *AppPublicServiceServerMock) LivenessBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmLiveness.beforeLivenessCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.Liveness. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmLiveness *mAppPublicServiceServerMockLiveness) Calls() []*AppPublicServiceServerMockLivenessParams { + mmLiveness.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockLivenessParams, len(mmLiveness.callArgs)) + copy(argCopy, mmLiveness.callArgs) + + mmLiveness.mutex.RUnlock() + + return argCopy +} + +// MinimockLivenessDone returns true if the count of the Liveness invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockLivenessDone() bool { + if m.LivenessMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.LivenessMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.LivenessMock.invocationsDone() +} + +// MinimockLivenessInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockLivenessInspect() { + for _, e := range m.LivenessMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterLivenessCounter := mm_atomic.LoadUint64(&m.afterLivenessCounter) + // if default expectation was set then invocations count should be greater than zero + if m.LivenessMock.defaultExpectation != nil && afterLivenessCounter < 1 { + if m.LivenessMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s", m.LivenessMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s with params: %#v", m.LivenessMock.defaultExpectation.expectationOrigins.origin, *m.LivenessMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcLiveness != nil && afterLivenessCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Liveness at\n%s", m.funcLivenessOrigin) + } + + if !m.LivenessMock.invocationsDone() && afterLivenessCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.Liveness at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.LivenessMock.expectedInvocations), m.LivenessMock.expectedInvocationsOrigin, afterLivenessCounter) + } +} + +type mAppPublicServiceServerMockMoveRows struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockMoveRowsExpectation + expectations []*AppPublicServiceServerMockMoveRowsExpectation + + callArgs []*AppPublicServiceServerMockMoveRowsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockMoveRowsExpectation specifies expectation struct of the AppPublicServiceServer.MoveRows +type AppPublicServiceServerMockMoveRowsExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockMoveRowsParams + paramPtrs *AppPublicServiceServerMockMoveRowsParamPtrs + expectationOrigins AppPublicServiceServerMockMoveRowsExpectationOrigins + results *AppPublicServiceServerMockMoveRowsResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockMoveRowsParams contains parameters of the AppPublicServiceServer.MoveRows +type AppPublicServiceServerMockMoveRowsParams struct { + ctx context.Context + mp1 *mm_appv1alpha.MoveRowsRequest +} + +// AppPublicServiceServerMockMoveRowsParamPtrs contains pointers to parameters of the AppPublicServiceServer.MoveRows +type AppPublicServiceServerMockMoveRowsParamPtrs struct { + ctx *context.Context + mp1 **mm_appv1alpha.MoveRowsRequest +} + +// AppPublicServiceServerMockMoveRowsResults contains results of the AppPublicServiceServer.MoveRows +type AppPublicServiceServerMockMoveRowsResults struct { + mp2 *mm_appv1alpha.MoveRowsResponse + err error +} + +// AppPublicServiceServerMockMoveRowsOrigins contains origins of expectations of the AppPublicServiceServer.MoveRows +type AppPublicServiceServerMockMoveRowsExpectationOrigins struct { + origin string + originCtx string + originMp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Optional() *mAppPublicServiceServerMockMoveRows { + mmMoveRows.optional = true + return mmMoveRows +} + +// Expect sets up expected params for AppPublicServiceServer.MoveRows +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Expect(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest) *mAppPublicServiceServerMockMoveRows { + if mmMoveRows.mock.funcMoveRows != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Set") + } + + if mmMoveRows.defaultExpectation == nil { + mmMoveRows.defaultExpectation = &AppPublicServiceServerMockMoveRowsExpectation{} + } + + if mmMoveRows.defaultExpectation.paramPtrs != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by ExpectParams functions") + } + + mmMoveRows.defaultExpectation.params = &AppPublicServiceServerMockMoveRowsParams{ctx, mp1} + mmMoveRows.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmMoveRows.expectations { + if minimock.Equal(e.params, mmMoveRows.defaultExpectation.params) { + mmMoveRows.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmMoveRows.defaultExpectation.params) + } + } + + return mmMoveRows +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.MoveRows +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockMoveRows { + if mmMoveRows.mock.funcMoveRows != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Set") + } + + if mmMoveRows.defaultExpectation == nil { + mmMoveRows.defaultExpectation = &AppPublicServiceServerMockMoveRowsExpectation{} + } + + if mmMoveRows.defaultExpectation.params != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Expect") + } + + if mmMoveRows.defaultExpectation.paramPtrs == nil { + mmMoveRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockMoveRowsParamPtrs{} + } + mmMoveRows.defaultExpectation.paramPtrs.ctx = &ctx + mmMoveRows.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmMoveRows +} + +// ExpectMp1Param2 sets up expected param mp1 for AppPublicServiceServer.MoveRows +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) ExpectMp1Param2(mp1 *mm_appv1alpha.MoveRowsRequest) *mAppPublicServiceServerMockMoveRows { + if mmMoveRows.mock.funcMoveRows != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Set") + } + + if mmMoveRows.defaultExpectation == nil { + mmMoveRows.defaultExpectation = &AppPublicServiceServerMockMoveRowsExpectation{} + } + + if mmMoveRows.defaultExpectation.params != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Expect") + } + + if mmMoveRows.defaultExpectation.paramPtrs == nil { + mmMoveRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockMoveRowsParamPtrs{} + } + mmMoveRows.defaultExpectation.paramPtrs.mp1 = &mp1 + mmMoveRows.defaultExpectation.expectationOrigins.originMp1 = minimock.CallerInfo(1) + + return mmMoveRows +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.MoveRows +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Inspect(f func(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest)) *mAppPublicServiceServerMockMoveRows { + if mmMoveRows.mock.inspectFuncMoveRows != nil { + mmMoveRows.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.MoveRows") + } + + mmMoveRows.mock.inspectFuncMoveRows = f + + return mmMoveRows +} + +// Return sets up results that will be returned by AppPublicServiceServer.MoveRows +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Return(mp2 *mm_appv1alpha.MoveRowsResponse, err error) *AppPublicServiceServerMock { + if mmMoveRows.mock.funcMoveRows != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Set") + } + + if mmMoveRows.defaultExpectation == nil { + mmMoveRows.defaultExpectation = &AppPublicServiceServerMockMoveRowsExpectation{mock: mmMoveRows.mock} + } + mmMoveRows.defaultExpectation.results = &AppPublicServiceServerMockMoveRowsResults{mp2, err} + mmMoveRows.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmMoveRows.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.MoveRows method +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Set(f func(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest) (mp2 *mm_appv1alpha.MoveRowsResponse, err error)) *AppPublicServiceServerMock { + if mmMoveRows.defaultExpectation != nil { + mmMoveRows.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.MoveRows method") + } + + if len(mmMoveRows.expectations) > 0 { + mmMoveRows.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.MoveRows method") + } + + mmMoveRows.mock.funcMoveRows = f + mmMoveRows.mock.funcMoveRowsOrigin = minimock.CallerInfo(1) + return mmMoveRows.mock +} + +// When sets expectation for the AppPublicServiceServer.MoveRows which will trigger the result defined by the following +// Then helper +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) When(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest) *AppPublicServiceServerMockMoveRowsExpectation { + if mmMoveRows.mock.funcMoveRows != nil { + mmMoveRows.mock.t.Fatalf("AppPublicServiceServerMock.MoveRows mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockMoveRowsExpectation{ + mock: mmMoveRows.mock, + params: &AppPublicServiceServerMockMoveRowsParams{ctx, mp1}, + expectationOrigins: AppPublicServiceServerMockMoveRowsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmMoveRows.expectations = append(mmMoveRows.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.MoveRows return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockMoveRowsExpectation) Then(mp2 *mm_appv1alpha.MoveRowsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockMoveRowsResults{mp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.MoveRows should be invoked +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Times(n uint64) *mAppPublicServiceServerMockMoveRows { + if n == 0 { + mmMoveRows.mock.t.Fatalf("Times of AppPublicServiceServerMock.MoveRows mock can not be zero") + } + mm_atomic.StoreUint64(&mmMoveRows.expectedInvocations, n) + mmMoveRows.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmMoveRows +} + +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) invocationsDone() bool { + if len(mmMoveRows.expectations) == 0 && mmMoveRows.defaultExpectation == nil && mmMoveRows.mock.funcMoveRows == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmMoveRows.mock.afterMoveRowsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmMoveRows.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// MoveRows implements mm_appv1alpha.AppPublicServiceServer +func (mmMoveRows *AppPublicServiceServerMock) MoveRows(ctx context.Context, mp1 *mm_appv1alpha.MoveRowsRequest) (mp2 *mm_appv1alpha.MoveRowsResponse, err error) { + mm_atomic.AddUint64(&mmMoveRows.beforeMoveRowsCounter, 1) + defer mm_atomic.AddUint64(&mmMoveRows.afterMoveRowsCounter, 1) + + mmMoveRows.t.Helper() + + if mmMoveRows.inspectFuncMoveRows != nil { + mmMoveRows.inspectFuncMoveRows(ctx, mp1) + } + + mm_params := AppPublicServiceServerMockMoveRowsParams{ctx, mp1} + + // Record call args + mmMoveRows.MoveRowsMock.mutex.Lock() + mmMoveRows.MoveRowsMock.callArgs = append(mmMoveRows.MoveRowsMock.callArgs, &mm_params) + mmMoveRows.MoveRowsMock.mutex.Unlock() + + for _, e := range mmMoveRows.MoveRowsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.mp2, e.results.err + } + } + + if mmMoveRows.MoveRowsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmMoveRows.MoveRowsMock.defaultExpectation.Counter, 1) + mm_want := mmMoveRows.MoveRowsMock.defaultExpectation.params + mm_want_ptrs := mmMoveRows.MoveRowsMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockMoveRowsParams{ctx, mp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmMoveRows.t.Errorf("AppPublicServiceServerMock.MoveRows got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmMoveRows.MoveRowsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.mp1 != nil && !minimock.Equal(*mm_want_ptrs.mp1, mm_got.mp1) { + mmMoveRows.t.Errorf("AppPublicServiceServerMock.MoveRows got unexpected parameter mp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmMoveRows.MoveRowsMock.defaultExpectation.expectationOrigins.originMp1, *mm_want_ptrs.mp1, mm_got.mp1, minimock.Diff(*mm_want_ptrs.mp1, mm_got.mp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmMoveRows.t.Errorf("AppPublicServiceServerMock.MoveRows got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmMoveRows.MoveRowsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmMoveRows.MoveRowsMock.defaultExpectation.results + if mm_results == nil { + mmMoveRows.t.Fatal("No results are set for the AppPublicServiceServerMock.MoveRows") + } + return (*mm_results).mp2, (*mm_results).err + } + if mmMoveRows.funcMoveRows != nil { + return mmMoveRows.funcMoveRows(ctx, mp1) + } + mmMoveRows.t.Fatalf("Unexpected call to AppPublicServiceServerMock.MoveRows. %v %v", ctx, mp1) + return +} + +// MoveRowsAfterCounter returns a count of finished AppPublicServiceServerMock.MoveRows invocations +func (mmMoveRows *AppPublicServiceServerMock) MoveRowsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmMoveRows.afterMoveRowsCounter) +} + +// MoveRowsBeforeCounter returns a count of AppPublicServiceServerMock.MoveRows invocations +func (mmMoveRows *AppPublicServiceServerMock) MoveRowsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmMoveRows.beforeMoveRowsCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.MoveRows. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmMoveRows *mAppPublicServiceServerMockMoveRows) Calls() []*AppPublicServiceServerMockMoveRowsParams { + mmMoveRows.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockMoveRowsParams, len(mmMoveRows.callArgs)) + copy(argCopy, mmMoveRows.callArgs) + + mmMoveRows.mutex.RUnlock() + + return argCopy +} + +// MinimockMoveRowsDone returns true if the count of the MoveRows invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockMoveRowsDone() bool { + if m.MoveRowsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.MoveRowsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.MoveRowsMock.invocationsDone() +} + +// MinimockMoveRowsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockMoveRowsInspect() { + for _, e := range m.MoveRowsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.MoveRows at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterMoveRowsCounter := mm_atomic.LoadUint64(&m.afterMoveRowsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.MoveRowsMock.defaultExpectation != nil && afterMoveRowsCounter < 1 { + if m.MoveRowsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.MoveRows at\n%s", m.MoveRowsMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.MoveRows at\n%s with params: %#v", m.MoveRowsMock.defaultExpectation.expectationOrigins.origin, *m.MoveRowsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcMoveRows != nil && afterMoveRowsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.MoveRows at\n%s", m.funcMoveRowsOrigin) + } + + if !m.MoveRowsMock.invocationsDone() && afterMoveRowsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.MoveRows at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.MoveRowsMock.expectedInvocations), m.MoveRowsMock.expectedInvocationsOrigin, afterMoveRowsCounter) + } +} + +type mAppPublicServiceServerMockReadiness struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockReadinessExpectation + expectations []*AppPublicServiceServerMockReadinessExpectation + + callArgs []*AppPublicServiceServerMockReadinessParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockReadinessExpectation specifies expectation struct of the AppPublicServiceServer.Readiness +type AppPublicServiceServerMockReadinessExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockReadinessParams + paramPtrs *AppPublicServiceServerMockReadinessParamPtrs + expectationOrigins AppPublicServiceServerMockReadinessExpectationOrigins + results *AppPublicServiceServerMockReadinessResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockReadinessParams contains parameters of the AppPublicServiceServer.Readiness +type AppPublicServiceServerMockReadinessParams struct { + ctx context.Context + rp1 *mm_appv1alpha.ReadinessRequest +} + +// AppPublicServiceServerMockReadinessParamPtrs contains pointers to parameters of the AppPublicServiceServer.Readiness +type AppPublicServiceServerMockReadinessParamPtrs struct { + ctx *context.Context + rp1 **mm_appv1alpha.ReadinessRequest +} + +// AppPublicServiceServerMockReadinessResults contains results of the AppPublicServiceServer.Readiness +type AppPublicServiceServerMockReadinessResults struct { + rp2 *mm_appv1alpha.ReadinessResponse + err error +} + +// AppPublicServiceServerMockReadinessOrigins contains origins of expectations of the AppPublicServiceServer.Readiness +type AppPublicServiceServerMockReadinessExpectationOrigins struct { + origin string + originCtx string + originRp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmReadiness *mAppPublicServiceServerMockReadiness) Optional() *mAppPublicServiceServerMockReadiness { + mmReadiness.optional = true + return mmReadiness +} + +// Expect sets up expected params for AppPublicServiceServer.Readiness +func (mmReadiness *mAppPublicServiceServerMockReadiness) Expect(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) *mAppPublicServiceServerMockReadiness { + if mmReadiness.mock.funcReadiness != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") + } + + if mmReadiness.defaultExpectation == nil { + mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{} + } + + if mmReadiness.defaultExpectation.paramPtrs != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by ExpectParams functions") + } + + mmReadiness.defaultExpectation.params = &AppPublicServiceServerMockReadinessParams{ctx, rp1} + mmReadiness.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmReadiness.expectations { + if minimock.Equal(e.params, mmReadiness.defaultExpectation.params) { + mmReadiness.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmReadiness.defaultExpectation.params) + } + } + + return mmReadiness +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.Readiness +func (mmReadiness *mAppPublicServiceServerMockReadiness) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockReadiness { + if mmReadiness.mock.funcReadiness != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") + } + + if mmReadiness.defaultExpectation == nil { + mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{} + } + + if mmReadiness.defaultExpectation.params != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Expect") + } + + if mmReadiness.defaultExpectation.paramPtrs == nil { + mmReadiness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockReadinessParamPtrs{} + } + mmReadiness.defaultExpectation.paramPtrs.ctx = &ctx + mmReadiness.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmReadiness +} + +// ExpectRp1Param2 sets up expected param rp1 for AppPublicServiceServer.Readiness +func (mmReadiness *mAppPublicServiceServerMockReadiness) ExpectRp1Param2(rp1 *mm_appv1alpha.ReadinessRequest) *mAppPublicServiceServerMockReadiness { + if mmReadiness.mock.funcReadiness != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") + } + + if mmReadiness.defaultExpectation == nil { + mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{} + } + + if mmReadiness.defaultExpectation.params != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Expect") + } + + if mmReadiness.defaultExpectation.paramPtrs == nil { + mmReadiness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockReadinessParamPtrs{} + } + mmReadiness.defaultExpectation.paramPtrs.rp1 = &rp1 + mmReadiness.defaultExpectation.expectationOrigins.originRp1 = minimock.CallerInfo(1) + + return mmReadiness +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.Readiness +func (mmReadiness *mAppPublicServiceServerMockReadiness) Inspect(f func(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest)) *mAppPublicServiceServerMockReadiness { + if mmReadiness.mock.inspectFuncReadiness != nil { + mmReadiness.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.Readiness") + } + + mmReadiness.mock.inspectFuncReadiness = f + + return mmReadiness +} + +// Return sets up results that will be returned by AppPublicServiceServer.Readiness +func (mmReadiness *mAppPublicServiceServerMockReadiness) Return(rp2 *mm_appv1alpha.ReadinessResponse, err error) *AppPublicServiceServerMock { + if mmReadiness.mock.funcReadiness != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") + } + + if mmReadiness.defaultExpectation == nil { + mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{mock: mmReadiness.mock} + } + mmReadiness.defaultExpectation.results = &AppPublicServiceServerMockReadinessResults{rp2, err} + mmReadiness.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmReadiness.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.Readiness method +func (mmReadiness *mAppPublicServiceServerMockReadiness) Set(f func(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) (rp2 *mm_appv1alpha.ReadinessResponse, err error)) *AppPublicServiceServerMock { + if mmReadiness.defaultExpectation != nil { + mmReadiness.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.Readiness method") + } + + if len(mmReadiness.expectations) > 0 { + mmReadiness.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.Readiness method") + } + + mmReadiness.mock.funcReadiness = f + mmReadiness.mock.funcReadinessOrigin = minimock.CallerInfo(1) + return mmReadiness.mock +} + +// When sets expectation for the AppPublicServiceServer.Readiness which will trigger the result defined by the following +// Then helper +func (mmReadiness *mAppPublicServiceServerMockReadiness) When(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) *AppPublicServiceServerMockReadinessExpectation { + if mmReadiness.mock.funcReadiness != nil { + mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockReadinessExpectation{ + mock: mmReadiness.mock, + params: &AppPublicServiceServerMockReadinessParams{ctx, rp1}, + expectationOrigins: AppPublicServiceServerMockReadinessExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmReadiness.expectations = append(mmReadiness.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.Readiness return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockReadinessExpectation) Then(rp2 *mm_appv1alpha.ReadinessResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockReadinessResults{rp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.Readiness should be invoked +func (mmReadiness *mAppPublicServiceServerMockReadiness) Times(n uint64) *mAppPublicServiceServerMockReadiness { + if n == 0 { + mmReadiness.mock.t.Fatalf("Times of AppPublicServiceServerMock.Readiness mock can not be zero") + } + mm_atomic.StoreUint64(&mmReadiness.expectedInvocations, n) + mmReadiness.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmReadiness +} + +func (mmReadiness *mAppPublicServiceServerMockReadiness) invocationsDone() bool { + if len(mmReadiness.expectations) == 0 && mmReadiness.defaultExpectation == nil && mmReadiness.mock.funcReadiness == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmReadiness.mock.afterReadinessCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmReadiness.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// Readiness implements mm_appv1alpha.AppPublicServiceServer +func (mmReadiness *AppPublicServiceServerMock) Readiness(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) (rp2 *mm_appv1alpha.ReadinessResponse, err error) { + mm_atomic.AddUint64(&mmReadiness.beforeReadinessCounter, 1) + defer mm_atomic.AddUint64(&mmReadiness.afterReadinessCounter, 1) + + mmReadiness.t.Helper() + + if mmReadiness.inspectFuncReadiness != nil { + mmReadiness.inspectFuncReadiness(ctx, rp1) + } + + mm_params := AppPublicServiceServerMockReadinessParams{ctx, rp1} + + // Record call args + mmReadiness.ReadinessMock.mutex.Lock() + mmReadiness.ReadinessMock.callArgs = append(mmReadiness.ReadinessMock.callArgs, &mm_params) + mmReadiness.ReadinessMock.mutex.Unlock() + + for _, e := range mmReadiness.ReadinessMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.rp2, e.results.err + } + } + + if mmReadiness.ReadinessMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmReadiness.ReadinessMock.defaultExpectation.Counter, 1) + mm_want := mmReadiness.ReadinessMock.defaultExpectation.params + mm_want_ptrs := mmReadiness.ReadinessMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockReadinessParams{ctx, rp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmReadiness.t.Errorf("AppPublicServiceServerMock.Readiness got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmReadiness.ReadinessMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.rp1 != nil && !minimock.Equal(*mm_want_ptrs.rp1, mm_got.rp1) { + mmReadiness.t.Errorf("AppPublicServiceServerMock.Readiness got unexpected parameter rp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmReadiness.ReadinessMock.defaultExpectation.expectationOrigins.originRp1, *mm_want_ptrs.rp1, mm_got.rp1, minimock.Diff(*mm_want_ptrs.rp1, mm_got.rp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmReadiness.t.Errorf("AppPublicServiceServerMock.Readiness got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmReadiness.ReadinessMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmReadiness.ReadinessMock.defaultExpectation.results + if mm_results == nil { + mmReadiness.t.Fatal("No results are set for the AppPublicServiceServerMock.Readiness") + } + return (*mm_results).rp2, (*mm_results).err + } + if mmReadiness.funcReadiness != nil { + return mmReadiness.funcReadiness(ctx, rp1) + } + mmReadiness.t.Fatalf("Unexpected call to AppPublicServiceServerMock.Readiness. %v %v", ctx, rp1) + return +} + +// ReadinessAfterCounter returns a count of finished AppPublicServiceServerMock.Readiness invocations +func (mmReadiness *AppPublicServiceServerMock) ReadinessAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmReadiness.afterReadinessCounter) +} + +// ReadinessBeforeCounter returns a count of AppPublicServiceServerMock.Readiness invocations +func (mmReadiness *AppPublicServiceServerMock) ReadinessBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmReadiness.beforeReadinessCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.Readiness. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmReadiness *mAppPublicServiceServerMockReadiness) Calls() []*AppPublicServiceServerMockReadinessParams { + mmReadiness.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockReadinessParams, len(mmReadiness.callArgs)) + copy(argCopy, mmReadiness.callArgs) + + mmReadiness.mutex.RUnlock() + + return argCopy +} + +// MinimockReadinessDone returns true if the count of the Readiness invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockReadinessDone() bool { + if m.ReadinessMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ReadinessMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ReadinessMock.invocationsDone() +} + +// MinimockReadinessInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockReadinessInspect() { + for _, e := range m.ReadinessMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterReadinessCounter := mm_atomic.LoadUint64(&m.afterReadinessCounter) + // if default expectation was set then invocations count should be greater than zero + if m.ReadinessMock.defaultExpectation != nil && afterReadinessCounter < 1 { + if m.ReadinessMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s", m.ReadinessMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s with params: %#v", m.ReadinessMock.defaultExpectation.expectationOrigins.origin, *m.ReadinessMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcReadiness != nil && afterReadinessCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s", m.funcReadinessOrigin) + } + + if !m.ReadinessMock.invocationsDone() && afterReadinessCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.Readiness at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ReadinessMock.expectedInvocations), m.ReadinessMock.expectedInvocationsOrigin, afterReadinessCounter) + } +} + +type mAppPublicServiceServerMockRestartPlaygroundConversation struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockRestartPlaygroundConversationExpectation + expectations []*AppPublicServiceServerMockRestartPlaygroundConversationExpectation + + callArgs []*AppPublicServiceServerMockRestartPlaygroundConversationParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockRestartPlaygroundConversationExpectation specifies expectation struct of the AppPublicServiceServer.RestartPlaygroundConversation +type AppPublicServiceServerMockRestartPlaygroundConversationExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockRestartPlaygroundConversationParams + paramPtrs *AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs + expectationOrigins AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins + results *AppPublicServiceServerMockRestartPlaygroundConversationResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockRestartPlaygroundConversationParams contains parameters of the AppPublicServiceServer.RestartPlaygroundConversation +type AppPublicServiceServerMockRestartPlaygroundConversationParams struct { + ctx context.Context + rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest +} + +// AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs contains pointers to parameters of the AppPublicServiceServer.RestartPlaygroundConversation +type AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs struct { + ctx *context.Context + rp1 **mm_appv1alpha.RestartPlaygroundConversationRequest +} + +// AppPublicServiceServerMockRestartPlaygroundConversationResults contains results of the AppPublicServiceServer.RestartPlaygroundConversation +type AppPublicServiceServerMockRestartPlaygroundConversationResults struct { + rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse + err error +} + +// AppPublicServiceServerMockRestartPlaygroundConversationOrigins contains origins of expectations of the AppPublicServiceServer.RestartPlaygroundConversation +type AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins struct { + origin string + originCtx string + originRp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Optional() *mAppPublicServiceServerMockRestartPlaygroundConversation { + mmRestartPlaygroundConversation.optional = true + return mmRestartPlaygroundConversation +} + +// Expect sets up expected params for AppPublicServiceServer.RestartPlaygroundConversation +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Expect(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) *mAppPublicServiceServerMockRestartPlaygroundConversation { + if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") + } + + if mmRestartPlaygroundConversation.defaultExpectation == nil { + mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{} + } + + if mmRestartPlaygroundConversation.defaultExpectation.paramPtrs != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by ExpectParams functions") + } + + mmRestartPlaygroundConversation.defaultExpectation.params = &AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1} + mmRestartPlaygroundConversation.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmRestartPlaygroundConversation.expectations { + if minimock.Equal(e.params, mmRestartPlaygroundConversation.defaultExpectation.params) { + mmRestartPlaygroundConversation.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmRestartPlaygroundConversation.defaultExpectation.params) + } + } + + return mmRestartPlaygroundConversation +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.RestartPlaygroundConversation +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockRestartPlaygroundConversation { + if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") + } + + if mmRestartPlaygroundConversation.defaultExpectation == nil { + mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{} + } + + if mmRestartPlaygroundConversation.defaultExpectation.params != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Expect") + } + + if mmRestartPlaygroundConversation.defaultExpectation.paramPtrs == nil { + mmRestartPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs{} + } + mmRestartPlaygroundConversation.defaultExpectation.paramPtrs.ctx = &ctx + mmRestartPlaygroundConversation.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmRestartPlaygroundConversation +} + +// ExpectRp1Param2 sets up expected param rp1 for AppPublicServiceServer.RestartPlaygroundConversation +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) ExpectRp1Param2(rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) *mAppPublicServiceServerMockRestartPlaygroundConversation { + if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") + } + + if mmRestartPlaygroundConversation.defaultExpectation == nil { + mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{} + } + + if mmRestartPlaygroundConversation.defaultExpectation.params != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Expect") + } + + if mmRestartPlaygroundConversation.defaultExpectation.paramPtrs == nil { + mmRestartPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs{} + } + mmRestartPlaygroundConversation.defaultExpectation.paramPtrs.rp1 = &rp1 + mmRestartPlaygroundConversation.defaultExpectation.expectationOrigins.originRp1 = minimock.CallerInfo(1) + + return mmRestartPlaygroundConversation +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.RestartPlaygroundConversation +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Inspect(f func(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest)) *mAppPublicServiceServerMockRestartPlaygroundConversation { + if mmRestartPlaygroundConversation.mock.inspectFuncRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.RestartPlaygroundConversation") + } + + mmRestartPlaygroundConversation.mock.inspectFuncRestartPlaygroundConversation = f + + return mmRestartPlaygroundConversation +} + +// Return sets up results that will be returned by AppPublicServiceServer.RestartPlaygroundConversation +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Return(rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { + if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") + } + + if mmRestartPlaygroundConversation.defaultExpectation == nil { + mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{mock: mmRestartPlaygroundConversation.mock} + } + mmRestartPlaygroundConversation.defaultExpectation.results = &AppPublicServiceServerMockRestartPlaygroundConversationResults{rp2, err} + mmRestartPlaygroundConversation.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmRestartPlaygroundConversation.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.RestartPlaygroundConversation method +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Set(f func(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) (rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error)) *AppPublicServiceServerMock { + if mmRestartPlaygroundConversation.defaultExpectation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.RestartPlaygroundConversation method") + } + + if len(mmRestartPlaygroundConversation.expectations) > 0 { + mmRestartPlaygroundConversation.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.RestartPlaygroundConversation method") + } + + mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation = f + mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversationOrigin = minimock.CallerInfo(1) + return mmRestartPlaygroundConversation.mock +} + +// When sets expectation for the AppPublicServiceServer.RestartPlaygroundConversation which will trigger the result defined by the following +// Then helper +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) When(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) *AppPublicServiceServerMockRestartPlaygroundConversationExpectation { + if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{ + mock: mmRestartPlaygroundConversation.mock, + params: &AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1}, + expectationOrigins: AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmRestartPlaygroundConversation.expectations = append(mmRestartPlaygroundConversation.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.RestartPlaygroundConversation return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockRestartPlaygroundConversationExpectation) Then(rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockRestartPlaygroundConversationResults{rp2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.RestartPlaygroundConversation should be invoked +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Times(n uint64) *mAppPublicServiceServerMockRestartPlaygroundConversation { + if n == 0 { + mmRestartPlaygroundConversation.mock.t.Fatalf("Times of AppPublicServiceServerMock.RestartPlaygroundConversation mock can not be zero") + } + mm_atomic.StoreUint64(&mmRestartPlaygroundConversation.expectedInvocations, n) + mmRestartPlaygroundConversation.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmRestartPlaygroundConversation +} + +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) invocationsDone() bool { + if len(mmRestartPlaygroundConversation.expectations) == 0 && mmRestartPlaygroundConversation.defaultExpectation == nil && mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.mock.afterRestartPlaygroundConversationCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// RestartPlaygroundConversation implements mm_appv1alpha.AppPublicServiceServer +func (mmRestartPlaygroundConversation *AppPublicServiceServerMock) RestartPlaygroundConversation(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) (rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error) { + mm_atomic.AddUint64(&mmRestartPlaygroundConversation.beforeRestartPlaygroundConversationCounter, 1) + defer mm_atomic.AddUint64(&mmRestartPlaygroundConversation.afterRestartPlaygroundConversationCounter, 1) + + mmRestartPlaygroundConversation.t.Helper() + + if mmRestartPlaygroundConversation.inspectFuncRestartPlaygroundConversation != nil { + mmRestartPlaygroundConversation.inspectFuncRestartPlaygroundConversation(ctx, rp1) + } + + mm_params := AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1} + + // Record call args + mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.mutex.Lock() + mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.callArgs = append(mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.callArgs, &mm_params) + mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.mutex.Unlock() + + for _, e := range mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.rp2, e.results.err + } + } + + if mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.Counter, 1) + mm_want := mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.params + mm_want_ptrs := mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmRestartPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.RestartPlaygroundConversation got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.rp1 != nil && !minimock.Equal(*mm_want_ptrs.rp1, mm_got.rp1) { + mmRestartPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.RestartPlaygroundConversation got unexpected parameter rp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.originRp1, *mm_want_ptrs.rp1, mm_got.rp1, minimock.Diff(*mm_want_ptrs.rp1, mm_got.rp1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmRestartPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.RestartPlaygroundConversation got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.results + if mm_results == nil { + mmRestartPlaygroundConversation.t.Fatal("No results are set for the AppPublicServiceServerMock.RestartPlaygroundConversation") + } + return (*mm_results).rp2, (*mm_results).err + } + if mmRestartPlaygroundConversation.funcRestartPlaygroundConversation != nil { + return mmRestartPlaygroundConversation.funcRestartPlaygroundConversation(ctx, rp1) + } + mmRestartPlaygroundConversation.t.Fatalf("Unexpected call to AppPublicServiceServerMock.RestartPlaygroundConversation. %v %v", ctx, rp1) + return +} + +// RestartPlaygroundConversationAfterCounter returns a count of finished AppPublicServiceServerMock.RestartPlaygroundConversation invocations +func (mmRestartPlaygroundConversation *AppPublicServiceServerMock) RestartPlaygroundConversationAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.afterRestartPlaygroundConversationCounter) +} + +// RestartPlaygroundConversationBeforeCounter returns a count of AppPublicServiceServerMock.RestartPlaygroundConversation invocations +func (mmRestartPlaygroundConversation *AppPublicServiceServerMock) RestartPlaygroundConversationBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.beforeRestartPlaygroundConversationCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.RestartPlaygroundConversation. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Calls() []*AppPublicServiceServerMockRestartPlaygroundConversationParams { + mmRestartPlaygroundConversation.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockRestartPlaygroundConversationParams, len(mmRestartPlaygroundConversation.callArgs)) + copy(argCopy, mmRestartPlaygroundConversation.callArgs) + + mmRestartPlaygroundConversation.mutex.RUnlock() + + return argCopy +} + +// MinimockRestartPlaygroundConversationDone returns true if the count of the RestartPlaygroundConversation invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockRestartPlaygroundConversationDone() bool { + if m.RestartPlaygroundConversationMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.RestartPlaygroundConversationMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.RestartPlaygroundConversationMock.invocationsDone() +} + +// MinimockRestartPlaygroundConversationInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockRestartPlaygroundConversationInspect() { + for _, e := range m.RestartPlaygroundConversationMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterRestartPlaygroundConversationCounter := mm_atomic.LoadUint64(&m.afterRestartPlaygroundConversationCounter) + // if default expectation was set then invocations count should be greater than zero + if m.RestartPlaygroundConversationMock.defaultExpectation != nil && afterRestartPlaygroundConversationCounter < 1 { + if m.RestartPlaygroundConversationMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s", m.RestartPlaygroundConversationMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s with params: %#v", m.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *m.RestartPlaygroundConversationMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcRestartPlaygroundConversation != nil && afterRestartPlaygroundConversationCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s", m.funcRestartPlaygroundConversationOrigin) + } + + if !m.RestartPlaygroundConversationMock.invocationsDone() && afterRestartPlaygroundConversationCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.RestartPlaygroundConversationMock.expectedInvocations), m.RestartPlaygroundConversationMock.expectedInvocationsOrigin, afterRestartPlaygroundConversationCounter) + } +} + +type mAppPublicServiceServerMockUpdateAgent struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockUpdateAgentExpectation + expectations []*AppPublicServiceServerMockUpdateAgentExpectation + + callArgs []*AppPublicServiceServerMockUpdateAgentParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockUpdateAgentExpectation specifies expectation struct of the AppPublicServiceServer.UpdateAgent +type AppPublicServiceServerMockUpdateAgentExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockUpdateAgentParams + paramPtrs *AppPublicServiceServerMockUpdateAgentParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateAgentExpectationOrigins + results *AppPublicServiceServerMockUpdateAgentResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockUpdateAgentParams contains parameters of the AppPublicServiceServer.UpdateAgent +type AppPublicServiceServerMockUpdateAgentParams struct { + ctx context.Context + up1 *mm_appv1alpha.UpdateAgentRequest +} + +// AppPublicServiceServerMockUpdateAgentParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateAgent +type AppPublicServiceServerMockUpdateAgentParamPtrs struct { + ctx *context.Context + up1 **mm_appv1alpha.UpdateAgentRequest +} + +// AppPublicServiceServerMockUpdateAgentResults contains results of the AppPublicServiceServer.UpdateAgent +type AppPublicServiceServerMockUpdateAgentResults struct { + up2 *mm_appv1alpha.UpdateAgentResponse + err error +} + +// AppPublicServiceServerMockUpdateAgentOrigins contains origins of expectations of the AppPublicServiceServer.UpdateAgent +type AppPublicServiceServerMockUpdateAgentExpectationOrigins struct { + origin string + originCtx string + originUp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Optional() *mAppPublicServiceServerMockUpdateAgent { + mmUpdateAgent.optional = true + return mmUpdateAgent +} + +// Expect sets up expected params for AppPublicServiceServer.UpdateAgent +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) *mAppPublicServiceServerMockUpdateAgent { + if mmUpdateAgent.mock.funcUpdateAgent != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") + } + + if mmUpdateAgent.defaultExpectation == nil { + mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{} + } + + if mmUpdateAgent.defaultExpectation.paramPtrs != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by ExpectParams functions") + } + + mmUpdateAgent.defaultExpectation.params = &AppPublicServiceServerMockUpdateAgentParams{ctx, up1} + mmUpdateAgent.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateAgent.expectations { + if minimock.Equal(e.params, mmUpdateAgent.defaultExpectation.params) { + mmUpdateAgent.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateAgent.defaultExpectation.params) + } + } + + return mmUpdateAgent +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateAgent +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateAgent { + if mmUpdateAgent.mock.funcUpdateAgent != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") + } + + if mmUpdateAgent.defaultExpectation == nil { + mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{} + } + + if mmUpdateAgent.defaultExpectation.params != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Expect") + } + + if mmUpdateAgent.defaultExpectation.paramPtrs == nil { + mmUpdateAgent.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAgentParamPtrs{} + } + mmUpdateAgent.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateAgent.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmUpdateAgent +} + +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateAgent +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateAgentRequest) *mAppPublicServiceServerMockUpdateAgent { + if mmUpdateAgent.mock.funcUpdateAgent != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") + } + + if mmUpdateAgent.defaultExpectation == nil { + mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{} + } + + if mmUpdateAgent.defaultExpectation.params != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Expect") + } + + if mmUpdateAgent.defaultExpectation.paramPtrs == nil { + mmUpdateAgent.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAgentParamPtrs{} + } + mmUpdateAgent.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateAgent.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + + return mmUpdateAgent +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateAgent +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest)) *mAppPublicServiceServerMockUpdateAgent { + if mmUpdateAgent.mock.inspectFuncUpdateAgent != nil { + mmUpdateAgent.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateAgent") + } + + mmUpdateAgent.mock.inspectFuncUpdateAgent = f + + return mmUpdateAgent +} + +// Return sets up results that will be returned by AppPublicServiceServer.UpdateAgent +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Return(up2 *mm_appv1alpha.UpdateAgentResponse, err error) *AppPublicServiceServerMock { + if mmUpdateAgent.mock.funcUpdateAgent != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") + } + + if mmUpdateAgent.defaultExpectation == nil { + mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{mock: mmUpdateAgent.mock} + } + mmUpdateAgent.defaultExpectation.results = &AppPublicServiceServerMockUpdateAgentResults{up2, err} + mmUpdateAgent.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateAgent.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.UpdateAgent method +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) (up2 *mm_appv1alpha.UpdateAgentResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateAgent.defaultExpectation != nil { + mmUpdateAgent.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateAgent method") + } + + if len(mmUpdateAgent.expectations) > 0 { + mmUpdateAgent.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateAgent method") + } + + mmUpdateAgent.mock.funcUpdateAgent = f + mmUpdateAgent.mock.funcUpdateAgentOrigin = minimock.CallerInfo(1) + return mmUpdateAgent.mock +} + +// When sets expectation for the AppPublicServiceServer.UpdateAgent which will trigger the result defined by the following +// Then helper +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) When(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) *AppPublicServiceServerMockUpdateAgentExpectation { + if mmUpdateAgent.mock.funcUpdateAgent != nil { + mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockUpdateAgentExpectation{ + mock: mmUpdateAgent.mock, + params: &AppPublicServiceServerMockUpdateAgentParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateAgentExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmUpdateAgent.expectations = append(mmUpdateAgent.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.UpdateAgent return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateAgentExpectation) Then(up2 *mm_appv1alpha.UpdateAgentResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateAgentResults{up2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.UpdateAgent should be invoked +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Times(n uint64) *mAppPublicServiceServerMockUpdateAgent { + if n == 0 { + mmUpdateAgent.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateAgent mock can not be zero") + } + mm_atomic.StoreUint64(&mmUpdateAgent.expectedInvocations, n) + mmUpdateAgent.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateAgent +} + +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) invocationsDone() bool { + if len(mmUpdateAgent.expectations) == 0 && mmUpdateAgent.defaultExpectation == nil && mmUpdateAgent.mock.funcUpdateAgent == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmUpdateAgent.mock.afterUpdateAgentCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateAgent.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// UpdateAgent implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateAgent *AppPublicServiceServerMock) UpdateAgent(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) (up2 *mm_appv1alpha.UpdateAgentResponse, err error) { + mm_atomic.AddUint64(&mmUpdateAgent.beforeUpdateAgentCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateAgent.afterUpdateAgentCounter, 1) + + mmUpdateAgent.t.Helper() + + if mmUpdateAgent.inspectFuncUpdateAgent != nil { + mmUpdateAgent.inspectFuncUpdateAgent(ctx, up1) + } + + mm_params := AppPublicServiceServerMockUpdateAgentParams{ctx, up1} + + // Record call args + mmUpdateAgent.UpdateAgentMock.mutex.Lock() + mmUpdateAgent.UpdateAgentMock.callArgs = append(mmUpdateAgent.UpdateAgentMock.callArgs, &mm_params) + mmUpdateAgent.UpdateAgentMock.mutex.Unlock() + + for _, e := range mmUpdateAgent.UpdateAgentMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.up2, e.results.err + } + } + + if mmUpdateAgent.UpdateAgentMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateAgent.UpdateAgentMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateAgent.UpdateAgentMock.defaultExpectation.params + mm_want_ptrs := mmUpdateAgent.UpdateAgentMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockUpdateAgentParams{ctx, up1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmUpdateAgent.t.Errorf("AppPublicServiceServerMock.UpdateAgent got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateAgent.UpdateAgentMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { + mmUpdateAgent.t.Errorf("AppPublicServiceServerMock.UpdateAgent got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateAgent.UpdateAgentMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmUpdateAgent.t.Errorf("AppPublicServiceServerMock.UpdateAgent got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateAgent.UpdateAgentMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmUpdateAgent.UpdateAgentMock.defaultExpectation.results + if mm_results == nil { + mmUpdateAgent.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateAgent") + } + return (*mm_results).up2, (*mm_results).err + } + if mmUpdateAgent.funcUpdateAgent != nil { + return mmUpdateAgent.funcUpdateAgent(ctx, up1) + } + mmUpdateAgent.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateAgent. %v %v", ctx, up1) + return +} + +// UpdateAgentAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateAgent invocations +func (mmUpdateAgent *AppPublicServiceServerMock) UpdateAgentAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateAgent.afterUpdateAgentCounter) +} + +// UpdateAgentBeforeCounter returns a count of AppPublicServiceServerMock.UpdateAgent invocations +func (mmUpdateAgent *AppPublicServiceServerMock) UpdateAgentBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateAgent.beforeUpdateAgentCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateAgent. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Calls() []*AppPublicServiceServerMockUpdateAgentParams { + mmUpdateAgent.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockUpdateAgentParams, len(mmUpdateAgent.callArgs)) + copy(argCopy, mmUpdateAgent.callArgs) + + mmUpdateAgent.mutex.RUnlock() + + return argCopy +} + +// MinimockUpdateAgentDone returns true if the count of the UpdateAgent invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockUpdateAgentDone() bool { + if m.UpdateAgentMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.UpdateAgentMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.UpdateAgentMock.invocationsDone() +} + +// MinimockUpdateAgentInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateAgentInspect() { + for _, e := range m.UpdateAgentMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterUpdateAgentCounter := mm_atomic.LoadUint64(&m.afterUpdateAgentCounter) + // if default expectation was set then invocations count should be greater than zero + if m.UpdateAgentMock.defaultExpectation != nil && afterUpdateAgentCounter < 1 { + if m.UpdateAgentMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s", m.UpdateAgentMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s with params: %#v", m.UpdateAgentMock.defaultExpectation.expectationOrigins.origin, *m.UpdateAgentMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcUpdateAgent != nil && afterUpdateAgentCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s", m.funcUpdateAgentOrigin) + } + + if !m.UpdateAgentMock.invocationsDone() && afterUpdateAgentCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateAgent at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateAgentMock.expectedInvocations), m.UpdateAgentMock.expectedInvocationsOrigin, afterUpdateAgentCounter) + } +} + +type mAppPublicServiceServerMockUpdateApp struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockUpdateAppExpectation + expectations []*AppPublicServiceServerMockUpdateAppExpectation + + callArgs []*AppPublicServiceServerMockUpdateAppParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockUpdateAppExpectation specifies expectation struct of the AppPublicServiceServer.UpdateApp +type AppPublicServiceServerMockUpdateAppExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockUpdateAppParams + paramPtrs *AppPublicServiceServerMockUpdateAppParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateAppExpectationOrigins + results *AppPublicServiceServerMockUpdateAppResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockUpdateAppParams contains parameters of the AppPublicServiceServer.UpdateApp +type AppPublicServiceServerMockUpdateAppParams struct { + ctx context.Context + up1 *mm_appv1alpha.UpdateAppRequest +} + +// AppPublicServiceServerMockUpdateAppParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateApp +type AppPublicServiceServerMockUpdateAppParamPtrs struct { + ctx *context.Context + up1 **mm_appv1alpha.UpdateAppRequest +} + +// AppPublicServiceServerMockUpdateAppResults contains results of the AppPublicServiceServer.UpdateApp +type AppPublicServiceServerMockUpdateAppResults struct { + up2 *mm_appv1alpha.UpdateAppResponse + err error +} + +// AppPublicServiceServerMockUpdateAppOrigins contains origins of expectations of the AppPublicServiceServer.UpdateApp +type AppPublicServiceServerMockUpdateAppExpectationOrigins struct { + origin string + originCtx string + originUp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Optional() *mAppPublicServiceServerMockUpdateApp { + mmUpdateApp.optional = true + return mmUpdateApp +} + +// Expect sets up expected params for AppPublicServiceServer.UpdateApp +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) *mAppPublicServiceServerMockUpdateApp { + if mmUpdateApp.mock.funcUpdateApp != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") + } + + if mmUpdateApp.defaultExpectation == nil { + mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{} + } + + if mmUpdateApp.defaultExpectation.paramPtrs != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by ExpectParams functions") + } + + mmUpdateApp.defaultExpectation.params = &AppPublicServiceServerMockUpdateAppParams{ctx, up1} + mmUpdateApp.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateApp.expectations { + if minimock.Equal(e.params, mmUpdateApp.defaultExpectation.params) { + mmUpdateApp.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateApp.defaultExpectation.params) + } + } + + return mmUpdateApp +} + +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateApp +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateApp { + if mmUpdateApp.mock.funcUpdateApp != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") + } + + if mmUpdateApp.defaultExpectation == nil { + mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{} + } + + if mmUpdateApp.defaultExpectation.params != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Expect") + } + + if mmUpdateApp.defaultExpectation.paramPtrs == nil { + mmUpdateApp.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAppParamPtrs{} + } + mmUpdateApp.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateApp.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmUpdateApp +} + +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateApp +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateAppRequest) *mAppPublicServiceServerMockUpdateApp { + if mmUpdateApp.mock.funcUpdateApp != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") + } + + if mmUpdateApp.defaultExpectation == nil { + mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{} + } + + if mmUpdateApp.defaultExpectation.params != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Expect") + } + + if mmUpdateApp.defaultExpectation.paramPtrs == nil { + mmUpdateApp.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAppParamPtrs{} + } + mmUpdateApp.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateApp.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + + return mmUpdateApp +} + +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateApp +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest)) *mAppPublicServiceServerMockUpdateApp { + if mmUpdateApp.mock.inspectFuncUpdateApp != nil { + mmUpdateApp.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateApp") + } + + mmUpdateApp.mock.inspectFuncUpdateApp = f + + return mmUpdateApp +} + +// Return sets up results that will be returned by AppPublicServiceServer.UpdateApp +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Return(up2 *mm_appv1alpha.UpdateAppResponse, err error) *AppPublicServiceServerMock { + if mmUpdateApp.mock.funcUpdateApp != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") + } + + if mmUpdateApp.defaultExpectation == nil { + mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{mock: mmUpdateApp.mock} + } + mmUpdateApp.defaultExpectation.results = &AppPublicServiceServerMockUpdateAppResults{up2, err} + mmUpdateApp.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateApp.mock +} + +// Set uses given function f to mock the AppPublicServiceServer.UpdateApp method +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) (up2 *mm_appv1alpha.UpdateAppResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateApp.defaultExpectation != nil { + mmUpdateApp.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateApp method") + } + + if len(mmUpdateApp.expectations) > 0 { + mmUpdateApp.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateApp method") + } + + mmUpdateApp.mock.funcUpdateApp = f + mmUpdateApp.mock.funcUpdateAppOrigin = minimock.CallerInfo(1) + return mmUpdateApp.mock +} + +// When sets expectation for the AppPublicServiceServer.UpdateApp which will trigger the result defined by the following +// Then helper +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) When(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) *AppPublicServiceServerMockUpdateAppExpectation { + if mmUpdateApp.mock.funcUpdateApp != nil { + mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") + } + + expectation := &AppPublicServiceServerMockUpdateAppExpectation{ + mock: mmUpdateApp.mock, + params: &AppPublicServiceServerMockUpdateAppParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateAppExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmUpdateApp.expectations = append(mmUpdateApp.expectations, expectation) + return expectation +} + +// Then sets up AppPublicServiceServer.UpdateApp return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateAppExpectation) Then(up2 *mm_appv1alpha.UpdateAppResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateAppResults{up2, err} + return e.mock +} + +// Times sets number of times AppPublicServiceServer.UpdateApp should be invoked +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Times(n uint64) *mAppPublicServiceServerMockUpdateApp { + if n == 0 { + mmUpdateApp.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateApp mock can not be zero") + } + mm_atomic.StoreUint64(&mmUpdateApp.expectedInvocations, n) + mmUpdateApp.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateApp +} + +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) invocationsDone() bool { + if len(mmUpdateApp.expectations) == 0 && mmUpdateApp.defaultExpectation == nil && mmUpdateApp.mock.funcUpdateApp == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmUpdateApp.mock.afterUpdateAppCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateApp.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// UpdateApp implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateApp *AppPublicServiceServerMock) UpdateApp(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) (up2 *mm_appv1alpha.UpdateAppResponse, err error) { + mm_atomic.AddUint64(&mmUpdateApp.beforeUpdateAppCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateApp.afterUpdateAppCounter, 1) + + mmUpdateApp.t.Helper() + + if mmUpdateApp.inspectFuncUpdateApp != nil { + mmUpdateApp.inspectFuncUpdateApp(ctx, up1) + } + + mm_params := AppPublicServiceServerMockUpdateAppParams{ctx, up1} + + // Record call args + mmUpdateApp.UpdateAppMock.mutex.Lock() + mmUpdateApp.UpdateAppMock.callArgs = append(mmUpdateApp.UpdateAppMock.callArgs, &mm_params) + mmUpdateApp.UpdateAppMock.mutex.Unlock() + + for _, e := range mmUpdateApp.UpdateAppMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.up2, e.results.err + } + } + + if mmUpdateApp.UpdateAppMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateApp.UpdateAppMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateApp.UpdateAppMock.defaultExpectation.params + mm_want_ptrs := mmUpdateApp.UpdateAppMock.defaultExpectation.paramPtrs + + mm_got := AppPublicServiceServerMockUpdateAppParams{ctx, up1} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmUpdateApp.t.Errorf("AppPublicServiceServerMock.UpdateApp got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateApp.UpdateAppMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { + mmUpdateApp.t.Errorf("AppPublicServiceServerMock.UpdateApp got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateApp.UpdateAppMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmUpdateApp.t.Errorf("AppPublicServiceServerMock.UpdateApp got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateApp.UpdateAppMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmUpdateApp.UpdateAppMock.defaultExpectation.results + if mm_results == nil { + mmUpdateApp.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateApp") + } + return (*mm_results).up2, (*mm_results).err + } + if mmUpdateApp.funcUpdateApp != nil { + return mmUpdateApp.funcUpdateApp(ctx, up1) + } + mmUpdateApp.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateApp. %v %v", ctx, up1) + return +} + +// UpdateAppAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateApp invocations +func (mmUpdateApp *AppPublicServiceServerMock) UpdateAppAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateApp.afterUpdateAppCounter) +} + +// UpdateAppBeforeCounter returns a count of AppPublicServiceServerMock.UpdateApp invocations +func (mmUpdateApp *AppPublicServiceServerMock) UpdateAppBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateApp.beforeUpdateAppCounter) +} + +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateApp. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Calls() []*AppPublicServiceServerMockUpdateAppParams { + mmUpdateApp.mutex.RLock() + + argCopy := make([]*AppPublicServiceServerMockUpdateAppParams, len(mmUpdateApp.callArgs)) + copy(argCopy, mmUpdateApp.callArgs) + + mmUpdateApp.mutex.RUnlock() + + return argCopy +} + +// MinimockUpdateAppDone returns true if the count of the UpdateApp invocations corresponds +// the number of defined expectations +func (m *AppPublicServiceServerMock) MinimockUpdateAppDone() bool { + if m.UpdateAppMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true } - if mmReadiness.defaultExpectation.paramPtrs == nil { - mmReadiness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockReadinessParamPtrs{} + for _, e := range m.UpdateAppMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } } - mmReadiness.defaultExpectation.paramPtrs.ctx = &ctx - mmReadiness.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmReadiness + return m.UpdateAppMock.invocationsDone() } -// ExpectRp1Param2 sets up expected param rp1 for AppPublicServiceServer.Readiness -func (mmReadiness *mAppPublicServiceServerMockReadiness) ExpectRp1Param2(rp1 *mm_appv1alpha.ReadinessRequest) *mAppPublicServiceServerMockReadiness { - if mmReadiness.mock.funcReadiness != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") +// MinimockUpdateAppInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateAppInspect() { + for _, e := range m.UpdateAppMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } } - if mmReadiness.defaultExpectation == nil { - mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{} + afterUpdateAppCounter := mm_atomic.LoadUint64(&m.afterUpdateAppCounter) + // if default expectation was set then invocations count should be greater than zero + if m.UpdateAppMock.defaultExpectation != nil && afterUpdateAppCounter < 1 { + if m.UpdateAppMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s", m.UpdateAppMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s with params: %#v", m.UpdateAppMock.defaultExpectation.expectationOrigins.origin, *m.UpdateAppMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcUpdateApp != nil && afterUpdateAppCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s", m.funcUpdateAppOrigin) } - if mmReadiness.defaultExpectation.params != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Expect") + if !m.UpdateAppMock.invocationsDone() && afterUpdateAppCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateApp at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateAppMock.expectedInvocations), m.UpdateAppMock.expectedInvocationsOrigin, afterUpdateAppCounter) } +} - if mmReadiness.defaultExpectation.paramPtrs == nil { - mmReadiness.defaultExpectation.paramPtrs = &AppPublicServiceServerMockReadinessParamPtrs{} +type mAppPublicServiceServerMockUpdateChat struct { + optional bool + mock *AppPublicServiceServerMock + defaultExpectation *AppPublicServiceServerMockUpdateChatExpectation + expectations []*AppPublicServiceServerMockUpdateChatExpectation + + callArgs []*AppPublicServiceServerMockUpdateChatParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// AppPublicServiceServerMockUpdateChatExpectation specifies expectation struct of the AppPublicServiceServer.UpdateChat +type AppPublicServiceServerMockUpdateChatExpectation struct { + mock *AppPublicServiceServerMock + params *AppPublicServiceServerMockUpdateChatParams + paramPtrs *AppPublicServiceServerMockUpdateChatParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateChatExpectationOrigins + results *AppPublicServiceServerMockUpdateChatResults + returnOrigin string + Counter uint64 +} + +// AppPublicServiceServerMockUpdateChatParams contains parameters of the AppPublicServiceServer.UpdateChat +type AppPublicServiceServerMockUpdateChatParams struct { + ctx context.Context + up1 *mm_appv1alpha.UpdateChatRequest +} + +// AppPublicServiceServerMockUpdateChatParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateChat +type AppPublicServiceServerMockUpdateChatParamPtrs struct { + ctx *context.Context + up1 **mm_appv1alpha.UpdateChatRequest +} + +// AppPublicServiceServerMockUpdateChatResults contains results of the AppPublicServiceServer.UpdateChat +type AppPublicServiceServerMockUpdateChatResults struct { + up2 *mm_appv1alpha.UpdateChatResponse + err error +} + +// AppPublicServiceServerMockUpdateChatOrigins contains origins of expectations of the AppPublicServiceServer.UpdateChat +type AppPublicServiceServerMockUpdateChatExpectationOrigins struct { + origin string + originCtx string + originUp1 string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Optional() *mAppPublicServiceServerMockUpdateChat { + mmUpdateChat.optional = true + return mmUpdateChat +} + +// Expect sets up expected params for AppPublicServiceServer.UpdateChat +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) *mAppPublicServiceServerMockUpdateChat { + if mmUpdateChat.mock.funcUpdateChat != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") } - mmReadiness.defaultExpectation.paramPtrs.rp1 = &rp1 - mmReadiness.defaultExpectation.expectationOrigins.originRp1 = minimock.CallerInfo(1) - return mmReadiness + if mmUpdateChat.defaultExpectation == nil { + mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{} + } + + if mmUpdateChat.defaultExpectation.paramPtrs != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by ExpectParams functions") + } + + mmUpdateChat.defaultExpectation.params = &AppPublicServiceServerMockUpdateChatParams{ctx, up1} + mmUpdateChat.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateChat.expectations { + if minimock.Equal(e.params, mmUpdateChat.defaultExpectation.params) { + mmUpdateChat.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateChat.defaultExpectation.params) + } + } + + return mmUpdateChat } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.Readiness -func (mmReadiness *mAppPublicServiceServerMockReadiness) Inspect(f func(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest)) *mAppPublicServiceServerMockReadiness { - if mmReadiness.mock.inspectFuncReadiness != nil { - mmReadiness.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.Readiness") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateChat +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateChat { + if mmUpdateChat.mock.funcUpdateChat != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") } - mmReadiness.mock.inspectFuncReadiness = f + if mmUpdateChat.defaultExpectation == nil { + mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{} + } - return mmReadiness + if mmUpdateChat.defaultExpectation.params != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Expect") + } + + if mmUpdateChat.defaultExpectation.paramPtrs == nil { + mmUpdateChat.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateChatParamPtrs{} + } + mmUpdateChat.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateChat.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmUpdateChat } -// Return sets up results that will be returned by AppPublicServiceServer.Readiness -func (mmReadiness *mAppPublicServiceServerMockReadiness) Return(rp2 *mm_appv1alpha.ReadinessResponse, err error) *AppPublicServiceServerMock { - if mmReadiness.mock.funcReadiness != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateChat +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateChatRequest) *mAppPublicServiceServerMockUpdateChat { + if mmUpdateChat.mock.funcUpdateChat != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") } - if mmReadiness.defaultExpectation == nil { - mmReadiness.defaultExpectation = &AppPublicServiceServerMockReadinessExpectation{mock: mmReadiness.mock} + if mmUpdateChat.defaultExpectation == nil { + mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{} } - mmReadiness.defaultExpectation.results = &AppPublicServiceServerMockReadinessResults{rp2, err} - mmReadiness.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmReadiness.mock + + if mmUpdateChat.defaultExpectation.params != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Expect") + } + + if mmUpdateChat.defaultExpectation.paramPtrs == nil { + mmUpdateChat.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateChatParamPtrs{} + } + mmUpdateChat.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateChat.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + + return mmUpdateChat } -// Set uses given function f to mock the AppPublicServiceServer.Readiness method -func (mmReadiness *mAppPublicServiceServerMockReadiness) Set(f func(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) (rp2 *mm_appv1alpha.ReadinessResponse, err error)) *AppPublicServiceServerMock { - if mmReadiness.defaultExpectation != nil { - mmReadiness.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.Readiness method") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateChat +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest)) *mAppPublicServiceServerMockUpdateChat { + if mmUpdateChat.mock.inspectFuncUpdateChat != nil { + mmUpdateChat.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateChat") } - if len(mmReadiness.expectations) > 0 { - mmReadiness.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.Readiness method") + mmUpdateChat.mock.inspectFuncUpdateChat = f + + return mmUpdateChat +} + +// Return sets up results that will be returned by AppPublicServiceServer.UpdateChat +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Return(up2 *mm_appv1alpha.UpdateChatResponse, err error) *AppPublicServiceServerMock { + if mmUpdateChat.mock.funcUpdateChat != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") } - mmReadiness.mock.funcReadiness = f - mmReadiness.mock.funcReadinessOrigin = minimock.CallerInfo(1) - return mmReadiness.mock + if mmUpdateChat.defaultExpectation == nil { + mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{mock: mmUpdateChat.mock} + } + mmUpdateChat.defaultExpectation.results = &AppPublicServiceServerMockUpdateChatResults{up2, err} + mmUpdateChat.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateChat.mock } -// When sets expectation for the AppPublicServiceServer.Readiness which will trigger the result defined by the following +// Set uses given function f to mock the AppPublicServiceServer.UpdateChat method +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) (up2 *mm_appv1alpha.UpdateChatResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateChat.defaultExpectation != nil { + mmUpdateChat.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateChat method") + } + + if len(mmUpdateChat.expectations) > 0 { + mmUpdateChat.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateChat method") + } + + mmUpdateChat.mock.funcUpdateChat = f + mmUpdateChat.mock.funcUpdateChatOrigin = minimock.CallerInfo(1) + return mmUpdateChat.mock +} + +// When sets expectation for the AppPublicServiceServer.UpdateChat which will trigger the result defined by the following // Then helper -func (mmReadiness *mAppPublicServiceServerMockReadiness) When(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) *AppPublicServiceServerMockReadinessExpectation { - if mmReadiness.mock.funcReadiness != nil { - mmReadiness.mock.t.Fatalf("AppPublicServiceServerMock.Readiness mock is already set by Set") +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) When(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) *AppPublicServiceServerMockUpdateChatExpectation { + if mmUpdateChat.mock.funcUpdateChat != nil { + mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") } - expectation := &AppPublicServiceServerMockReadinessExpectation{ - mock: mmReadiness.mock, - params: &AppPublicServiceServerMockReadinessParams{ctx, rp1}, - expectationOrigins: AppPublicServiceServerMockReadinessExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateChatExpectation{ + mock: mmUpdateChat.mock, + params: &AppPublicServiceServerMockUpdateChatParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateChatExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmReadiness.expectations = append(mmReadiness.expectations, expectation) + mmUpdateChat.expectations = append(mmUpdateChat.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.Readiness return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockReadinessExpectation) Then(rp2 *mm_appv1alpha.ReadinessResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockReadinessResults{rp2, err} +// Then sets up AppPublicServiceServer.UpdateChat return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateChatExpectation) Then(up2 *mm_appv1alpha.UpdateChatResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateChatResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.Readiness should be invoked -func (mmReadiness *mAppPublicServiceServerMockReadiness) Times(n uint64) *mAppPublicServiceServerMockReadiness { +// Times sets number of times AppPublicServiceServer.UpdateChat should be invoked +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Times(n uint64) *mAppPublicServiceServerMockUpdateChat { if n == 0 { - mmReadiness.mock.t.Fatalf("Times of AppPublicServiceServerMock.Readiness mock can not be zero") + mmUpdateChat.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateChat mock can not be zero") } - mm_atomic.StoreUint64(&mmReadiness.expectedInvocations, n) - mmReadiness.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmReadiness + mm_atomic.StoreUint64(&mmUpdateChat.expectedInvocations, n) + mmUpdateChat.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateChat } -func (mmReadiness *mAppPublicServiceServerMockReadiness) invocationsDone() bool { - if len(mmReadiness.expectations) == 0 && mmReadiness.defaultExpectation == nil && mmReadiness.mock.funcReadiness == nil { +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) invocationsDone() bool { + if len(mmUpdateChat.expectations) == 0 && mmUpdateChat.defaultExpectation == nil && mmUpdateChat.mock.funcUpdateChat == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmReadiness.mock.afterReadinessCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmReadiness.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateChat.mock.afterUpdateChatCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateChat.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// Readiness implements mm_appv1alpha.AppPublicServiceServer -func (mmReadiness *AppPublicServiceServerMock) Readiness(ctx context.Context, rp1 *mm_appv1alpha.ReadinessRequest) (rp2 *mm_appv1alpha.ReadinessResponse, err error) { - mm_atomic.AddUint64(&mmReadiness.beforeReadinessCounter, 1) - defer mm_atomic.AddUint64(&mmReadiness.afterReadinessCounter, 1) +// UpdateChat implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateChat *AppPublicServiceServerMock) UpdateChat(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) (up2 *mm_appv1alpha.UpdateChatResponse, err error) { + mm_atomic.AddUint64(&mmUpdateChat.beforeUpdateChatCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateChat.afterUpdateChatCounter, 1) - mmReadiness.t.Helper() + mmUpdateChat.t.Helper() - if mmReadiness.inspectFuncReadiness != nil { - mmReadiness.inspectFuncReadiness(ctx, rp1) + if mmUpdateChat.inspectFuncUpdateChat != nil { + mmUpdateChat.inspectFuncUpdateChat(ctx, up1) } - mm_params := AppPublicServiceServerMockReadinessParams{ctx, rp1} + mm_params := AppPublicServiceServerMockUpdateChatParams{ctx, up1} // Record call args - mmReadiness.ReadinessMock.mutex.Lock() - mmReadiness.ReadinessMock.callArgs = append(mmReadiness.ReadinessMock.callArgs, &mm_params) - mmReadiness.ReadinessMock.mutex.Unlock() + mmUpdateChat.UpdateChatMock.mutex.Lock() + mmUpdateChat.UpdateChatMock.callArgs = append(mmUpdateChat.UpdateChatMock.callArgs, &mm_params) + mmUpdateChat.UpdateChatMock.mutex.Unlock() - for _, e := range mmReadiness.ReadinessMock.expectations { + for _, e := range mmUpdateChat.UpdateChatMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.rp2, e.results.err + return e.results.up2, e.results.err } } - if mmReadiness.ReadinessMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmReadiness.ReadinessMock.defaultExpectation.Counter, 1) - mm_want := mmReadiness.ReadinessMock.defaultExpectation.params - mm_want_ptrs := mmReadiness.ReadinessMock.defaultExpectation.paramPtrs + if mmUpdateChat.UpdateChatMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateChat.UpdateChatMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateChat.UpdateChatMock.defaultExpectation.params + mm_want_ptrs := mmUpdateChat.UpdateChatMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockReadinessParams{ctx, rp1} + mm_got := AppPublicServiceServerMockUpdateChatParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmReadiness.t.Errorf("AppPublicServiceServerMock.Readiness got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmReadiness.ReadinessMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateChat.t.Errorf("AppPublicServiceServerMock.UpdateChat got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateChat.UpdateChatMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.rp1 != nil && !minimock.Equal(*mm_want_ptrs.rp1, mm_got.rp1) { - mmReadiness.t.Errorf("AppPublicServiceServerMock.Readiness got unexpected parameter rp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmReadiness.ReadinessMock.defaultExpectation.expectationOrigins.originRp1, *mm_want_ptrs.rp1, mm_got.rp1, minimock.Diff(*mm_want_ptrs.rp1, mm_got.rp1)) + if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { + mmUpdateChat.t.Errorf("AppPublicServiceServerMock.UpdateChat got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateChat.UpdateChatMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmReadiness.t.Errorf("AppPublicServiceServerMock.Readiness got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmReadiness.ReadinessMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateChat.t.Errorf("AppPublicServiceServerMock.UpdateChat got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateChat.UpdateChatMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmReadiness.ReadinessMock.defaultExpectation.results + mm_results := mmUpdateChat.UpdateChatMock.defaultExpectation.results if mm_results == nil { - mmReadiness.t.Fatal("No results are set for the AppPublicServiceServerMock.Readiness") + mmUpdateChat.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateChat") } - return (*mm_results).rp2, (*mm_results).err + return (*mm_results).up2, (*mm_results).err } - if mmReadiness.funcReadiness != nil { - return mmReadiness.funcReadiness(ctx, rp1) + if mmUpdateChat.funcUpdateChat != nil { + return mmUpdateChat.funcUpdateChat(ctx, up1) } - mmReadiness.t.Fatalf("Unexpected call to AppPublicServiceServerMock.Readiness. %v %v", ctx, rp1) + mmUpdateChat.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateChat. %v %v", ctx, up1) return } -// ReadinessAfterCounter returns a count of finished AppPublicServiceServerMock.Readiness invocations -func (mmReadiness *AppPublicServiceServerMock) ReadinessAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmReadiness.afterReadinessCounter) +// UpdateChatAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateChat invocations +func (mmUpdateChat *AppPublicServiceServerMock) UpdateChatAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateChat.afterUpdateChatCounter) } -// ReadinessBeforeCounter returns a count of AppPublicServiceServerMock.Readiness invocations -func (mmReadiness *AppPublicServiceServerMock) ReadinessBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmReadiness.beforeReadinessCounter) +// UpdateChatBeforeCounter returns a count of AppPublicServiceServerMock.UpdateChat invocations +func (mmUpdateChat *AppPublicServiceServerMock) UpdateChatBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateChat.beforeUpdateChatCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.Readiness. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateChat. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmReadiness *mAppPublicServiceServerMockReadiness) Calls() []*AppPublicServiceServerMockReadinessParams { - mmReadiness.mutex.RLock() +func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Calls() []*AppPublicServiceServerMockUpdateChatParams { + mmUpdateChat.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockReadinessParams, len(mmReadiness.callArgs)) - copy(argCopy, mmReadiness.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateChatParams, len(mmUpdateChat.callArgs)) + copy(argCopy, mmUpdateChat.callArgs) - mmReadiness.mutex.RUnlock() + mmUpdateChat.mutex.RUnlock() return argCopy } -// MinimockReadinessDone returns true if the count of the Readiness invocations corresponds +// MinimockUpdateChatDone returns true if the count of the UpdateChat invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockReadinessDone() bool { - if m.ReadinessMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateChatDone() bool { + if m.UpdateChatMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.ReadinessMock.expectations { + for _, e := range m.UpdateChatMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.ReadinessMock.invocationsDone() + return m.UpdateChatMock.invocationsDone() } -// MinimockReadinessInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockReadinessInspect() { - for _, e := range m.ReadinessMock.expectations { +// MinimockUpdateChatInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateChatInspect() { + for _, e := range m.UpdateChatMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterReadinessCounter := mm_atomic.LoadUint64(&m.afterReadinessCounter) + afterUpdateChatCounter := mm_atomic.LoadUint64(&m.afterUpdateChatCounter) // if default expectation was set then invocations count should be greater than zero - if m.ReadinessMock.defaultExpectation != nil && afterReadinessCounter < 1 { - if m.ReadinessMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s", m.ReadinessMock.defaultExpectation.returnOrigin) + if m.UpdateChatMock.defaultExpectation != nil && afterUpdateChatCounter < 1 { + if m.UpdateChatMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s", m.UpdateChatMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s with params: %#v", m.ReadinessMock.defaultExpectation.expectationOrigins.origin, *m.ReadinessMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s with params: %#v", m.UpdateChatMock.defaultExpectation.expectationOrigins.origin, *m.UpdateChatMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcReadiness != nil && afterReadinessCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.Readiness at\n%s", m.funcReadinessOrigin) + if m.funcUpdateChat != nil && afterUpdateChatCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s", m.funcUpdateChatOrigin) } - if !m.ReadinessMock.invocationsDone() && afterReadinessCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.Readiness at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.ReadinessMock.expectedInvocations), m.ReadinessMock.expectedInvocationsOrigin, afterReadinessCounter) + if !m.UpdateChatMock.invocationsDone() && afterUpdateChatCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateChat at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateChatMock.expectedInvocations), m.UpdateChatMock.expectedInvocationsOrigin, afterUpdateChatCounter) } } -type mAppPublicServiceServerMockRestartPlaygroundConversation struct { +type mAppPublicServiceServerMockUpdateColumnDefinitions struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockRestartPlaygroundConversationExpectation - expectations []*AppPublicServiceServerMockRestartPlaygroundConversationExpectation + defaultExpectation *AppPublicServiceServerMockUpdateColumnDefinitionsExpectation + expectations []*AppPublicServiceServerMockUpdateColumnDefinitionsExpectation - callArgs []*AppPublicServiceServerMockRestartPlaygroundConversationParams + callArgs []*AppPublicServiceServerMockUpdateColumnDefinitionsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockRestartPlaygroundConversationExpectation specifies expectation struct of the AppPublicServiceServer.RestartPlaygroundConversation -type AppPublicServiceServerMockRestartPlaygroundConversationExpectation struct { +// AppPublicServiceServerMockUpdateColumnDefinitionsExpectation specifies expectation struct of the AppPublicServiceServer.UpdateColumnDefinitions +type AppPublicServiceServerMockUpdateColumnDefinitionsExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockRestartPlaygroundConversationParams - paramPtrs *AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs - expectationOrigins AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins - results *AppPublicServiceServerMockRestartPlaygroundConversationResults + params *AppPublicServiceServerMockUpdateColumnDefinitionsParams + paramPtrs *AppPublicServiceServerMockUpdateColumnDefinitionsParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateColumnDefinitionsExpectationOrigins + results *AppPublicServiceServerMockUpdateColumnDefinitionsResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockRestartPlaygroundConversationParams contains parameters of the AppPublicServiceServer.RestartPlaygroundConversation -type AppPublicServiceServerMockRestartPlaygroundConversationParams struct { +// AppPublicServiceServerMockUpdateColumnDefinitionsParams contains parameters of the AppPublicServiceServer.UpdateColumnDefinitions +type AppPublicServiceServerMockUpdateColumnDefinitionsParams struct { ctx context.Context - rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest + up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest } -// AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs contains pointers to parameters of the AppPublicServiceServer.RestartPlaygroundConversation -type AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs struct { +// AppPublicServiceServerMockUpdateColumnDefinitionsParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateColumnDefinitions +type AppPublicServiceServerMockUpdateColumnDefinitionsParamPtrs struct { ctx *context.Context - rp1 **mm_appv1alpha.RestartPlaygroundConversationRequest + up1 **mm_appv1alpha.UpdateColumnDefinitionsRequest } -// AppPublicServiceServerMockRestartPlaygroundConversationResults contains results of the AppPublicServiceServer.RestartPlaygroundConversation -type AppPublicServiceServerMockRestartPlaygroundConversationResults struct { - rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse +// AppPublicServiceServerMockUpdateColumnDefinitionsResults contains results of the AppPublicServiceServer.UpdateColumnDefinitions +type AppPublicServiceServerMockUpdateColumnDefinitionsResults struct { + up2 *mm_appv1alpha.UpdateColumnDefinitionsResponse err error } -// AppPublicServiceServerMockRestartPlaygroundConversationOrigins contains origins of expectations of the AppPublicServiceServer.RestartPlaygroundConversation -type AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins struct { +// AppPublicServiceServerMockUpdateColumnDefinitionsOrigins contains origins of expectations of the AppPublicServiceServer.UpdateColumnDefinitions +type AppPublicServiceServerMockUpdateColumnDefinitionsExpectationOrigins struct { origin string originCtx string - originRp1 string + originUp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -7558,339 +13205,339 @@ type AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins s // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Optional() *mAppPublicServiceServerMockRestartPlaygroundConversation { - mmRestartPlaygroundConversation.optional = true - return mmRestartPlaygroundConversation +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Optional() *mAppPublicServiceServerMockUpdateColumnDefinitions { + mmUpdateColumnDefinitions.optional = true + return mmUpdateColumnDefinitions } -// Expect sets up expected params for AppPublicServiceServer.RestartPlaygroundConversation -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Expect(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) *mAppPublicServiceServerMockRestartPlaygroundConversation { - if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.UpdateColumnDefinitions +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) *mAppPublicServiceServerMockUpdateColumnDefinitions { + if mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Set") } - if mmRestartPlaygroundConversation.defaultExpectation == nil { - mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{} + if mmUpdateColumnDefinitions.defaultExpectation == nil { + mmUpdateColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockUpdateColumnDefinitionsExpectation{} } - if mmRestartPlaygroundConversation.defaultExpectation.paramPtrs != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by ExpectParams functions") + if mmUpdateColumnDefinitions.defaultExpectation.paramPtrs != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by ExpectParams functions") } - mmRestartPlaygroundConversation.defaultExpectation.params = &AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1} - mmRestartPlaygroundConversation.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmRestartPlaygroundConversation.expectations { - if minimock.Equal(e.params, mmRestartPlaygroundConversation.defaultExpectation.params) { - mmRestartPlaygroundConversation.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmRestartPlaygroundConversation.defaultExpectation.params) + mmUpdateColumnDefinitions.defaultExpectation.params = &AppPublicServiceServerMockUpdateColumnDefinitionsParams{ctx, up1} + mmUpdateColumnDefinitions.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateColumnDefinitions.expectations { + if minimock.Equal(e.params, mmUpdateColumnDefinitions.defaultExpectation.params) { + mmUpdateColumnDefinitions.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateColumnDefinitions.defaultExpectation.params) } } - return mmRestartPlaygroundConversation + return mmUpdateColumnDefinitions } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.RestartPlaygroundConversation -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockRestartPlaygroundConversation { - if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateColumnDefinitions +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateColumnDefinitions { + if mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Set") } - if mmRestartPlaygroundConversation.defaultExpectation == nil { - mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{} + if mmUpdateColumnDefinitions.defaultExpectation == nil { + mmUpdateColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockUpdateColumnDefinitionsExpectation{} } - if mmRestartPlaygroundConversation.defaultExpectation.params != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Expect") + if mmUpdateColumnDefinitions.defaultExpectation.params != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Expect") } - if mmRestartPlaygroundConversation.defaultExpectation.paramPtrs == nil { - mmRestartPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs{} + if mmUpdateColumnDefinitions.defaultExpectation.paramPtrs == nil { + mmUpdateColumnDefinitions.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateColumnDefinitionsParamPtrs{} } - mmRestartPlaygroundConversation.defaultExpectation.paramPtrs.ctx = &ctx - mmRestartPlaygroundConversation.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmUpdateColumnDefinitions.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateColumnDefinitions.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmRestartPlaygroundConversation + return mmUpdateColumnDefinitions } -// ExpectRp1Param2 sets up expected param rp1 for AppPublicServiceServer.RestartPlaygroundConversation -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) ExpectRp1Param2(rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) *mAppPublicServiceServerMockRestartPlaygroundConversation { - if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateColumnDefinitions +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) *mAppPublicServiceServerMockUpdateColumnDefinitions { + if mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Set") } - if mmRestartPlaygroundConversation.defaultExpectation == nil { - mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{} + if mmUpdateColumnDefinitions.defaultExpectation == nil { + mmUpdateColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockUpdateColumnDefinitionsExpectation{} } - if mmRestartPlaygroundConversation.defaultExpectation.params != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Expect") + if mmUpdateColumnDefinitions.defaultExpectation.params != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Expect") } - if mmRestartPlaygroundConversation.defaultExpectation.paramPtrs == nil { - mmRestartPlaygroundConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockRestartPlaygroundConversationParamPtrs{} + if mmUpdateColumnDefinitions.defaultExpectation.paramPtrs == nil { + mmUpdateColumnDefinitions.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateColumnDefinitionsParamPtrs{} } - mmRestartPlaygroundConversation.defaultExpectation.paramPtrs.rp1 = &rp1 - mmRestartPlaygroundConversation.defaultExpectation.expectationOrigins.originRp1 = minimock.CallerInfo(1) + mmUpdateColumnDefinitions.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateColumnDefinitions.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) - return mmRestartPlaygroundConversation + return mmUpdateColumnDefinitions } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.RestartPlaygroundConversation -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Inspect(f func(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest)) *mAppPublicServiceServerMockRestartPlaygroundConversation { - if mmRestartPlaygroundConversation.mock.inspectFuncRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.RestartPlaygroundConversation") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateColumnDefinitions +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest)) *mAppPublicServiceServerMockUpdateColumnDefinitions { + if mmUpdateColumnDefinitions.mock.inspectFuncUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateColumnDefinitions") } - mmRestartPlaygroundConversation.mock.inspectFuncRestartPlaygroundConversation = f + mmUpdateColumnDefinitions.mock.inspectFuncUpdateColumnDefinitions = f - return mmRestartPlaygroundConversation + return mmUpdateColumnDefinitions } -// Return sets up results that will be returned by AppPublicServiceServer.RestartPlaygroundConversation -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Return(rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { - if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.UpdateColumnDefinitions +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Return(up2 *mm_appv1alpha.UpdateColumnDefinitionsResponse, err error) *AppPublicServiceServerMock { + if mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Set") } - if mmRestartPlaygroundConversation.defaultExpectation == nil { - mmRestartPlaygroundConversation.defaultExpectation = &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{mock: mmRestartPlaygroundConversation.mock} + if mmUpdateColumnDefinitions.defaultExpectation == nil { + mmUpdateColumnDefinitions.defaultExpectation = &AppPublicServiceServerMockUpdateColumnDefinitionsExpectation{mock: mmUpdateColumnDefinitions.mock} } - mmRestartPlaygroundConversation.defaultExpectation.results = &AppPublicServiceServerMockRestartPlaygroundConversationResults{rp2, err} - mmRestartPlaygroundConversation.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmRestartPlaygroundConversation.mock + mmUpdateColumnDefinitions.defaultExpectation.results = &AppPublicServiceServerMockUpdateColumnDefinitionsResults{up2, err} + mmUpdateColumnDefinitions.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateColumnDefinitions.mock } -// Set uses given function f to mock the AppPublicServiceServer.RestartPlaygroundConversation method -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Set(f func(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) (rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error)) *AppPublicServiceServerMock { - if mmRestartPlaygroundConversation.defaultExpectation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.RestartPlaygroundConversation method") +// Set uses given function f to mock the AppPublicServiceServer.UpdateColumnDefinitions method +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) (up2 *mm_appv1alpha.UpdateColumnDefinitionsResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateColumnDefinitions.defaultExpectation != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateColumnDefinitions method") } - if len(mmRestartPlaygroundConversation.expectations) > 0 { - mmRestartPlaygroundConversation.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.RestartPlaygroundConversation method") + if len(mmUpdateColumnDefinitions.expectations) > 0 { + mmUpdateColumnDefinitions.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateColumnDefinitions method") } - mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation = f - mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversationOrigin = minimock.CallerInfo(1) - return mmRestartPlaygroundConversation.mock + mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions = f + mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitionsOrigin = minimock.CallerInfo(1) + return mmUpdateColumnDefinitions.mock } -// When sets expectation for the AppPublicServiceServer.RestartPlaygroundConversation which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.UpdateColumnDefinitions which will trigger the result defined by the following // Then helper -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) When(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) *AppPublicServiceServerMockRestartPlaygroundConversationExpectation { - if mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.mock.t.Fatalf("AppPublicServiceServerMock.RestartPlaygroundConversation mock is already set by Set") +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) When(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) *AppPublicServiceServerMockUpdateColumnDefinitionsExpectation { + if mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.mock.t.Fatalf("AppPublicServiceServerMock.UpdateColumnDefinitions mock is already set by Set") } - expectation := &AppPublicServiceServerMockRestartPlaygroundConversationExpectation{ - mock: mmRestartPlaygroundConversation.mock, - params: &AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1}, - expectationOrigins: AppPublicServiceServerMockRestartPlaygroundConversationExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateColumnDefinitionsExpectation{ + mock: mmUpdateColumnDefinitions.mock, + params: &AppPublicServiceServerMockUpdateColumnDefinitionsParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateColumnDefinitionsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmRestartPlaygroundConversation.expectations = append(mmRestartPlaygroundConversation.expectations, expectation) + mmUpdateColumnDefinitions.expectations = append(mmUpdateColumnDefinitions.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.RestartPlaygroundConversation return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockRestartPlaygroundConversationExpectation) Then(rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockRestartPlaygroundConversationResults{rp2, err} +// Then sets up AppPublicServiceServer.UpdateColumnDefinitions return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateColumnDefinitionsExpectation) Then(up2 *mm_appv1alpha.UpdateColumnDefinitionsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateColumnDefinitionsResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.RestartPlaygroundConversation should be invoked -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Times(n uint64) *mAppPublicServiceServerMockRestartPlaygroundConversation { +// Times sets number of times AppPublicServiceServer.UpdateColumnDefinitions should be invoked +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Times(n uint64) *mAppPublicServiceServerMockUpdateColumnDefinitions { if n == 0 { - mmRestartPlaygroundConversation.mock.t.Fatalf("Times of AppPublicServiceServerMock.RestartPlaygroundConversation mock can not be zero") + mmUpdateColumnDefinitions.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateColumnDefinitions mock can not be zero") } - mm_atomic.StoreUint64(&mmRestartPlaygroundConversation.expectedInvocations, n) - mmRestartPlaygroundConversation.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmRestartPlaygroundConversation + mm_atomic.StoreUint64(&mmUpdateColumnDefinitions.expectedInvocations, n) + mmUpdateColumnDefinitions.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateColumnDefinitions } -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) invocationsDone() bool { - if len(mmRestartPlaygroundConversation.expectations) == 0 && mmRestartPlaygroundConversation.defaultExpectation == nil && mmRestartPlaygroundConversation.mock.funcRestartPlaygroundConversation == nil { +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) invocationsDone() bool { + if len(mmUpdateColumnDefinitions.expectations) == 0 && mmUpdateColumnDefinitions.defaultExpectation == nil && mmUpdateColumnDefinitions.mock.funcUpdateColumnDefinitions == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.mock.afterRestartPlaygroundConversationCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateColumnDefinitions.mock.afterUpdateColumnDefinitionsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateColumnDefinitions.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// RestartPlaygroundConversation implements mm_appv1alpha.AppPublicServiceServer -func (mmRestartPlaygroundConversation *AppPublicServiceServerMock) RestartPlaygroundConversation(ctx context.Context, rp1 *mm_appv1alpha.RestartPlaygroundConversationRequest) (rp2 *mm_appv1alpha.RestartPlaygroundConversationResponse, err error) { - mm_atomic.AddUint64(&mmRestartPlaygroundConversation.beforeRestartPlaygroundConversationCounter, 1) - defer mm_atomic.AddUint64(&mmRestartPlaygroundConversation.afterRestartPlaygroundConversationCounter, 1) +// UpdateColumnDefinitions implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateColumnDefinitions *AppPublicServiceServerMock) UpdateColumnDefinitions(ctx context.Context, up1 *mm_appv1alpha.UpdateColumnDefinitionsRequest) (up2 *mm_appv1alpha.UpdateColumnDefinitionsResponse, err error) { + mm_atomic.AddUint64(&mmUpdateColumnDefinitions.beforeUpdateColumnDefinitionsCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateColumnDefinitions.afterUpdateColumnDefinitionsCounter, 1) - mmRestartPlaygroundConversation.t.Helper() + mmUpdateColumnDefinitions.t.Helper() - if mmRestartPlaygroundConversation.inspectFuncRestartPlaygroundConversation != nil { - mmRestartPlaygroundConversation.inspectFuncRestartPlaygroundConversation(ctx, rp1) + if mmUpdateColumnDefinitions.inspectFuncUpdateColumnDefinitions != nil { + mmUpdateColumnDefinitions.inspectFuncUpdateColumnDefinitions(ctx, up1) } - mm_params := AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1} + mm_params := AppPublicServiceServerMockUpdateColumnDefinitionsParams{ctx, up1} // Record call args - mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.mutex.Lock() - mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.callArgs = append(mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.callArgs, &mm_params) - mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.mutex.Unlock() + mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.mutex.Lock() + mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.callArgs = append(mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.callArgs, &mm_params) + mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.mutex.Unlock() - for _, e := range mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.expectations { + for _, e := range mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.rp2, e.results.err + return e.results.up2, e.results.err } } - if mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.Counter, 1) - mm_want := mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.params - mm_want_ptrs := mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.paramPtrs + if mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.params + mm_want_ptrs := mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockRestartPlaygroundConversationParams{ctx, rp1} + mm_got := AppPublicServiceServerMockUpdateColumnDefinitionsParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmRestartPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.RestartPlaygroundConversation got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateColumnDefinitions.t.Errorf("AppPublicServiceServerMock.UpdateColumnDefinitions got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.rp1 != nil && !minimock.Equal(*mm_want_ptrs.rp1, mm_got.rp1) { - mmRestartPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.RestartPlaygroundConversation got unexpected parameter rp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.originRp1, *mm_want_ptrs.rp1, mm_got.rp1, minimock.Diff(*mm_want_ptrs.rp1, mm_got.rp1)) + if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { + mmUpdateColumnDefinitions.t.Errorf("AppPublicServiceServerMock.UpdateColumnDefinitions got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmRestartPlaygroundConversation.t.Errorf("AppPublicServiceServerMock.RestartPlaygroundConversation got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateColumnDefinitions.t.Errorf("AppPublicServiceServerMock.UpdateColumnDefinitions got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmRestartPlaygroundConversation.RestartPlaygroundConversationMock.defaultExpectation.results + mm_results := mmUpdateColumnDefinitions.UpdateColumnDefinitionsMock.defaultExpectation.results if mm_results == nil { - mmRestartPlaygroundConversation.t.Fatal("No results are set for the AppPublicServiceServerMock.RestartPlaygroundConversation") + mmUpdateColumnDefinitions.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateColumnDefinitions") } - return (*mm_results).rp2, (*mm_results).err + return (*mm_results).up2, (*mm_results).err } - if mmRestartPlaygroundConversation.funcRestartPlaygroundConversation != nil { - return mmRestartPlaygroundConversation.funcRestartPlaygroundConversation(ctx, rp1) + if mmUpdateColumnDefinitions.funcUpdateColumnDefinitions != nil { + return mmUpdateColumnDefinitions.funcUpdateColumnDefinitions(ctx, up1) } - mmRestartPlaygroundConversation.t.Fatalf("Unexpected call to AppPublicServiceServerMock.RestartPlaygroundConversation. %v %v", ctx, rp1) + mmUpdateColumnDefinitions.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateColumnDefinitions. %v %v", ctx, up1) return } -// RestartPlaygroundConversationAfterCounter returns a count of finished AppPublicServiceServerMock.RestartPlaygroundConversation invocations -func (mmRestartPlaygroundConversation *AppPublicServiceServerMock) RestartPlaygroundConversationAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.afterRestartPlaygroundConversationCounter) +// UpdateColumnDefinitionsAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateColumnDefinitions invocations +func (mmUpdateColumnDefinitions *AppPublicServiceServerMock) UpdateColumnDefinitionsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateColumnDefinitions.afterUpdateColumnDefinitionsCounter) } -// RestartPlaygroundConversationBeforeCounter returns a count of AppPublicServiceServerMock.RestartPlaygroundConversation invocations -func (mmRestartPlaygroundConversation *AppPublicServiceServerMock) RestartPlaygroundConversationBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmRestartPlaygroundConversation.beforeRestartPlaygroundConversationCounter) +// UpdateColumnDefinitionsBeforeCounter returns a count of AppPublicServiceServerMock.UpdateColumnDefinitions invocations +func (mmUpdateColumnDefinitions *AppPublicServiceServerMock) UpdateColumnDefinitionsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateColumnDefinitions.beforeUpdateColumnDefinitionsCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.RestartPlaygroundConversation. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateColumnDefinitions. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmRestartPlaygroundConversation *mAppPublicServiceServerMockRestartPlaygroundConversation) Calls() []*AppPublicServiceServerMockRestartPlaygroundConversationParams { - mmRestartPlaygroundConversation.mutex.RLock() +func (mmUpdateColumnDefinitions *mAppPublicServiceServerMockUpdateColumnDefinitions) Calls() []*AppPublicServiceServerMockUpdateColumnDefinitionsParams { + mmUpdateColumnDefinitions.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockRestartPlaygroundConversationParams, len(mmRestartPlaygroundConversation.callArgs)) - copy(argCopy, mmRestartPlaygroundConversation.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateColumnDefinitionsParams, len(mmUpdateColumnDefinitions.callArgs)) + copy(argCopy, mmUpdateColumnDefinitions.callArgs) - mmRestartPlaygroundConversation.mutex.RUnlock() + mmUpdateColumnDefinitions.mutex.RUnlock() return argCopy } -// MinimockRestartPlaygroundConversationDone returns true if the count of the RestartPlaygroundConversation invocations corresponds +// MinimockUpdateColumnDefinitionsDone returns true if the count of the UpdateColumnDefinitions invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockRestartPlaygroundConversationDone() bool { - if m.RestartPlaygroundConversationMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateColumnDefinitionsDone() bool { + if m.UpdateColumnDefinitionsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.RestartPlaygroundConversationMock.expectations { + for _, e := range m.UpdateColumnDefinitionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.RestartPlaygroundConversationMock.invocationsDone() + return m.UpdateColumnDefinitionsMock.invocationsDone() } -// MinimockRestartPlaygroundConversationInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockRestartPlaygroundConversationInspect() { - for _, e := range m.RestartPlaygroundConversationMock.expectations { +// MinimockUpdateColumnDefinitionsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateColumnDefinitionsInspect() { + for _, e := range m.UpdateColumnDefinitionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateColumnDefinitions at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterRestartPlaygroundConversationCounter := mm_atomic.LoadUint64(&m.afterRestartPlaygroundConversationCounter) + afterUpdateColumnDefinitionsCounter := mm_atomic.LoadUint64(&m.afterUpdateColumnDefinitionsCounter) // if default expectation was set then invocations count should be greater than zero - if m.RestartPlaygroundConversationMock.defaultExpectation != nil && afterRestartPlaygroundConversationCounter < 1 { - if m.RestartPlaygroundConversationMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s", m.RestartPlaygroundConversationMock.defaultExpectation.returnOrigin) + if m.UpdateColumnDefinitionsMock.defaultExpectation != nil && afterUpdateColumnDefinitionsCounter < 1 { + if m.UpdateColumnDefinitionsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateColumnDefinitions at\n%s", m.UpdateColumnDefinitionsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s with params: %#v", m.RestartPlaygroundConversationMock.defaultExpectation.expectationOrigins.origin, *m.RestartPlaygroundConversationMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateColumnDefinitions at\n%s with params: %#v", m.UpdateColumnDefinitionsMock.defaultExpectation.expectationOrigins.origin, *m.UpdateColumnDefinitionsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcRestartPlaygroundConversation != nil && afterRestartPlaygroundConversationCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s", m.funcRestartPlaygroundConversationOrigin) + if m.funcUpdateColumnDefinitions != nil && afterUpdateColumnDefinitionsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateColumnDefinitions at\n%s", m.funcUpdateColumnDefinitionsOrigin) } - if !m.RestartPlaygroundConversationMock.invocationsDone() && afterRestartPlaygroundConversationCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.RestartPlaygroundConversation at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.RestartPlaygroundConversationMock.expectedInvocations), m.RestartPlaygroundConversationMock.expectedInvocationsOrigin, afterRestartPlaygroundConversationCounter) + if !m.UpdateColumnDefinitionsMock.invocationsDone() && afterUpdateColumnDefinitionsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateColumnDefinitions at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateColumnDefinitionsMock.expectedInvocations), m.UpdateColumnDefinitionsMock.expectedInvocationsOrigin, afterUpdateColumnDefinitionsCounter) } } -type mAppPublicServiceServerMockUpdateAgent struct { +type mAppPublicServiceServerMockUpdateConversation struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockUpdateAgentExpectation - expectations []*AppPublicServiceServerMockUpdateAgentExpectation + defaultExpectation *AppPublicServiceServerMockUpdateConversationExpectation + expectations []*AppPublicServiceServerMockUpdateConversationExpectation - callArgs []*AppPublicServiceServerMockUpdateAgentParams + callArgs []*AppPublicServiceServerMockUpdateConversationParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockUpdateAgentExpectation specifies expectation struct of the AppPublicServiceServer.UpdateAgent -type AppPublicServiceServerMockUpdateAgentExpectation struct { +// AppPublicServiceServerMockUpdateConversationExpectation specifies expectation struct of the AppPublicServiceServer.UpdateConversation +type AppPublicServiceServerMockUpdateConversationExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockUpdateAgentParams - paramPtrs *AppPublicServiceServerMockUpdateAgentParamPtrs - expectationOrigins AppPublicServiceServerMockUpdateAgentExpectationOrigins - results *AppPublicServiceServerMockUpdateAgentResults + params *AppPublicServiceServerMockUpdateConversationParams + paramPtrs *AppPublicServiceServerMockUpdateConversationParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateConversationExpectationOrigins + results *AppPublicServiceServerMockUpdateConversationResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockUpdateAgentParams contains parameters of the AppPublicServiceServer.UpdateAgent -type AppPublicServiceServerMockUpdateAgentParams struct { +// AppPublicServiceServerMockUpdateConversationParams contains parameters of the AppPublicServiceServer.UpdateConversation +type AppPublicServiceServerMockUpdateConversationParams struct { ctx context.Context - up1 *mm_appv1alpha.UpdateAgentRequest + up1 *mm_appv1alpha.UpdateConversationRequest } -// AppPublicServiceServerMockUpdateAgentParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateAgent -type AppPublicServiceServerMockUpdateAgentParamPtrs struct { +// AppPublicServiceServerMockUpdateConversationParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateConversation +type AppPublicServiceServerMockUpdateConversationParamPtrs struct { ctx *context.Context - up1 **mm_appv1alpha.UpdateAgentRequest + up1 **mm_appv1alpha.UpdateConversationRequest } -// AppPublicServiceServerMockUpdateAgentResults contains results of the AppPublicServiceServer.UpdateAgent -type AppPublicServiceServerMockUpdateAgentResults struct { - up2 *mm_appv1alpha.UpdateAgentResponse +// AppPublicServiceServerMockUpdateConversationResults contains results of the AppPublicServiceServer.UpdateConversation +type AppPublicServiceServerMockUpdateConversationResults struct { + up2 *mm_appv1alpha.UpdateConversationResponse err error } -// AppPublicServiceServerMockUpdateAgentOrigins contains origins of expectations of the AppPublicServiceServer.UpdateAgent -type AppPublicServiceServerMockUpdateAgentExpectationOrigins struct { +// AppPublicServiceServerMockUpdateConversationOrigins contains origins of expectations of the AppPublicServiceServer.UpdateConversation +type AppPublicServiceServerMockUpdateConversationExpectationOrigins struct { origin string originCtx string originUp1 string @@ -7901,339 +13548,339 @@ type AppPublicServiceServerMockUpdateAgentExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Optional() *mAppPublicServiceServerMockUpdateAgent { - mmUpdateAgent.optional = true - return mmUpdateAgent +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Optional() *mAppPublicServiceServerMockUpdateConversation { + mmUpdateConversation.optional = true + return mmUpdateConversation } -// Expect sets up expected params for AppPublicServiceServer.UpdateAgent -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) *mAppPublicServiceServerMockUpdateAgent { - if mmUpdateAgent.mock.funcUpdateAgent != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.UpdateConversation +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) *mAppPublicServiceServerMockUpdateConversation { + if mmUpdateConversation.mock.funcUpdateConversation != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") } - if mmUpdateAgent.defaultExpectation == nil { - mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{} + if mmUpdateConversation.defaultExpectation == nil { + mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{} } - if mmUpdateAgent.defaultExpectation.paramPtrs != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by ExpectParams functions") + if mmUpdateConversation.defaultExpectation.paramPtrs != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by ExpectParams functions") } - mmUpdateAgent.defaultExpectation.params = &AppPublicServiceServerMockUpdateAgentParams{ctx, up1} - mmUpdateAgent.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmUpdateAgent.expectations { - if minimock.Equal(e.params, mmUpdateAgent.defaultExpectation.params) { - mmUpdateAgent.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateAgent.defaultExpectation.params) + mmUpdateConversation.defaultExpectation.params = &AppPublicServiceServerMockUpdateConversationParams{ctx, up1} + mmUpdateConversation.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateConversation.expectations { + if minimock.Equal(e.params, mmUpdateConversation.defaultExpectation.params) { + mmUpdateConversation.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateConversation.defaultExpectation.params) } } - return mmUpdateAgent + return mmUpdateConversation } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateAgent -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateAgent { - if mmUpdateAgent.mock.funcUpdateAgent != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateConversation +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateConversation { + if mmUpdateConversation.mock.funcUpdateConversation != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") } - if mmUpdateAgent.defaultExpectation == nil { - mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{} + if mmUpdateConversation.defaultExpectation == nil { + mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{} } - if mmUpdateAgent.defaultExpectation.params != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Expect") + if mmUpdateConversation.defaultExpectation.params != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Expect") } - if mmUpdateAgent.defaultExpectation.paramPtrs == nil { - mmUpdateAgent.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAgentParamPtrs{} + if mmUpdateConversation.defaultExpectation.paramPtrs == nil { + mmUpdateConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateConversationParamPtrs{} } - mmUpdateAgent.defaultExpectation.paramPtrs.ctx = &ctx - mmUpdateAgent.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmUpdateConversation.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateConversation.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmUpdateAgent + return mmUpdateConversation } -// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateAgent -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateAgentRequest) *mAppPublicServiceServerMockUpdateAgent { - if mmUpdateAgent.mock.funcUpdateAgent != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateConversation +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateConversationRequest) *mAppPublicServiceServerMockUpdateConversation { + if mmUpdateConversation.mock.funcUpdateConversation != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") } - if mmUpdateAgent.defaultExpectation == nil { - mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{} + if mmUpdateConversation.defaultExpectation == nil { + mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{} } - if mmUpdateAgent.defaultExpectation.params != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Expect") + if mmUpdateConversation.defaultExpectation.params != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Expect") } - if mmUpdateAgent.defaultExpectation.paramPtrs == nil { - mmUpdateAgent.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAgentParamPtrs{} + if mmUpdateConversation.defaultExpectation.paramPtrs == nil { + mmUpdateConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateConversationParamPtrs{} } - mmUpdateAgent.defaultExpectation.paramPtrs.up1 = &up1 - mmUpdateAgent.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + mmUpdateConversation.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateConversation.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) - return mmUpdateAgent + return mmUpdateConversation } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateAgent -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest)) *mAppPublicServiceServerMockUpdateAgent { - if mmUpdateAgent.mock.inspectFuncUpdateAgent != nil { - mmUpdateAgent.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateAgent") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateConversation +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest)) *mAppPublicServiceServerMockUpdateConversation { + if mmUpdateConversation.mock.inspectFuncUpdateConversation != nil { + mmUpdateConversation.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateConversation") } - mmUpdateAgent.mock.inspectFuncUpdateAgent = f + mmUpdateConversation.mock.inspectFuncUpdateConversation = f - return mmUpdateAgent + return mmUpdateConversation } -// Return sets up results that will be returned by AppPublicServiceServer.UpdateAgent -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Return(up2 *mm_appv1alpha.UpdateAgentResponse, err error) *AppPublicServiceServerMock { - if mmUpdateAgent.mock.funcUpdateAgent != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.UpdateConversation +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Return(up2 *mm_appv1alpha.UpdateConversationResponse, err error) *AppPublicServiceServerMock { + if mmUpdateConversation.mock.funcUpdateConversation != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") } - if mmUpdateAgent.defaultExpectation == nil { - mmUpdateAgent.defaultExpectation = &AppPublicServiceServerMockUpdateAgentExpectation{mock: mmUpdateAgent.mock} + if mmUpdateConversation.defaultExpectation == nil { + mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{mock: mmUpdateConversation.mock} } - mmUpdateAgent.defaultExpectation.results = &AppPublicServiceServerMockUpdateAgentResults{up2, err} - mmUpdateAgent.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmUpdateAgent.mock + mmUpdateConversation.defaultExpectation.results = &AppPublicServiceServerMockUpdateConversationResults{up2, err} + mmUpdateConversation.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateConversation.mock } -// Set uses given function f to mock the AppPublicServiceServer.UpdateAgent method -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) (up2 *mm_appv1alpha.UpdateAgentResponse, err error)) *AppPublicServiceServerMock { - if mmUpdateAgent.defaultExpectation != nil { - mmUpdateAgent.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateAgent method") +// Set uses given function f to mock the AppPublicServiceServer.UpdateConversation method +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) (up2 *mm_appv1alpha.UpdateConversationResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateConversation.defaultExpectation != nil { + mmUpdateConversation.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateConversation method") } - if len(mmUpdateAgent.expectations) > 0 { - mmUpdateAgent.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateAgent method") + if len(mmUpdateConversation.expectations) > 0 { + mmUpdateConversation.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateConversation method") } - mmUpdateAgent.mock.funcUpdateAgent = f - mmUpdateAgent.mock.funcUpdateAgentOrigin = minimock.CallerInfo(1) - return mmUpdateAgent.mock + mmUpdateConversation.mock.funcUpdateConversation = f + mmUpdateConversation.mock.funcUpdateConversationOrigin = minimock.CallerInfo(1) + return mmUpdateConversation.mock } -// When sets expectation for the AppPublicServiceServer.UpdateAgent which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.UpdateConversation which will trigger the result defined by the following // Then helper -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) When(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) *AppPublicServiceServerMockUpdateAgentExpectation { - if mmUpdateAgent.mock.funcUpdateAgent != nil { - mmUpdateAgent.mock.t.Fatalf("AppPublicServiceServerMock.UpdateAgent mock is already set by Set") +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) When(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) *AppPublicServiceServerMockUpdateConversationExpectation { + if mmUpdateConversation.mock.funcUpdateConversation != nil { + mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") } - expectation := &AppPublicServiceServerMockUpdateAgentExpectation{ - mock: mmUpdateAgent.mock, - params: &AppPublicServiceServerMockUpdateAgentParams{ctx, up1}, - expectationOrigins: AppPublicServiceServerMockUpdateAgentExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateConversationExpectation{ + mock: mmUpdateConversation.mock, + params: &AppPublicServiceServerMockUpdateConversationParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateConversationExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmUpdateAgent.expectations = append(mmUpdateAgent.expectations, expectation) + mmUpdateConversation.expectations = append(mmUpdateConversation.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.UpdateAgent return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockUpdateAgentExpectation) Then(up2 *mm_appv1alpha.UpdateAgentResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockUpdateAgentResults{up2, err} +// Then sets up AppPublicServiceServer.UpdateConversation return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateConversationExpectation) Then(up2 *mm_appv1alpha.UpdateConversationResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateConversationResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.UpdateAgent should be invoked -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Times(n uint64) *mAppPublicServiceServerMockUpdateAgent { +// Times sets number of times AppPublicServiceServer.UpdateConversation should be invoked +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Times(n uint64) *mAppPublicServiceServerMockUpdateConversation { if n == 0 { - mmUpdateAgent.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateAgent mock can not be zero") + mmUpdateConversation.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateConversation mock can not be zero") } - mm_atomic.StoreUint64(&mmUpdateAgent.expectedInvocations, n) - mmUpdateAgent.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmUpdateAgent + mm_atomic.StoreUint64(&mmUpdateConversation.expectedInvocations, n) + mmUpdateConversation.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateConversation } -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) invocationsDone() bool { - if len(mmUpdateAgent.expectations) == 0 && mmUpdateAgent.defaultExpectation == nil && mmUpdateAgent.mock.funcUpdateAgent == nil { +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) invocationsDone() bool { + if len(mmUpdateConversation.expectations) == 0 && mmUpdateConversation.defaultExpectation == nil && mmUpdateConversation.mock.funcUpdateConversation == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmUpdateAgent.mock.afterUpdateAgentCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmUpdateAgent.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateConversation.mock.afterUpdateConversationCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateConversation.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// UpdateAgent implements mm_appv1alpha.AppPublicServiceServer -func (mmUpdateAgent *AppPublicServiceServerMock) UpdateAgent(ctx context.Context, up1 *mm_appv1alpha.UpdateAgentRequest) (up2 *mm_appv1alpha.UpdateAgentResponse, err error) { - mm_atomic.AddUint64(&mmUpdateAgent.beforeUpdateAgentCounter, 1) - defer mm_atomic.AddUint64(&mmUpdateAgent.afterUpdateAgentCounter, 1) +// UpdateConversation implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateConversation *AppPublicServiceServerMock) UpdateConversation(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) (up2 *mm_appv1alpha.UpdateConversationResponse, err error) { + mm_atomic.AddUint64(&mmUpdateConversation.beforeUpdateConversationCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateConversation.afterUpdateConversationCounter, 1) - mmUpdateAgent.t.Helper() + mmUpdateConversation.t.Helper() - if mmUpdateAgent.inspectFuncUpdateAgent != nil { - mmUpdateAgent.inspectFuncUpdateAgent(ctx, up1) + if mmUpdateConversation.inspectFuncUpdateConversation != nil { + mmUpdateConversation.inspectFuncUpdateConversation(ctx, up1) } - mm_params := AppPublicServiceServerMockUpdateAgentParams{ctx, up1} + mm_params := AppPublicServiceServerMockUpdateConversationParams{ctx, up1} // Record call args - mmUpdateAgent.UpdateAgentMock.mutex.Lock() - mmUpdateAgent.UpdateAgentMock.callArgs = append(mmUpdateAgent.UpdateAgentMock.callArgs, &mm_params) - mmUpdateAgent.UpdateAgentMock.mutex.Unlock() + mmUpdateConversation.UpdateConversationMock.mutex.Lock() + mmUpdateConversation.UpdateConversationMock.callArgs = append(mmUpdateConversation.UpdateConversationMock.callArgs, &mm_params) + mmUpdateConversation.UpdateConversationMock.mutex.Unlock() - for _, e := range mmUpdateAgent.UpdateAgentMock.expectations { + for _, e := range mmUpdateConversation.UpdateConversationMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.up2, e.results.err } } - if mmUpdateAgent.UpdateAgentMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmUpdateAgent.UpdateAgentMock.defaultExpectation.Counter, 1) - mm_want := mmUpdateAgent.UpdateAgentMock.defaultExpectation.params - mm_want_ptrs := mmUpdateAgent.UpdateAgentMock.defaultExpectation.paramPtrs + if mmUpdateConversation.UpdateConversationMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateConversation.UpdateConversationMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateConversation.UpdateConversationMock.defaultExpectation.params + mm_want_ptrs := mmUpdateConversation.UpdateConversationMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockUpdateAgentParams{ctx, up1} + mm_got := AppPublicServiceServerMockUpdateConversationParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateAgent.t.Errorf("AppPublicServiceServerMock.UpdateAgent got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateAgent.UpdateAgentMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateConversation.t.Errorf("AppPublicServiceServerMock.UpdateConversation got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateConversation.UpdateConversationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { - mmUpdateAgent.t.Errorf("AppPublicServiceServerMock.UpdateAgent got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateAgent.UpdateAgentMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + mmUpdateConversation.t.Errorf("AppPublicServiceServerMock.UpdateConversation got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateConversation.UpdateConversationMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateAgent.t.Errorf("AppPublicServiceServerMock.UpdateAgent got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateAgent.UpdateAgentMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateConversation.t.Errorf("AppPublicServiceServerMock.UpdateConversation got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateConversation.UpdateConversationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmUpdateAgent.UpdateAgentMock.defaultExpectation.results + mm_results := mmUpdateConversation.UpdateConversationMock.defaultExpectation.results if mm_results == nil { - mmUpdateAgent.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateAgent") + mmUpdateConversation.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateConversation") } return (*mm_results).up2, (*mm_results).err } - if mmUpdateAgent.funcUpdateAgent != nil { - return mmUpdateAgent.funcUpdateAgent(ctx, up1) + if mmUpdateConversation.funcUpdateConversation != nil { + return mmUpdateConversation.funcUpdateConversation(ctx, up1) } - mmUpdateAgent.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateAgent. %v %v", ctx, up1) + mmUpdateConversation.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateConversation. %v %v", ctx, up1) return } -// UpdateAgentAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateAgent invocations -func (mmUpdateAgent *AppPublicServiceServerMock) UpdateAgentAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateAgent.afterUpdateAgentCounter) +// UpdateConversationAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateConversation invocations +func (mmUpdateConversation *AppPublicServiceServerMock) UpdateConversationAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateConversation.afterUpdateConversationCounter) } -// UpdateAgentBeforeCounter returns a count of AppPublicServiceServerMock.UpdateAgent invocations -func (mmUpdateAgent *AppPublicServiceServerMock) UpdateAgentBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateAgent.beforeUpdateAgentCounter) +// UpdateConversationBeforeCounter returns a count of AppPublicServiceServerMock.UpdateConversation invocations +func (mmUpdateConversation *AppPublicServiceServerMock) UpdateConversationBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateConversation.beforeUpdateConversationCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateAgent. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateConversation. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmUpdateAgent *mAppPublicServiceServerMockUpdateAgent) Calls() []*AppPublicServiceServerMockUpdateAgentParams { - mmUpdateAgent.mutex.RLock() +func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Calls() []*AppPublicServiceServerMockUpdateConversationParams { + mmUpdateConversation.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockUpdateAgentParams, len(mmUpdateAgent.callArgs)) - copy(argCopy, mmUpdateAgent.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateConversationParams, len(mmUpdateConversation.callArgs)) + copy(argCopy, mmUpdateConversation.callArgs) - mmUpdateAgent.mutex.RUnlock() + mmUpdateConversation.mutex.RUnlock() return argCopy } -// MinimockUpdateAgentDone returns true if the count of the UpdateAgent invocations corresponds +// MinimockUpdateConversationDone returns true if the count of the UpdateConversation invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockUpdateAgentDone() bool { - if m.UpdateAgentMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateConversationDone() bool { + if m.UpdateConversationMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.UpdateAgentMock.expectations { + for _, e := range m.UpdateConversationMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.UpdateAgentMock.invocationsDone() + return m.UpdateConversationMock.invocationsDone() } -// MinimockUpdateAgentInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockUpdateAgentInspect() { - for _, e := range m.UpdateAgentMock.expectations { +// MinimockUpdateConversationInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateConversationInspect() { + for _, e := range m.UpdateConversationMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterUpdateAgentCounter := mm_atomic.LoadUint64(&m.afterUpdateAgentCounter) + afterUpdateConversationCounter := mm_atomic.LoadUint64(&m.afterUpdateConversationCounter) // if default expectation was set then invocations count should be greater than zero - if m.UpdateAgentMock.defaultExpectation != nil && afterUpdateAgentCounter < 1 { - if m.UpdateAgentMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s", m.UpdateAgentMock.defaultExpectation.returnOrigin) + if m.UpdateConversationMock.defaultExpectation != nil && afterUpdateConversationCounter < 1 { + if m.UpdateConversationMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s", m.UpdateConversationMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s with params: %#v", m.UpdateAgentMock.defaultExpectation.expectationOrigins.origin, *m.UpdateAgentMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s with params: %#v", m.UpdateConversationMock.defaultExpectation.expectationOrigins.origin, *m.UpdateConversationMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcUpdateAgent != nil && afterUpdateAgentCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateAgent at\n%s", m.funcUpdateAgentOrigin) + if m.funcUpdateConversation != nil && afterUpdateConversationCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s", m.funcUpdateConversationOrigin) } - if !m.UpdateAgentMock.invocationsDone() && afterUpdateAgentCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateAgent at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.UpdateAgentMock.expectedInvocations), m.UpdateAgentMock.expectedInvocationsOrigin, afterUpdateAgentCounter) + if !m.UpdateConversationMock.invocationsDone() && afterUpdateConversationCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateConversation at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateConversationMock.expectedInvocations), m.UpdateConversationMock.expectedInvocationsOrigin, afterUpdateConversationCounter) } } -type mAppPublicServiceServerMockUpdateApp struct { +type mAppPublicServiceServerMockUpdateMessage struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockUpdateAppExpectation - expectations []*AppPublicServiceServerMockUpdateAppExpectation + defaultExpectation *AppPublicServiceServerMockUpdateMessageExpectation + expectations []*AppPublicServiceServerMockUpdateMessageExpectation - callArgs []*AppPublicServiceServerMockUpdateAppParams + callArgs []*AppPublicServiceServerMockUpdateMessageParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockUpdateAppExpectation specifies expectation struct of the AppPublicServiceServer.UpdateApp -type AppPublicServiceServerMockUpdateAppExpectation struct { +// AppPublicServiceServerMockUpdateMessageExpectation specifies expectation struct of the AppPublicServiceServer.UpdateMessage +type AppPublicServiceServerMockUpdateMessageExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockUpdateAppParams - paramPtrs *AppPublicServiceServerMockUpdateAppParamPtrs - expectationOrigins AppPublicServiceServerMockUpdateAppExpectationOrigins - results *AppPublicServiceServerMockUpdateAppResults + params *AppPublicServiceServerMockUpdateMessageParams + paramPtrs *AppPublicServiceServerMockUpdateMessageParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateMessageExpectationOrigins + results *AppPublicServiceServerMockUpdateMessageResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockUpdateAppParams contains parameters of the AppPublicServiceServer.UpdateApp -type AppPublicServiceServerMockUpdateAppParams struct { +// AppPublicServiceServerMockUpdateMessageParams contains parameters of the AppPublicServiceServer.UpdateMessage +type AppPublicServiceServerMockUpdateMessageParams struct { ctx context.Context - up1 *mm_appv1alpha.UpdateAppRequest + up1 *mm_appv1alpha.UpdateMessageRequest } -// AppPublicServiceServerMockUpdateAppParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateApp -type AppPublicServiceServerMockUpdateAppParamPtrs struct { +// AppPublicServiceServerMockUpdateMessageParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateMessage +type AppPublicServiceServerMockUpdateMessageParamPtrs struct { ctx *context.Context - up1 **mm_appv1alpha.UpdateAppRequest + up1 **mm_appv1alpha.UpdateMessageRequest } -// AppPublicServiceServerMockUpdateAppResults contains results of the AppPublicServiceServer.UpdateApp -type AppPublicServiceServerMockUpdateAppResults struct { - up2 *mm_appv1alpha.UpdateAppResponse +// AppPublicServiceServerMockUpdateMessageResults contains results of the AppPublicServiceServer.UpdateMessage +type AppPublicServiceServerMockUpdateMessageResults struct { + up2 *mm_appv1alpha.UpdateMessageResponse err error } -// AppPublicServiceServerMockUpdateAppOrigins contains origins of expectations of the AppPublicServiceServer.UpdateApp -type AppPublicServiceServerMockUpdateAppExpectationOrigins struct { +// AppPublicServiceServerMockUpdateMessageOrigins contains origins of expectations of the AppPublicServiceServer.UpdateMessage +type AppPublicServiceServerMockUpdateMessageExpectationOrigins struct { origin string originCtx string originUp1 string @@ -8244,339 +13891,339 @@ type AppPublicServiceServerMockUpdateAppExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Optional() *mAppPublicServiceServerMockUpdateApp { - mmUpdateApp.optional = true - return mmUpdateApp +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Optional() *mAppPublicServiceServerMockUpdateMessage { + mmUpdateMessage.optional = true + return mmUpdateMessage } -// Expect sets up expected params for AppPublicServiceServer.UpdateApp -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) *mAppPublicServiceServerMockUpdateApp { - if mmUpdateApp.mock.funcUpdateApp != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.UpdateMessage +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) *mAppPublicServiceServerMockUpdateMessage { + if mmUpdateMessage.mock.funcUpdateMessage != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") } - if mmUpdateApp.defaultExpectation == nil { - mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{} + if mmUpdateMessage.defaultExpectation == nil { + mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{} } - if mmUpdateApp.defaultExpectation.paramPtrs != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by ExpectParams functions") + if mmUpdateMessage.defaultExpectation.paramPtrs != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by ExpectParams functions") } - mmUpdateApp.defaultExpectation.params = &AppPublicServiceServerMockUpdateAppParams{ctx, up1} - mmUpdateApp.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmUpdateApp.expectations { - if minimock.Equal(e.params, mmUpdateApp.defaultExpectation.params) { - mmUpdateApp.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateApp.defaultExpectation.params) + mmUpdateMessage.defaultExpectation.params = &AppPublicServiceServerMockUpdateMessageParams{ctx, up1} + mmUpdateMessage.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateMessage.expectations { + if minimock.Equal(e.params, mmUpdateMessage.defaultExpectation.params) { + mmUpdateMessage.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateMessage.defaultExpectation.params) } } - return mmUpdateApp + return mmUpdateMessage } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateApp -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateApp { - if mmUpdateApp.mock.funcUpdateApp != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateMessage +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateMessage { + if mmUpdateMessage.mock.funcUpdateMessage != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") } - if mmUpdateApp.defaultExpectation == nil { - mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{} + if mmUpdateMessage.defaultExpectation == nil { + mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{} } - if mmUpdateApp.defaultExpectation.params != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Expect") + if mmUpdateMessage.defaultExpectation.params != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Expect") } - if mmUpdateApp.defaultExpectation.paramPtrs == nil { - mmUpdateApp.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAppParamPtrs{} - } - mmUpdateApp.defaultExpectation.paramPtrs.ctx = &ctx - mmUpdateApp.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + if mmUpdateMessage.defaultExpectation.paramPtrs == nil { + mmUpdateMessage.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateMessageParamPtrs{} + } + mmUpdateMessage.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateMessage.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmUpdateApp + return mmUpdateMessage } -// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateApp -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateAppRequest) *mAppPublicServiceServerMockUpdateApp { - if mmUpdateApp.mock.funcUpdateApp != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateMessage +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateMessageRequest) *mAppPublicServiceServerMockUpdateMessage { + if mmUpdateMessage.mock.funcUpdateMessage != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") } - if mmUpdateApp.defaultExpectation == nil { - mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{} + if mmUpdateMessage.defaultExpectation == nil { + mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{} } - if mmUpdateApp.defaultExpectation.params != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Expect") + if mmUpdateMessage.defaultExpectation.params != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Expect") } - if mmUpdateApp.defaultExpectation.paramPtrs == nil { - mmUpdateApp.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateAppParamPtrs{} + if mmUpdateMessage.defaultExpectation.paramPtrs == nil { + mmUpdateMessage.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateMessageParamPtrs{} } - mmUpdateApp.defaultExpectation.paramPtrs.up1 = &up1 - mmUpdateApp.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + mmUpdateMessage.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateMessage.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) - return mmUpdateApp + return mmUpdateMessage } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateApp -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest)) *mAppPublicServiceServerMockUpdateApp { - if mmUpdateApp.mock.inspectFuncUpdateApp != nil { - mmUpdateApp.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateApp") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateMessage +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest)) *mAppPublicServiceServerMockUpdateMessage { + if mmUpdateMessage.mock.inspectFuncUpdateMessage != nil { + mmUpdateMessage.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateMessage") } - mmUpdateApp.mock.inspectFuncUpdateApp = f + mmUpdateMessage.mock.inspectFuncUpdateMessage = f - return mmUpdateApp + return mmUpdateMessage } -// Return sets up results that will be returned by AppPublicServiceServer.UpdateApp -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Return(up2 *mm_appv1alpha.UpdateAppResponse, err error) *AppPublicServiceServerMock { - if mmUpdateApp.mock.funcUpdateApp != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.UpdateMessage +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Return(up2 *mm_appv1alpha.UpdateMessageResponse, err error) *AppPublicServiceServerMock { + if mmUpdateMessage.mock.funcUpdateMessage != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") } - if mmUpdateApp.defaultExpectation == nil { - mmUpdateApp.defaultExpectation = &AppPublicServiceServerMockUpdateAppExpectation{mock: mmUpdateApp.mock} + if mmUpdateMessage.defaultExpectation == nil { + mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{mock: mmUpdateMessage.mock} } - mmUpdateApp.defaultExpectation.results = &AppPublicServiceServerMockUpdateAppResults{up2, err} - mmUpdateApp.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmUpdateApp.mock + mmUpdateMessage.defaultExpectation.results = &AppPublicServiceServerMockUpdateMessageResults{up2, err} + mmUpdateMessage.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateMessage.mock } -// Set uses given function f to mock the AppPublicServiceServer.UpdateApp method -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) (up2 *mm_appv1alpha.UpdateAppResponse, err error)) *AppPublicServiceServerMock { - if mmUpdateApp.defaultExpectation != nil { - mmUpdateApp.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateApp method") +// Set uses given function f to mock the AppPublicServiceServer.UpdateMessage method +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) (up2 *mm_appv1alpha.UpdateMessageResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateMessage.defaultExpectation != nil { + mmUpdateMessage.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateMessage method") } - if len(mmUpdateApp.expectations) > 0 { - mmUpdateApp.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateApp method") + if len(mmUpdateMessage.expectations) > 0 { + mmUpdateMessage.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateMessage method") } - mmUpdateApp.mock.funcUpdateApp = f - mmUpdateApp.mock.funcUpdateAppOrigin = minimock.CallerInfo(1) - return mmUpdateApp.mock + mmUpdateMessage.mock.funcUpdateMessage = f + mmUpdateMessage.mock.funcUpdateMessageOrigin = minimock.CallerInfo(1) + return mmUpdateMessage.mock } -// When sets expectation for the AppPublicServiceServer.UpdateApp which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.UpdateMessage which will trigger the result defined by the following // Then helper -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) When(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) *AppPublicServiceServerMockUpdateAppExpectation { - if mmUpdateApp.mock.funcUpdateApp != nil { - mmUpdateApp.mock.t.Fatalf("AppPublicServiceServerMock.UpdateApp mock is already set by Set") +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) When(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) *AppPublicServiceServerMockUpdateMessageExpectation { + if mmUpdateMessage.mock.funcUpdateMessage != nil { + mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") } - expectation := &AppPublicServiceServerMockUpdateAppExpectation{ - mock: mmUpdateApp.mock, - params: &AppPublicServiceServerMockUpdateAppParams{ctx, up1}, - expectationOrigins: AppPublicServiceServerMockUpdateAppExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateMessageExpectation{ + mock: mmUpdateMessage.mock, + params: &AppPublicServiceServerMockUpdateMessageParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateMessageExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmUpdateApp.expectations = append(mmUpdateApp.expectations, expectation) + mmUpdateMessage.expectations = append(mmUpdateMessage.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.UpdateApp return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockUpdateAppExpectation) Then(up2 *mm_appv1alpha.UpdateAppResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockUpdateAppResults{up2, err} +// Then sets up AppPublicServiceServer.UpdateMessage return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateMessageExpectation) Then(up2 *mm_appv1alpha.UpdateMessageResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateMessageResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.UpdateApp should be invoked -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Times(n uint64) *mAppPublicServiceServerMockUpdateApp { +// Times sets number of times AppPublicServiceServer.UpdateMessage should be invoked +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Times(n uint64) *mAppPublicServiceServerMockUpdateMessage { if n == 0 { - mmUpdateApp.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateApp mock can not be zero") + mmUpdateMessage.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateMessage mock can not be zero") } - mm_atomic.StoreUint64(&mmUpdateApp.expectedInvocations, n) - mmUpdateApp.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmUpdateApp + mm_atomic.StoreUint64(&mmUpdateMessage.expectedInvocations, n) + mmUpdateMessage.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateMessage } -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) invocationsDone() bool { - if len(mmUpdateApp.expectations) == 0 && mmUpdateApp.defaultExpectation == nil && mmUpdateApp.mock.funcUpdateApp == nil { +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) invocationsDone() bool { + if len(mmUpdateMessage.expectations) == 0 && mmUpdateMessage.defaultExpectation == nil && mmUpdateMessage.mock.funcUpdateMessage == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmUpdateApp.mock.afterUpdateAppCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmUpdateApp.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateMessage.mock.afterUpdateMessageCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateMessage.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// UpdateApp implements mm_appv1alpha.AppPublicServiceServer -func (mmUpdateApp *AppPublicServiceServerMock) UpdateApp(ctx context.Context, up1 *mm_appv1alpha.UpdateAppRequest) (up2 *mm_appv1alpha.UpdateAppResponse, err error) { - mm_atomic.AddUint64(&mmUpdateApp.beforeUpdateAppCounter, 1) - defer mm_atomic.AddUint64(&mmUpdateApp.afterUpdateAppCounter, 1) +// UpdateMessage implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateMessage *AppPublicServiceServerMock) UpdateMessage(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) (up2 *mm_appv1alpha.UpdateMessageResponse, err error) { + mm_atomic.AddUint64(&mmUpdateMessage.beforeUpdateMessageCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateMessage.afterUpdateMessageCounter, 1) - mmUpdateApp.t.Helper() + mmUpdateMessage.t.Helper() - if mmUpdateApp.inspectFuncUpdateApp != nil { - mmUpdateApp.inspectFuncUpdateApp(ctx, up1) + if mmUpdateMessage.inspectFuncUpdateMessage != nil { + mmUpdateMessage.inspectFuncUpdateMessage(ctx, up1) } - mm_params := AppPublicServiceServerMockUpdateAppParams{ctx, up1} + mm_params := AppPublicServiceServerMockUpdateMessageParams{ctx, up1} // Record call args - mmUpdateApp.UpdateAppMock.mutex.Lock() - mmUpdateApp.UpdateAppMock.callArgs = append(mmUpdateApp.UpdateAppMock.callArgs, &mm_params) - mmUpdateApp.UpdateAppMock.mutex.Unlock() + mmUpdateMessage.UpdateMessageMock.mutex.Lock() + mmUpdateMessage.UpdateMessageMock.callArgs = append(mmUpdateMessage.UpdateMessageMock.callArgs, &mm_params) + mmUpdateMessage.UpdateMessageMock.mutex.Unlock() - for _, e := range mmUpdateApp.UpdateAppMock.expectations { + for _, e := range mmUpdateMessage.UpdateMessageMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.up2, e.results.err } } - if mmUpdateApp.UpdateAppMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmUpdateApp.UpdateAppMock.defaultExpectation.Counter, 1) - mm_want := mmUpdateApp.UpdateAppMock.defaultExpectation.params - mm_want_ptrs := mmUpdateApp.UpdateAppMock.defaultExpectation.paramPtrs + if mmUpdateMessage.UpdateMessageMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateMessage.UpdateMessageMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateMessage.UpdateMessageMock.defaultExpectation.params + mm_want_ptrs := mmUpdateMessage.UpdateMessageMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockUpdateAppParams{ctx, up1} + mm_got := AppPublicServiceServerMockUpdateMessageParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateApp.t.Errorf("AppPublicServiceServerMock.UpdateApp got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateApp.UpdateAppMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateMessage.t.Errorf("AppPublicServiceServerMock.UpdateMessage got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateMessage.UpdateMessageMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { - mmUpdateApp.t.Errorf("AppPublicServiceServerMock.UpdateApp got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateApp.UpdateAppMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + mmUpdateMessage.t.Errorf("AppPublicServiceServerMock.UpdateMessage got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateMessage.UpdateMessageMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateApp.t.Errorf("AppPublicServiceServerMock.UpdateApp got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateApp.UpdateAppMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateMessage.t.Errorf("AppPublicServiceServerMock.UpdateMessage got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateMessage.UpdateMessageMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmUpdateApp.UpdateAppMock.defaultExpectation.results + mm_results := mmUpdateMessage.UpdateMessageMock.defaultExpectation.results if mm_results == nil { - mmUpdateApp.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateApp") + mmUpdateMessage.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateMessage") } return (*mm_results).up2, (*mm_results).err } - if mmUpdateApp.funcUpdateApp != nil { - return mmUpdateApp.funcUpdateApp(ctx, up1) + if mmUpdateMessage.funcUpdateMessage != nil { + return mmUpdateMessage.funcUpdateMessage(ctx, up1) } - mmUpdateApp.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateApp. %v %v", ctx, up1) + mmUpdateMessage.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateMessage. %v %v", ctx, up1) return } -// UpdateAppAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateApp invocations -func (mmUpdateApp *AppPublicServiceServerMock) UpdateAppAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateApp.afterUpdateAppCounter) +// UpdateMessageAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateMessage invocations +func (mmUpdateMessage *AppPublicServiceServerMock) UpdateMessageAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateMessage.afterUpdateMessageCounter) } -// UpdateAppBeforeCounter returns a count of AppPublicServiceServerMock.UpdateApp invocations -func (mmUpdateApp *AppPublicServiceServerMock) UpdateAppBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateApp.beforeUpdateAppCounter) +// UpdateMessageBeforeCounter returns a count of AppPublicServiceServerMock.UpdateMessage invocations +func (mmUpdateMessage *AppPublicServiceServerMock) UpdateMessageBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateMessage.beforeUpdateMessageCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateApp. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateMessage. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmUpdateApp *mAppPublicServiceServerMockUpdateApp) Calls() []*AppPublicServiceServerMockUpdateAppParams { - mmUpdateApp.mutex.RLock() +func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Calls() []*AppPublicServiceServerMockUpdateMessageParams { + mmUpdateMessage.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockUpdateAppParams, len(mmUpdateApp.callArgs)) - copy(argCopy, mmUpdateApp.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateMessageParams, len(mmUpdateMessage.callArgs)) + copy(argCopy, mmUpdateMessage.callArgs) - mmUpdateApp.mutex.RUnlock() + mmUpdateMessage.mutex.RUnlock() return argCopy } -// MinimockUpdateAppDone returns true if the count of the UpdateApp invocations corresponds +// MinimockUpdateMessageDone returns true if the count of the UpdateMessage invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockUpdateAppDone() bool { - if m.UpdateAppMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateMessageDone() bool { + if m.UpdateMessageMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.UpdateAppMock.expectations { + for _, e := range m.UpdateMessageMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.UpdateAppMock.invocationsDone() + return m.UpdateMessageMock.invocationsDone() } -// MinimockUpdateAppInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockUpdateAppInspect() { - for _, e := range m.UpdateAppMock.expectations { +// MinimockUpdateMessageInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateMessageInspect() { + for _, e := range m.UpdateMessageMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterUpdateAppCounter := mm_atomic.LoadUint64(&m.afterUpdateAppCounter) + afterUpdateMessageCounter := mm_atomic.LoadUint64(&m.afterUpdateMessageCounter) // if default expectation was set then invocations count should be greater than zero - if m.UpdateAppMock.defaultExpectation != nil && afterUpdateAppCounter < 1 { - if m.UpdateAppMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s", m.UpdateAppMock.defaultExpectation.returnOrigin) + if m.UpdateMessageMock.defaultExpectation != nil && afterUpdateMessageCounter < 1 { + if m.UpdateMessageMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s", m.UpdateMessageMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s with params: %#v", m.UpdateAppMock.defaultExpectation.expectationOrigins.origin, *m.UpdateAppMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s with params: %#v", m.UpdateMessageMock.defaultExpectation.expectationOrigins.origin, *m.UpdateMessageMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcUpdateApp != nil && afterUpdateAppCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateApp at\n%s", m.funcUpdateAppOrigin) + if m.funcUpdateMessage != nil && afterUpdateMessageCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s", m.funcUpdateMessageOrigin) } - if !m.UpdateAppMock.invocationsDone() && afterUpdateAppCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateApp at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.UpdateAppMock.expectedInvocations), m.UpdateAppMock.expectedInvocationsOrigin, afterUpdateAppCounter) + if !m.UpdateMessageMock.invocationsDone() && afterUpdateMessageCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateMessage at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateMessageMock.expectedInvocations), m.UpdateMessageMock.expectedInvocationsOrigin, afterUpdateMessageCounter) } } -type mAppPublicServiceServerMockUpdateChat struct { +type mAppPublicServiceServerMockUpdateRow struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockUpdateChatExpectation - expectations []*AppPublicServiceServerMockUpdateChatExpectation + defaultExpectation *AppPublicServiceServerMockUpdateRowExpectation + expectations []*AppPublicServiceServerMockUpdateRowExpectation - callArgs []*AppPublicServiceServerMockUpdateChatParams + callArgs []*AppPublicServiceServerMockUpdateRowParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockUpdateChatExpectation specifies expectation struct of the AppPublicServiceServer.UpdateChat -type AppPublicServiceServerMockUpdateChatExpectation struct { +// AppPublicServiceServerMockUpdateRowExpectation specifies expectation struct of the AppPublicServiceServer.UpdateRow +type AppPublicServiceServerMockUpdateRowExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockUpdateChatParams - paramPtrs *AppPublicServiceServerMockUpdateChatParamPtrs - expectationOrigins AppPublicServiceServerMockUpdateChatExpectationOrigins - results *AppPublicServiceServerMockUpdateChatResults + params *AppPublicServiceServerMockUpdateRowParams + paramPtrs *AppPublicServiceServerMockUpdateRowParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateRowExpectationOrigins + results *AppPublicServiceServerMockUpdateRowResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockUpdateChatParams contains parameters of the AppPublicServiceServer.UpdateChat -type AppPublicServiceServerMockUpdateChatParams struct { +// AppPublicServiceServerMockUpdateRowParams contains parameters of the AppPublicServiceServer.UpdateRow +type AppPublicServiceServerMockUpdateRowParams struct { ctx context.Context - up1 *mm_appv1alpha.UpdateChatRequest + up1 *mm_appv1alpha.UpdateRowRequest } -// AppPublicServiceServerMockUpdateChatParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateChat -type AppPublicServiceServerMockUpdateChatParamPtrs struct { +// AppPublicServiceServerMockUpdateRowParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateRow +type AppPublicServiceServerMockUpdateRowParamPtrs struct { ctx *context.Context - up1 **mm_appv1alpha.UpdateChatRequest + up1 **mm_appv1alpha.UpdateRowRequest } -// AppPublicServiceServerMockUpdateChatResults contains results of the AppPublicServiceServer.UpdateChat -type AppPublicServiceServerMockUpdateChatResults struct { - up2 *mm_appv1alpha.UpdateChatResponse +// AppPublicServiceServerMockUpdateRowResults contains results of the AppPublicServiceServer.UpdateRow +type AppPublicServiceServerMockUpdateRowResults struct { + up2 *mm_appv1alpha.UpdateRowResponse err error } -// AppPublicServiceServerMockUpdateChatOrigins contains origins of expectations of the AppPublicServiceServer.UpdateChat -type AppPublicServiceServerMockUpdateChatExpectationOrigins struct { +// AppPublicServiceServerMockUpdateRowOrigins contains origins of expectations of the AppPublicServiceServer.UpdateRow +type AppPublicServiceServerMockUpdateRowExpectationOrigins struct { origin string originCtx string originUp1 string @@ -8587,339 +14234,339 @@ type AppPublicServiceServerMockUpdateChatExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Optional() *mAppPublicServiceServerMockUpdateChat { - mmUpdateChat.optional = true - return mmUpdateChat +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Optional() *mAppPublicServiceServerMockUpdateRow { + mmUpdateRow.optional = true + return mmUpdateRow } -// Expect sets up expected params for AppPublicServiceServer.UpdateChat -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) *mAppPublicServiceServerMockUpdateChat { - if mmUpdateChat.mock.funcUpdateChat != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.UpdateRow +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest) *mAppPublicServiceServerMockUpdateRow { + if mmUpdateRow.mock.funcUpdateRow != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Set") } - if mmUpdateChat.defaultExpectation == nil { - mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{} + if mmUpdateRow.defaultExpectation == nil { + mmUpdateRow.defaultExpectation = &AppPublicServiceServerMockUpdateRowExpectation{} } - if mmUpdateChat.defaultExpectation.paramPtrs != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by ExpectParams functions") + if mmUpdateRow.defaultExpectation.paramPtrs != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by ExpectParams functions") } - mmUpdateChat.defaultExpectation.params = &AppPublicServiceServerMockUpdateChatParams{ctx, up1} - mmUpdateChat.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmUpdateChat.expectations { - if minimock.Equal(e.params, mmUpdateChat.defaultExpectation.params) { - mmUpdateChat.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateChat.defaultExpectation.params) + mmUpdateRow.defaultExpectation.params = &AppPublicServiceServerMockUpdateRowParams{ctx, up1} + mmUpdateRow.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateRow.expectations { + if minimock.Equal(e.params, mmUpdateRow.defaultExpectation.params) { + mmUpdateRow.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateRow.defaultExpectation.params) } } - return mmUpdateChat + return mmUpdateRow } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateChat -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateChat { - if mmUpdateChat.mock.funcUpdateChat != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateRow +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateRow { + if mmUpdateRow.mock.funcUpdateRow != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Set") } - if mmUpdateChat.defaultExpectation == nil { - mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{} + if mmUpdateRow.defaultExpectation == nil { + mmUpdateRow.defaultExpectation = &AppPublicServiceServerMockUpdateRowExpectation{} } - if mmUpdateChat.defaultExpectation.params != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Expect") + if mmUpdateRow.defaultExpectation.params != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Expect") } - if mmUpdateChat.defaultExpectation.paramPtrs == nil { - mmUpdateChat.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateChatParamPtrs{} + if mmUpdateRow.defaultExpectation.paramPtrs == nil { + mmUpdateRow.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateRowParamPtrs{} } - mmUpdateChat.defaultExpectation.paramPtrs.ctx = &ctx - mmUpdateChat.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmUpdateRow.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateRow.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmUpdateChat + return mmUpdateRow } -// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateChat -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateChatRequest) *mAppPublicServiceServerMockUpdateChat { - if mmUpdateChat.mock.funcUpdateChat != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateRow +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateRowRequest) *mAppPublicServiceServerMockUpdateRow { + if mmUpdateRow.mock.funcUpdateRow != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Set") } - if mmUpdateChat.defaultExpectation == nil { - mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{} + if mmUpdateRow.defaultExpectation == nil { + mmUpdateRow.defaultExpectation = &AppPublicServiceServerMockUpdateRowExpectation{} } - if mmUpdateChat.defaultExpectation.params != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Expect") + if mmUpdateRow.defaultExpectation.params != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Expect") } - if mmUpdateChat.defaultExpectation.paramPtrs == nil { - mmUpdateChat.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateChatParamPtrs{} + if mmUpdateRow.defaultExpectation.paramPtrs == nil { + mmUpdateRow.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateRowParamPtrs{} } - mmUpdateChat.defaultExpectation.paramPtrs.up1 = &up1 - mmUpdateChat.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + mmUpdateRow.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateRow.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) - return mmUpdateChat + return mmUpdateRow } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateChat -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest)) *mAppPublicServiceServerMockUpdateChat { - if mmUpdateChat.mock.inspectFuncUpdateChat != nil { - mmUpdateChat.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateChat") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateRow +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest)) *mAppPublicServiceServerMockUpdateRow { + if mmUpdateRow.mock.inspectFuncUpdateRow != nil { + mmUpdateRow.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateRow") } - mmUpdateChat.mock.inspectFuncUpdateChat = f + mmUpdateRow.mock.inspectFuncUpdateRow = f - return mmUpdateChat + return mmUpdateRow } -// Return sets up results that will be returned by AppPublicServiceServer.UpdateChat -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Return(up2 *mm_appv1alpha.UpdateChatResponse, err error) *AppPublicServiceServerMock { - if mmUpdateChat.mock.funcUpdateChat != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.UpdateRow +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Return(up2 *mm_appv1alpha.UpdateRowResponse, err error) *AppPublicServiceServerMock { + if mmUpdateRow.mock.funcUpdateRow != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Set") } - if mmUpdateChat.defaultExpectation == nil { - mmUpdateChat.defaultExpectation = &AppPublicServiceServerMockUpdateChatExpectation{mock: mmUpdateChat.mock} + if mmUpdateRow.defaultExpectation == nil { + mmUpdateRow.defaultExpectation = &AppPublicServiceServerMockUpdateRowExpectation{mock: mmUpdateRow.mock} } - mmUpdateChat.defaultExpectation.results = &AppPublicServiceServerMockUpdateChatResults{up2, err} - mmUpdateChat.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmUpdateChat.mock + mmUpdateRow.defaultExpectation.results = &AppPublicServiceServerMockUpdateRowResults{up2, err} + mmUpdateRow.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateRow.mock } -// Set uses given function f to mock the AppPublicServiceServer.UpdateChat method -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) (up2 *mm_appv1alpha.UpdateChatResponse, err error)) *AppPublicServiceServerMock { - if mmUpdateChat.defaultExpectation != nil { - mmUpdateChat.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateChat method") +// Set uses given function f to mock the AppPublicServiceServer.UpdateRow method +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest) (up2 *mm_appv1alpha.UpdateRowResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateRow.defaultExpectation != nil { + mmUpdateRow.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateRow method") } - if len(mmUpdateChat.expectations) > 0 { - mmUpdateChat.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateChat method") + if len(mmUpdateRow.expectations) > 0 { + mmUpdateRow.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateRow method") } - mmUpdateChat.mock.funcUpdateChat = f - mmUpdateChat.mock.funcUpdateChatOrigin = minimock.CallerInfo(1) - return mmUpdateChat.mock + mmUpdateRow.mock.funcUpdateRow = f + mmUpdateRow.mock.funcUpdateRowOrigin = minimock.CallerInfo(1) + return mmUpdateRow.mock } -// When sets expectation for the AppPublicServiceServer.UpdateChat which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.UpdateRow which will trigger the result defined by the following // Then helper -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) When(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) *AppPublicServiceServerMockUpdateChatExpectation { - if mmUpdateChat.mock.funcUpdateChat != nil { - mmUpdateChat.mock.t.Fatalf("AppPublicServiceServerMock.UpdateChat mock is already set by Set") +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) When(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest) *AppPublicServiceServerMockUpdateRowExpectation { + if mmUpdateRow.mock.funcUpdateRow != nil { + mmUpdateRow.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRow mock is already set by Set") } - expectation := &AppPublicServiceServerMockUpdateChatExpectation{ - mock: mmUpdateChat.mock, - params: &AppPublicServiceServerMockUpdateChatParams{ctx, up1}, - expectationOrigins: AppPublicServiceServerMockUpdateChatExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateRowExpectation{ + mock: mmUpdateRow.mock, + params: &AppPublicServiceServerMockUpdateRowParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateRowExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmUpdateChat.expectations = append(mmUpdateChat.expectations, expectation) + mmUpdateRow.expectations = append(mmUpdateRow.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.UpdateChat return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockUpdateChatExpectation) Then(up2 *mm_appv1alpha.UpdateChatResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockUpdateChatResults{up2, err} +// Then sets up AppPublicServiceServer.UpdateRow return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateRowExpectation) Then(up2 *mm_appv1alpha.UpdateRowResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateRowResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.UpdateChat should be invoked -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Times(n uint64) *mAppPublicServiceServerMockUpdateChat { +// Times sets number of times AppPublicServiceServer.UpdateRow should be invoked +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Times(n uint64) *mAppPublicServiceServerMockUpdateRow { if n == 0 { - mmUpdateChat.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateChat mock can not be zero") + mmUpdateRow.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateRow mock can not be zero") } - mm_atomic.StoreUint64(&mmUpdateChat.expectedInvocations, n) - mmUpdateChat.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmUpdateChat + mm_atomic.StoreUint64(&mmUpdateRow.expectedInvocations, n) + mmUpdateRow.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateRow } -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) invocationsDone() bool { - if len(mmUpdateChat.expectations) == 0 && mmUpdateChat.defaultExpectation == nil && mmUpdateChat.mock.funcUpdateChat == nil { +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) invocationsDone() bool { + if len(mmUpdateRow.expectations) == 0 && mmUpdateRow.defaultExpectation == nil && mmUpdateRow.mock.funcUpdateRow == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmUpdateChat.mock.afterUpdateChatCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmUpdateChat.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateRow.mock.afterUpdateRowCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateRow.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// UpdateChat implements mm_appv1alpha.AppPublicServiceServer -func (mmUpdateChat *AppPublicServiceServerMock) UpdateChat(ctx context.Context, up1 *mm_appv1alpha.UpdateChatRequest) (up2 *mm_appv1alpha.UpdateChatResponse, err error) { - mm_atomic.AddUint64(&mmUpdateChat.beforeUpdateChatCounter, 1) - defer mm_atomic.AddUint64(&mmUpdateChat.afterUpdateChatCounter, 1) +// UpdateRow implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateRow *AppPublicServiceServerMock) UpdateRow(ctx context.Context, up1 *mm_appv1alpha.UpdateRowRequest) (up2 *mm_appv1alpha.UpdateRowResponse, err error) { + mm_atomic.AddUint64(&mmUpdateRow.beforeUpdateRowCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateRow.afterUpdateRowCounter, 1) - mmUpdateChat.t.Helper() + mmUpdateRow.t.Helper() - if mmUpdateChat.inspectFuncUpdateChat != nil { - mmUpdateChat.inspectFuncUpdateChat(ctx, up1) + if mmUpdateRow.inspectFuncUpdateRow != nil { + mmUpdateRow.inspectFuncUpdateRow(ctx, up1) } - mm_params := AppPublicServiceServerMockUpdateChatParams{ctx, up1} + mm_params := AppPublicServiceServerMockUpdateRowParams{ctx, up1} // Record call args - mmUpdateChat.UpdateChatMock.mutex.Lock() - mmUpdateChat.UpdateChatMock.callArgs = append(mmUpdateChat.UpdateChatMock.callArgs, &mm_params) - mmUpdateChat.UpdateChatMock.mutex.Unlock() + mmUpdateRow.UpdateRowMock.mutex.Lock() + mmUpdateRow.UpdateRowMock.callArgs = append(mmUpdateRow.UpdateRowMock.callArgs, &mm_params) + mmUpdateRow.UpdateRowMock.mutex.Unlock() - for _, e := range mmUpdateChat.UpdateChatMock.expectations { + for _, e := range mmUpdateRow.UpdateRowMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.up2, e.results.err } } - if mmUpdateChat.UpdateChatMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmUpdateChat.UpdateChatMock.defaultExpectation.Counter, 1) - mm_want := mmUpdateChat.UpdateChatMock.defaultExpectation.params - mm_want_ptrs := mmUpdateChat.UpdateChatMock.defaultExpectation.paramPtrs + if mmUpdateRow.UpdateRowMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateRow.UpdateRowMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateRow.UpdateRowMock.defaultExpectation.params + mm_want_ptrs := mmUpdateRow.UpdateRowMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockUpdateChatParams{ctx, up1} + mm_got := AppPublicServiceServerMockUpdateRowParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateChat.t.Errorf("AppPublicServiceServerMock.UpdateChat got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateChat.UpdateChatMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateRow.t.Errorf("AppPublicServiceServerMock.UpdateRow got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateRow.UpdateRowMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { - mmUpdateChat.t.Errorf("AppPublicServiceServerMock.UpdateChat got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateChat.UpdateChatMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + mmUpdateRow.t.Errorf("AppPublicServiceServerMock.UpdateRow got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateRow.UpdateRowMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateChat.t.Errorf("AppPublicServiceServerMock.UpdateChat got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateChat.UpdateChatMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateRow.t.Errorf("AppPublicServiceServerMock.UpdateRow got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateRow.UpdateRowMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmUpdateChat.UpdateChatMock.defaultExpectation.results + mm_results := mmUpdateRow.UpdateRowMock.defaultExpectation.results if mm_results == nil { - mmUpdateChat.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateChat") + mmUpdateRow.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateRow") } return (*mm_results).up2, (*mm_results).err } - if mmUpdateChat.funcUpdateChat != nil { - return mmUpdateChat.funcUpdateChat(ctx, up1) + if mmUpdateRow.funcUpdateRow != nil { + return mmUpdateRow.funcUpdateRow(ctx, up1) } - mmUpdateChat.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateChat. %v %v", ctx, up1) + mmUpdateRow.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateRow. %v %v", ctx, up1) return } -// UpdateChatAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateChat invocations -func (mmUpdateChat *AppPublicServiceServerMock) UpdateChatAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateChat.afterUpdateChatCounter) +// UpdateRowAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateRow invocations +func (mmUpdateRow *AppPublicServiceServerMock) UpdateRowAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateRow.afterUpdateRowCounter) } -// UpdateChatBeforeCounter returns a count of AppPublicServiceServerMock.UpdateChat invocations -func (mmUpdateChat *AppPublicServiceServerMock) UpdateChatBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateChat.beforeUpdateChatCounter) +// UpdateRowBeforeCounter returns a count of AppPublicServiceServerMock.UpdateRow invocations +func (mmUpdateRow *AppPublicServiceServerMock) UpdateRowBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateRow.beforeUpdateRowCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateChat. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateRow. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmUpdateChat *mAppPublicServiceServerMockUpdateChat) Calls() []*AppPublicServiceServerMockUpdateChatParams { - mmUpdateChat.mutex.RLock() +func (mmUpdateRow *mAppPublicServiceServerMockUpdateRow) Calls() []*AppPublicServiceServerMockUpdateRowParams { + mmUpdateRow.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockUpdateChatParams, len(mmUpdateChat.callArgs)) - copy(argCopy, mmUpdateChat.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateRowParams, len(mmUpdateRow.callArgs)) + copy(argCopy, mmUpdateRow.callArgs) - mmUpdateChat.mutex.RUnlock() + mmUpdateRow.mutex.RUnlock() return argCopy } -// MinimockUpdateChatDone returns true if the count of the UpdateChat invocations corresponds +// MinimockUpdateRowDone returns true if the count of the UpdateRow invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockUpdateChatDone() bool { - if m.UpdateChatMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateRowDone() bool { + if m.UpdateRowMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.UpdateChatMock.expectations { + for _, e := range m.UpdateRowMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.UpdateChatMock.invocationsDone() + return m.UpdateRowMock.invocationsDone() } -// MinimockUpdateChatInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockUpdateChatInspect() { - for _, e := range m.UpdateChatMock.expectations { +// MinimockUpdateRowInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateRowInspect() { + for _, e := range m.UpdateRowMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRow at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterUpdateChatCounter := mm_atomic.LoadUint64(&m.afterUpdateChatCounter) + afterUpdateRowCounter := mm_atomic.LoadUint64(&m.afterUpdateRowCounter) // if default expectation was set then invocations count should be greater than zero - if m.UpdateChatMock.defaultExpectation != nil && afterUpdateChatCounter < 1 { - if m.UpdateChatMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s", m.UpdateChatMock.defaultExpectation.returnOrigin) + if m.UpdateRowMock.defaultExpectation != nil && afterUpdateRowCounter < 1 { + if m.UpdateRowMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRow at\n%s", m.UpdateRowMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s with params: %#v", m.UpdateChatMock.defaultExpectation.expectationOrigins.origin, *m.UpdateChatMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRow at\n%s with params: %#v", m.UpdateRowMock.defaultExpectation.expectationOrigins.origin, *m.UpdateRowMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcUpdateChat != nil && afterUpdateChatCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateChat at\n%s", m.funcUpdateChatOrigin) + if m.funcUpdateRow != nil && afterUpdateRowCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRow at\n%s", m.funcUpdateRowOrigin) } - if !m.UpdateChatMock.invocationsDone() && afterUpdateChatCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateChat at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.UpdateChatMock.expectedInvocations), m.UpdateChatMock.expectedInvocationsOrigin, afterUpdateChatCounter) + if !m.UpdateRowMock.invocationsDone() && afterUpdateRowCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateRow at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateRowMock.expectedInvocations), m.UpdateRowMock.expectedInvocationsOrigin, afterUpdateRowCounter) } } -type mAppPublicServiceServerMockUpdateConversation struct { +type mAppPublicServiceServerMockUpdateRows struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockUpdateConversationExpectation - expectations []*AppPublicServiceServerMockUpdateConversationExpectation + defaultExpectation *AppPublicServiceServerMockUpdateRowsExpectation + expectations []*AppPublicServiceServerMockUpdateRowsExpectation - callArgs []*AppPublicServiceServerMockUpdateConversationParams + callArgs []*AppPublicServiceServerMockUpdateRowsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockUpdateConversationExpectation specifies expectation struct of the AppPublicServiceServer.UpdateConversation -type AppPublicServiceServerMockUpdateConversationExpectation struct { +// AppPublicServiceServerMockUpdateRowsExpectation specifies expectation struct of the AppPublicServiceServer.UpdateRows +type AppPublicServiceServerMockUpdateRowsExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockUpdateConversationParams - paramPtrs *AppPublicServiceServerMockUpdateConversationParamPtrs - expectationOrigins AppPublicServiceServerMockUpdateConversationExpectationOrigins - results *AppPublicServiceServerMockUpdateConversationResults + params *AppPublicServiceServerMockUpdateRowsParams + paramPtrs *AppPublicServiceServerMockUpdateRowsParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateRowsExpectationOrigins + results *AppPublicServiceServerMockUpdateRowsResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockUpdateConversationParams contains parameters of the AppPublicServiceServer.UpdateConversation -type AppPublicServiceServerMockUpdateConversationParams struct { +// AppPublicServiceServerMockUpdateRowsParams contains parameters of the AppPublicServiceServer.UpdateRows +type AppPublicServiceServerMockUpdateRowsParams struct { ctx context.Context - up1 *mm_appv1alpha.UpdateConversationRequest + up1 *mm_appv1alpha.UpdateRowsRequest } -// AppPublicServiceServerMockUpdateConversationParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateConversation -type AppPublicServiceServerMockUpdateConversationParamPtrs struct { +// AppPublicServiceServerMockUpdateRowsParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateRows +type AppPublicServiceServerMockUpdateRowsParamPtrs struct { ctx *context.Context - up1 **mm_appv1alpha.UpdateConversationRequest + up1 **mm_appv1alpha.UpdateRowsRequest } -// AppPublicServiceServerMockUpdateConversationResults contains results of the AppPublicServiceServer.UpdateConversation -type AppPublicServiceServerMockUpdateConversationResults struct { - up2 *mm_appv1alpha.UpdateConversationResponse +// AppPublicServiceServerMockUpdateRowsResults contains results of the AppPublicServiceServer.UpdateRows +type AppPublicServiceServerMockUpdateRowsResults struct { + up2 *mm_appv1alpha.UpdateRowsResponse err error } -// AppPublicServiceServerMockUpdateConversationOrigins contains origins of expectations of the AppPublicServiceServer.UpdateConversation -type AppPublicServiceServerMockUpdateConversationExpectationOrigins struct { +// AppPublicServiceServerMockUpdateRowsOrigins contains origins of expectations of the AppPublicServiceServer.UpdateRows +type AppPublicServiceServerMockUpdateRowsExpectationOrigins struct { origin string originCtx string originUp1 string @@ -8930,339 +14577,339 @@ type AppPublicServiceServerMockUpdateConversationExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Optional() *mAppPublicServiceServerMockUpdateConversation { - mmUpdateConversation.optional = true - return mmUpdateConversation +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Optional() *mAppPublicServiceServerMockUpdateRows { + mmUpdateRows.optional = true + return mmUpdateRows } -// Expect sets up expected params for AppPublicServiceServer.UpdateConversation -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) *mAppPublicServiceServerMockUpdateConversation { - if mmUpdateConversation.mock.funcUpdateConversation != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.UpdateRows +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest) *mAppPublicServiceServerMockUpdateRows { + if mmUpdateRows.mock.funcUpdateRows != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Set") } - if mmUpdateConversation.defaultExpectation == nil { - mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{} + if mmUpdateRows.defaultExpectation == nil { + mmUpdateRows.defaultExpectation = &AppPublicServiceServerMockUpdateRowsExpectation{} } - if mmUpdateConversation.defaultExpectation.paramPtrs != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by ExpectParams functions") + if mmUpdateRows.defaultExpectation.paramPtrs != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by ExpectParams functions") } - mmUpdateConversation.defaultExpectation.params = &AppPublicServiceServerMockUpdateConversationParams{ctx, up1} - mmUpdateConversation.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmUpdateConversation.expectations { - if minimock.Equal(e.params, mmUpdateConversation.defaultExpectation.params) { - mmUpdateConversation.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateConversation.defaultExpectation.params) + mmUpdateRows.defaultExpectation.params = &AppPublicServiceServerMockUpdateRowsParams{ctx, up1} + mmUpdateRows.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateRows.expectations { + if minimock.Equal(e.params, mmUpdateRows.defaultExpectation.params) { + mmUpdateRows.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateRows.defaultExpectation.params) } } - return mmUpdateConversation + return mmUpdateRows } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateConversation -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateConversation { - if mmUpdateConversation.mock.funcUpdateConversation != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateRows +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateRows { + if mmUpdateRows.mock.funcUpdateRows != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Set") } - if mmUpdateConversation.defaultExpectation == nil { - mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{} + if mmUpdateRows.defaultExpectation == nil { + mmUpdateRows.defaultExpectation = &AppPublicServiceServerMockUpdateRowsExpectation{} } - if mmUpdateConversation.defaultExpectation.params != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Expect") + if mmUpdateRows.defaultExpectation.params != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Expect") } - if mmUpdateConversation.defaultExpectation.paramPtrs == nil { - mmUpdateConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateConversationParamPtrs{} + if mmUpdateRows.defaultExpectation.paramPtrs == nil { + mmUpdateRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateRowsParamPtrs{} } - mmUpdateConversation.defaultExpectation.paramPtrs.ctx = &ctx - mmUpdateConversation.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmUpdateRows.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateRows.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmUpdateConversation + return mmUpdateRows } -// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateConversation -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateConversationRequest) *mAppPublicServiceServerMockUpdateConversation { - if mmUpdateConversation.mock.funcUpdateConversation != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateRows +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateRowsRequest) *mAppPublicServiceServerMockUpdateRows { + if mmUpdateRows.mock.funcUpdateRows != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Set") } - if mmUpdateConversation.defaultExpectation == nil { - mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{} + if mmUpdateRows.defaultExpectation == nil { + mmUpdateRows.defaultExpectation = &AppPublicServiceServerMockUpdateRowsExpectation{} } - if mmUpdateConversation.defaultExpectation.params != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Expect") + if mmUpdateRows.defaultExpectation.params != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Expect") } - if mmUpdateConversation.defaultExpectation.paramPtrs == nil { - mmUpdateConversation.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateConversationParamPtrs{} + if mmUpdateRows.defaultExpectation.paramPtrs == nil { + mmUpdateRows.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateRowsParamPtrs{} } - mmUpdateConversation.defaultExpectation.paramPtrs.up1 = &up1 - mmUpdateConversation.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + mmUpdateRows.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateRows.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) - return mmUpdateConversation + return mmUpdateRows } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateConversation -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest)) *mAppPublicServiceServerMockUpdateConversation { - if mmUpdateConversation.mock.inspectFuncUpdateConversation != nil { - mmUpdateConversation.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateConversation") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateRows +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest)) *mAppPublicServiceServerMockUpdateRows { + if mmUpdateRows.mock.inspectFuncUpdateRows != nil { + mmUpdateRows.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateRows") } - mmUpdateConversation.mock.inspectFuncUpdateConversation = f + mmUpdateRows.mock.inspectFuncUpdateRows = f - return mmUpdateConversation + return mmUpdateRows } -// Return sets up results that will be returned by AppPublicServiceServer.UpdateConversation -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Return(up2 *mm_appv1alpha.UpdateConversationResponse, err error) *AppPublicServiceServerMock { - if mmUpdateConversation.mock.funcUpdateConversation != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.UpdateRows +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Return(up2 *mm_appv1alpha.UpdateRowsResponse, err error) *AppPublicServiceServerMock { + if mmUpdateRows.mock.funcUpdateRows != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Set") } - if mmUpdateConversation.defaultExpectation == nil { - mmUpdateConversation.defaultExpectation = &AppPublicServiceServerMockUpdateConversationExpectation{mock: mmUpdateConversation.mock} + if mmUpdateRows.defaultExpectation == nil { + mmUpdateRows.defaultExpectation = &AppPublicServiceServerMockUpdateRowsExpectation{mock: mmUpdateRows.mock} } - mmUpdateConversation.defaultExpectation.results = &AppPublicServiceServerMockUpdateConversationResults{up2, err} - mmUpdateConversation.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmUpdateConversation.mock + mmUpdateRows.defaultExpectation.results = &AppPublicServiceServerMockUpdateRowsResults{up2, err} + mmUpdateRows.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateRows.mock } -// Set uses given function f to mock the AppPublicServiceServer.UpdateConversation method -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) (up2 *mm_appv1alpha.UpdateConversationResponse, err error)) *AppPublicServiceServerMock { - if mmUpdateConversation.defaultExpectation != nil { - mmUpdateConversation.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateConversation method") +// Set uses given function f to mock the AppPublicServiceServer.UpdateRows method +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest) (up2 *mm_appv1alpha.UpdateRowsResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateRows.defaultExpectation != nil { + mmUpdateRows.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateRows method") } - if len(mmUpdateConversation.expectations) > 0 { - mmUpdateConversation.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateConversation method") + if len(mmUpdateRows.expectations) > 0 { + mmUpdateRows.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateRows method") } - mmUpdateConversation.mock.funcUpdateConversation = f - mmUpdateConversation.mock.funcUpdateConversationOrigin = minimock.CallerInfo(1) - return mmUpdateConversation.mock + mmUpdateRows.mock.funcUpdateRows = f + mmUpdateRows.mock.funcUpdateRowsOrigin = minimock.CallerInfo(1) + return mmUpdateRows.mock } -// When sets expectation for the AppPublicServiceServer.UpdateConversation which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.UpdateRows which will trigger the result defined by the following // Then helper -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) When(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) *AppPublicServiceServerMockUpdateConversationExpectation { - if mmUpdateConversation.mock.funcUpdateConversation != nil { - mmUpdateConversation.mock.t.Fatalf("AppPublicServiceServerMock.UpdateConversation mock is already set by Set") +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) When(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest) *AppPublicServiceServerMockUpdateRowsExpectation { + if mmUpdateRows.mock.funcUpdateRows != nil { + mmUpdateRows.mock.t.Fatalf("AppPublicServiceServerMock.UpdateRows mock is already set by Set") } - expectation := &AppPublicServiceServerMockUpdateConversationExpectation{ - mock: mmUpdateConversation.mock, - params: &AppPublicServiceServerMockUpdateConversationParams{ctx, up1}, - expectationOrigins: AppPublicServiceServerMockUpdateConversationExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateRowsExpectation{ + mock: mmUpdateRows.mock, + params: &AppPublicServiceServerMockUpdateRowsParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateRowsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmUpdateConversation.expectations = append(mmUpdateConversation.expectations, expectation) + mmUpdateRows.expectations = append(mmUpdateRows.expectations, expectation) return expectation -} - -// Then sets up AppPublicServiceServer.UpdateConversation return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockUpdateConversationExpectation) Then(up2 *mm_appv1alpha.UpdateConversationResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockUpdateConversationResults{up2, err} +} + +// Then sets up AppPublicServiceServer.UpdateRows return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateRowsExpectation) Then(up2 *mm_appv1alpha.UpdateRowsResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateRowsResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.UpdateConversation should be invoked -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Times(n uint64) *mAppPublicServiceServerMockUpdateConversation { +// Times sets number of times AppPublicServiceServer.UpdateRows should be invoked +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Times(n uint64) *mAppPublicServiceServerMockUpdateRows { if n == 0 { - mmUpdateConversation.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateConversation mock can not be zero") + mmUpdateRows.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateRows mock can not be zero") } - mm_atomic.StoreUint64(&mmUpdateConversation.expectedInvocations, n) - mmUpdateConversation.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmUpdateConversation + mm_atomic.StoreUint64(&mmUpdateRows.expectedInvocations, n) + mmUpdateRows.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateRows } -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) invocationsDone() bool { - if len(mmUpdateConversation.expectations) == 0 && mmUpdateConversation.defaultExpectation == nil && mmUpdateConversation.mock.funcUpdateConversation == nil { +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) invocationsDone() bool { + if len(mmUpdateRows.expectations) == 0 && mmUpdateRows.defaultExpectation == nil && mmUpdateRows.mock.funcUpdateRows == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmUpdateConversation.mock.afterUpdateConversationCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmUpdateConversation.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateRows.mock.afterUpdateRowsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateRows.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// UpdateConversation implements mm_appv1alpha.AppPublicServiceServer -func (mmUpdateConversation *AppPublicServiceServerMock) UpdateConversation(ctx context.Context, up1 *mm_appv1alpha.UpdateConversationRequest) (up2 *mm_appv1alpha.UpdateConversationResponse, err error) { - mm_atomic.AddUint64(&mmUpdateConversation.beforeUpdateConversationCounter, 1) - defer mm_atomic.AddUint64(&mmUpdateConversation.afterUpdateConversationCounter, 1) +// UpdateRows implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateRows *AppPublicServiceServerMock) UpdateRows(ctx context.Context, up1 *mm_appv1alpha.UpdateRowsRequest) (up2 *mm_appv1alpha.UpdateRowsResponse, err error) { + mm_atomic.AddUint64(&mmUpdateRows.beforeUpdateRowsCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateRows.afterUpdateRowsCounter, 1) - mmUpdateConversation.t.Helper() + mmUpdateRows.t.Helper() - if mmUpdateConversation.inspectFuncUpdateConversation != nil { - mmUpdateConversation.inspectFuncUpdateConversation(ctx, up1) + if mmUpdateRows.inspectFuncUpdateRows != nil { + mmUpdateRows.inspectFuncUpdateRows(ctx, up1) } - mm_params := AppPublicServiceServerMockUpdateConversationParams{ctx, up1} + mm_params := AppPublicServiceServerMockUpdateRowsParams{ctx, up1} // Record call args - mmUpdateConversation.UpdateConversationMock.mutex.Lock() - mmUpdateConversation.UpdateConversationMock.callArgs = append(mmUpdateConversation.UpdateConversationMock.callArgs, &mm_params) - mmUpdateConversation.UpdateConversationMock.mutex.Unlock() + mmUpdateRows.UpdateRowsMock.mutex.Lock() + mmUpdateRows.UpdateRowsMock.callArgs = append(mmUpdateRows.UpdateRowsMock.callArgs, &mm_params) + mmUpdateRows.UpdateRowsMock.mutex.Unlock() - for _, e := range mmUpdateConversation.UpdateConversationMock.expectations { + for _, e := range mmUpdateRows.UpdateRowsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.up2, e.results.err } } - if mmUpdateConversation.UpdateConversationMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmUpdateConversation.UpdateConversationMock.defaultExpectation.Counter, 1) - mm_want := mmUpdateConversation.UpdateConversationMock.defaultExpectation.params - mm_want_ptrs := mmUpdateConversation.UpdateConversationMock.defaultExpectation.paramPtrs + if mmUpdateRows.UpdateRowsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateRows.UpdateRowsMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateRows.UpdateRowsMock.defaultExpectation.params + mm_want_ptrs := mmUpdateRows.UpdateRowsMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockUpdateConversationParams{ctx, up1} + mm_got := AppPublicServiceServerMockUpdateRowsParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateConversation.t.Errorf("AppPublicServiceServerMock.UpdateConversation got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateConversation.UpdateConversationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateRows.t.Errorf("AppPublicServiceServerMock.UpdateRows got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateRows.UpdateRowsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { - mmUpdateConversation.t.Errorf("AppPublicServiceServerMock.UpdateConversation got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateConversation.UpdateConversationMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + mmUpdateRows.t.Errorf("AppPublicServiceServerMock.UpdateRows got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateRows.UpdateRowsMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateConversation.t.Errorf("AppPublicServiceServerMock.UpdateConversation got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateConversation.UpdateConversationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateRows.t.Errorf("AppPublicServiceServerMock.UpdateRows got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateRows.UpdateRowsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmUpdateConversation.UpdateConversationMock.defaultExpectation.results + mm_results := mmUpdateRows.UpdateRowsMock.defaultExpectation.results if mm_results == nil { - mmUpdateConversation.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateConversation") + mmUpdateRows.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateRows") } return (*mm_results).up2, (*mm_results).err } - if mmUpdateConversation.funcUpdateConversation != nil { - return mmUpdateConversation.funcUpdateConversation(ctx, up1) + if mmUpdateRows.funcUpdateRows != nil { + return mmUpdateRows.funcUpdateRows(ctx, up1) } - mmUpdateConversation.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateConversation. %v %v", ctx, up1) + mmUpdateRows.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateRows. %v %v", ctx, up1) return } -// UpdateConversationAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateConversation invocations -func (mmUpdateConversation *AppPublicServiceServerMock) UpdateConversationAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateConversation.afterUpdateConversationCounter) +// UpdateRowsAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateRows invocations +func (mmUpdateRows *AppPublicServiceServerMock) UpdateRowsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateRows.afterUpdateRowsCounter) } -// UpdateConversationBeforeCounter returns a count of AppPublicServiceServerMock.UpdateConversation invocations -func (mmUpdateConversation *AppPublicServiceServerMock) UpdateConversationBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateConversation.beforeUpdateConversationCounter) +// UpdateRowsBeforeCounter returns a count of AppPublicServiceServerMock.UpdateRows invocations +func (mmUpdateRows *AppPublicServiceServerMock) UpdateRowsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateRows.beforeUpdateRowsCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateConversation. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateRows. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmUpdateConversation *mAppPublicServiceServerMockUpdateConversation) Calls() []*AppPublicServiceServerMockUpdateConversationParams { - mmUpdateConversation.mutex.RLock() +func (mmUpdateRows *mAppPublicServiceServerMockUpdateRows) Calls() []*AppPublicServiceServerMockUpdateRowsParams { + mmUpdateRows.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockUpdateConversationParams, len(mmUpdateConversation.callArgs)) - copy(argCopy, mmUpdateConversation.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateRowsParams, len(mmUpdateRows.callArgs)) + copy(argCopy, mmUpdateRows.callArgs) - mmUpdateConversation.mutex.RUnlock() + mmUpdateRows.mutex.RUnlock() return argCopy } -// MinimockUpdateConversationDone returns true if the count of the UpdateConversation invocations corresponds +// MinimockUpdateRowsDone returns true if the count of the UpdateRows invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockUpdateConversationDone() bool { - if m.UpdateConversationMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateRowsDone() bool { + if m.UpdateRowsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.UpdateConversationMock.expectations { + for _, e := range m.UpdateRowsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.UpdateConversationMock.invocationsDone() + return m.UpdateRowsMock.invocationsDone() } -// MinimockUpdateConversationInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockUpdateConversationInspect() { - for _, e := range m.UpdateConversationMock.expectations { +// MinimockUpdateRowsInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateRowsInspect() { + for _, e := range m.UpdateRowsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRows at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterUpdateConversationCounter := mm_atomic.LoadUint64(&m.afterUpdateConversationCounter) + afterUpdateRowsCounter := mm_atomic.LoadUint64(&m.afterUpdateRowsCounter) // if default expectation was set then invocations count should be greater than zero - if m.UpdateConversationMock.defaultExpectation != nil && afterUpdateConversationCounter < 1 { - if m.UpdateConversationMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s", m.UpdateConversationMock.defaultExpectation.returnOrigin) + if m.UpdateRowsMock.defaultExpectation != nil && afterUpdateRowsCounter < 1 { + if m.UpdateRowsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRows at\n%s", m.UpdateRowsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s with params: %#v", m.UpdateConversationMock.defaultExpectation.expectationOrigins.origin, *m.UpdateConversationMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRows at\n%s with params: %#v", m.UpdateRowsMock.defaultExpectation.expectationOrigins.origin, *m.UpdateRowsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcUpdateConversation != nil && afterUpdateConversationCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateConversation at\n%s", m.funcUpdateConversationOrigin) + if m.funcUpdateRows != nil && afterUpdateRowsCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateRows at\n%s", m.funcUpdateRowsOrigin) } - if !m.UpdateConversationMock.invocationsDone() && afterUpdateConversationCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateConversation at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.UpdateConversationMock.expectedInvocations), m.UpdateConversationMock.expectedInvocationsOrigin, afterUpdateConversationCounter) + if !m.UpdateRowsMock.invocationsDone() && afterUpdateRowsCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateRows at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateRowsMock.expectedInvocations), m.UpdateRowsMock.expectedInvocationsOrigin, afterUpdateRowsCounter) } } -type mAppPublicServiceServerMockUpdateMessage struct { +type mAppPublicServiceServerMockUpdateTable struct { optional bool mock *AppPublicServiceServerMock - defaultExpectation *AppPublicServiceServerMockUpdateMessageExpectation - expectations []*AppPublicServiceServerMockUpdateMessageExpectation + defaultExpectation *AppPublicServiceServerMockUpdateTableExpectation + expectations []*AppPublicServiceServerMockUpdateTableExpectation - callArgs []*AppPublicServiceServerMockUpdateMessageParams + callArgs []*AppPublicServiceServerMockUpdateTableParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// AppPublicServiceServerMockUpdateMessageExpectation specifies expectation struct of the AppPublicServiceServer.UpdateMessage -type AppPublicServiceServerMockUpdateMessageExpectation struct { +// AppPublicServiceServerMockUpdateTableExpectation specifies expectation struct of the AppPublicServiceServer.UpdateTable +type AppPublicServiceServerMockUpdateTableExpectation struct { mock *AppPublicServiceServerMock - params *AppPublicServiceServerMockUpdateMessageParams - paramPtrs *AppPublicServiceServerMockUpdateMessageParamPtrs - expectationOrigins AppPublicServiceServerMockUpdateMessageExpectationOrigins - results *AppPublicServiceServerMockUpdateMessageResults + params *AppPublicServiceServerMockUpdateTableParams + paramPtrs *AppPublicServiceServerMockUpdateTableParamPtrs + expectationOrigins AppPublicServiceServerMockUpdateTableExpectationOrigins + results *AppPublicServiceServerMockUpdateTableResults returnOrigin string Counter uint64 } -// AppPublicServiceServerMockUpdateMessageParams contains parameters of the AppPublicServiceServer.UpdateMessage -type AppPublicServiceServerMockUpdateMessageParams struct { +// AppPublicServiceServerMockUpdateTableParams contains parameters of the AppPublicServiceServer.UpdateTable +type AppPublicServiceServerMockUpdateTableParams struct { ctx context.Context - up1 *mm_appv1alpha.UpdateMessageRequest + up1 *mm_appv1alpha.UpdateTableRequest } -// AppPublicServiceServerMockUpdateMessageParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateMessage -type AppPublicServiceServerMockUpdateMessageParamPtrs struct { +// AppPublicServiceServerMockUpdateTableParamPtrs contains pointers to parameters of the AppPublicServiceServer.UpdateTable +type AppPublicServiceServerMockUpdateTableParamPtrs struct { ctx *context.Context - up1 **mm_appv1alpha.UpdateMessageRequest + up1 **mm_appv1alpha.UpdateTableRequest } -// AppPublicServiceServerMockUpdateMessageResults contains results of the AppPublicServiceServer.UpdateMessage -type AppPublicServiceServerMockUpdateMessageResults struct { - up2 *mm_appv1alpha.UpdateMessageResponse +// AppPublicServiceServerMockUpdateTableResults contains results of the AppPublicServiceServer.UpdateTable +type AppPublicServiceServerMockUpdateTableResults struct { + up2 *mm_appv1alpha.UpdateTableResponse err error } -// AppPublicServiceServerMockUpdateMessageOrigins contains origins of expectations of the AppPublicServiceServer.UpdateMessage -type AppPublicServiceServerMockUpdateMessageExpectationOrigins struct { +// AppPublicServiceServerMockUpdateTableOrigins contains origins of expectations of the AppPublicServiceServer.UpdateTable +type AppPublicServiceServerMockUpdateTableExpectationOrigins struct { origin string originCtx string originUp1 string @@ -9273,292 +14920,292 @@ type AppPublicServiceServerMockUpdateMessageExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Optional() *mAppPublicServiceServerMockUpdateMessage { - mmUpdateMessage.optional = true - return mmUpdateMessage +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Optional() *mAppPublicServiceServerMockUpdateTable { + mmUpdateTable.optional = true + return mmUpdateTable } -// Expect sets up expected params for AppPublicServiceServer.UpdateMessage -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) *mAppPublicServiceServerMockUpdateMessage { - if mmUpdateMessage.mock.funcUpdateMessage != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") +// Expect sets up expected params for AppPublicServiceServer.UpdateTable +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Expect(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest) *mAppPublicServiceServerMockUpdateTable { + if mmUpdateTable.mock.funcUpdateTable != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Set") } - if mmUpdateMessage.defaultExpectation == nil { - mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{} + if mmUpdateTable.defaultExpectation == nil { + mmUpdateTable.defaultExpectation = &AppPublicServiceServerMockUpdateTableExpectation{} } - if mmUpdateMessage.defaultExpectation.paramPtrs != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by ExpectParams functions") + if mmUpdateTable.defaultExpectation.paramPtrs != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by ExpectParams functions") } - mmUpdateMessage.defaultExpectation.params = &AppPublicServiceServerMockUpdateMessageParams{ctx, up1} - mmUpdateMessage.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmUpdateMessage.expectations { - if minimock.Equal(e.params, mmUpdateMessage.defaultExpectation.params) { - mmUpdateMessage.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateMessage.defaultExpectation.params) + mmUpdateTable.defaultExpectation.params = &AppPublicServiceServerMockUpdateTableParams{ctx, up1} + mmUpdateTable.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmUpdateTable.expectations { + if minimock.Equal(e.params, mmUpdateTable.defaultExpectation.params) { + mmUpdateTable.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateTable.defaultExpectation.params) } } - return mmUpdateMessage + return mmUpdateTable } -// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateMessage -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateMessage { - if mmUpdateMessage.mock.funcUpdateMessage != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for AppPublicServiceServer.UpdateTable +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) ExpectCtxParam1(ctx context.Context) *mAppPublicServiceServerMockUpdateTable { + if mmUpdateTable.mock.funcUpdateTable != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Set") } - if mmUpdateMessage.defaultExpectation == nil { - mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{} + if mmUpdateTable.defaultExpectation == nil { + mmUpdateTable.defaultExpectation = &AppPublicServiceServerMockUpdateTableExpectation{} } - if mmUpdateMessage.defaultExpectation.params != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Expect") + if mmUpdateTable.defaultExpectation.params != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Expect") } - if mmUpdateMessage.defaultExpectation.paramPtrs == nil { - mmUpdateMessage.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateMessageParamPtrs{} + if mmUpdateTable.defaultExpectation.paramPtrs == nil { + mmUpdateTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateTableParamPtrs{} } - mmUpdateMessage.defaultExpectation.paramPtrs.ctx = &ctx - mmUpdateMessage.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmUpdateTable.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateTable.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmUpdateMessage + return mmUpdateTable } -// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateMessage -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateMessageRequest) *mAppPublicServiceServerMockUpdateMessage { - if mmUpdateMessage.mock.funcUpdateMessage != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") +// ExpectUp1Param2 sets up expected param up1 for AppPublicServiceServer.UpdateTable +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) ExpectUp1Param2(up1 *mm_appv1alpha.UpdateTableRequest) *mAppPublicServiceServerMockUpdateTable { + if mmUpdateTable.mock.funcUpdateTable != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Set") } - if mmUpdateMessage.defaultExpectation == nil { - mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{} + if mmUpdateTable.defaultExpectation == nil { + mmUpdateTable.defaultExpectation = &AppPublicServiceServerMockUpdateTableExpectation{} } - if mmUpdateMessage.defaultExpectation.params != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Expect") + if mmUpdateTable.defaultExpectation.params != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Expect") } - if mmUpdateMessage.defaultExpectation.paramPtrs == nil { - mmUpdateMessage.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateMessageParamPtrs{} + if mmUpdateTable.defaultExpectation.paramPtrs == nil { + mmUpdateTable.defaultExpectation.paramPtrs = &AppPublicServiceServerMockUpdateTableParamPtrs{} } - mmUpdateMessage.defaultExpectation.paramPtrs.up1 = &up1 - mmUpdateMessage.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) + mmUpdateTable.defaultExpectation.paramPtrs.up1 = &up1 + mmUpdateTable.defaultExpectation.expectationOrigins.originUp1 = minimock.CallerInfo(1) - return mmUpdateMessage + return mmUpdateTable } -// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateMessage -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest)) *mAppPublicServiceServerMockUpdateMessage { - if mmUpdateMessage.mock.inspectFuncUpdateMessage != nil { - mmUpdateMessage.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateMessage") +// Inspect accepts an inspector function that has same arguments as the AppPublicServiceServer.UpdateTable +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Inspect(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest)) *mAppPublicServiceServerMockUpdateTable { + if mmUpdateTable.mock.inspectFuncUpdateTable != nil { + mmUpdateTable.mock.t.Fatalf("Inspect function is already set for AppPublicServiceServerMock.UpdateTable") } - mmUpdateMessage.mock.inspectFuncUpdateMessage = f + mmUpdateTable.mock.inspectFuncUpdateTable = f - return mmUpdateMessage + return mmUpdateTable } -// Return sets up results that will be returned by AppPublicServiceServer.UpdateMessage -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Return(up2 *mm_appv1alpha.UpdateMessageResponse, err error) *AppPublicServiceServerMock { - if mmUpdateMessage.mock.funcUpdateMessage != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") +// Return sets up results that will be returned by AppPublicServiceServer.UpdateTable +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Return(up2 *mm_appv1alpha.UpdateTableResponse, err error) *AppPublicServiceServerMock { + if mmUpdateTable.mock.funcUpdateTable != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Set") } - if mmUpdateMessage.defaultExpectation == nil { - mmUpdateMessage.defaultExpectation = &AppPublicServiceServerMockUpdateMessageExpectation{mock: mmUpdateMessage.mock} + if mmUpdateTable.defaultExpectation == nil { + mmUpdateTable.defaultExpectation = &AppPublicServiceServerMockUpdateTableExpectation{mock: mmUpdateTable.mock} } - mmUpdateMessage.defaultExpectation.results = &AppPublicServiceServerMockUpdateMessageResults{up2, err} - mmUpdateMessage.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmUpdateMessage.mock + mmUpdateTable.defaultExpectation.results = &AppPublicServiceServerMockUpdateTableResults{up2, err} + mmUpdateTable.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmUpdateTable.mock } -// Set uses given function f to mock the AppPublicServiceServer.UpdateMessage method -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) (up2 *mm_appv1alpha.UpdateMessageResponse, err error)) *AppPublicServiceServerMock { - if mmUpdateMessage.defaultExpectation != nil { - mmUpdateMessage.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateMessage method") +// Set uses given function f to mock the AppPublicServiceServer.UpdateTable method +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Set(f func(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest) (up2 *mm_appv1alpha.UpdateTableResponse, err error)) *AppPublicServiceServerMock { + if mmUpdateTable.defaultExpectation != nil { + mmUpdateTable.mock.t.Fatalf("Default expectation is already set for the AppPublicServiceServer.UpdateTable method") } - if len(mmUpdateMessage.expectations) > 0 { - mmUpdateMessage.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateMessage method") + if len(mmUpdateTable.expectations) > 0 { + mmUpdateTable.mock.t.Fatalf("Some expectations are already set for the AppPublicServiceServer.UpdateTable method") } - mmUpdateMessage.mock.funcUpdateMessage = f - mmUpdateMessage.mock.funcUpdateMessageOrigin = minimock.CallerInfo(1) - return mmUpdateMessage.mock + mmUpdateTable.mock.funcUpdateTable = f + mmUpdateTable.mock.funcUpdateTableOrigin = minimock.CallerInfo(1) + return mmUpdateTable.mock } -// When sets expectation for the AppPublicServiceServer.UpdateMessage which will trigger the result defined by the following +// When sets expectation for the AppPublicServiceServer.UpdateTable which will trigger the result defined by the following // Then helper -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) When(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) *AppPublicServiceServerMockUpdateMessageExpectation { - if mmUpdateMessage.mock.funcUpdateMessage != nil { - mmUpdateMessage.mock.t.Fatalf("AppPublicServiceServerMock.UpdateMessage mock is already set by Set") +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) When(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest) *AppPublicServiceServerMockUpdateTableExpectation { + if mmUpdateTable.mock.funcUpdateTable != nil { + mmUpdateTable.mock.t.Fatalf("AppPublicServiceServerMock.UpdateTable mock is already set by Set") } - expectation := &AppPublicServiceServerMockUpdateMessageExpectation{ - mock: mmUpdateMessage.mock, - params: &AppPublicServiceServerMockUpdateMessageParams{ctx, up1}, - expectationOrigins: AppPublicServiceServerMockUpdateMessageExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &AppPublicServiceServerMockUpdateTableExpectation{ + mock: mmUpdateTable.mock, + params: &AppPublicServiceServerMockUpdateTableParams{ctx, up1}, + expectationOrigins: AppPublicServiceServerMockUpdateTableExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmUpdateMessage.expectations = append(mmUpdateMessage.expectations, expectation) + mmUpdateTable.expectations = append(mmUpdateTable.expectations, expectation) return expectation } -// Then sets up AppPublicServiceServer.UpdateMessage return parameters for the expectation previously defined by the When method -func (e *AppPublicServiceServerMockUpdateMessageExpectation) Then(up2 *mm_appv1alpha.UpdateMessageResponse, err error) *AppPublicServiceServerMock { - e.results = &AppPublicServiceServerMockUpdateMessageResults{up2, err} +// Then sets up AppPublicServiceServer.UpdateTable return parameters for the expectation previously defined by the When method +func (e *AppPublicServiceServerMockUpdateTableExpectation) Then(up2 *mm_appv1alpha.UpdateTableResponse, err error) *AppPublicServiceServerMock { + e.results = &AppPublicServiceServerMockUpdateTableResults{up2, err} return e.mock } -// Times sets number of times AppPublicServiceServer.UpdateMessage should be invoked -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Times(n uint64) *mAppPublicServiceServerMockUpdateMessage { +// Times sets number of times AppPublicServiceServer.UpdateTable should be invoked +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Times(n uint64) *mAppPublicServiceServerMockUpdateTable { if n == 0 { - mmUpdateMessage.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateMessage mock can not be zero") + mmUpdateTable.mock.t.Fatalf("Times of AppPublicServiceServerMock.UpdateTable mock can not be zero") } - mm_atomic.StoreUint64(&mmUpdateMessage.expectedInvocations, n) - mmUpdateMessage.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmUpdateMessage + mm_atomic.StoreUint64(&mmUpdateTable.expectedInvocations, n) + mmUpdateTable.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmUpdateTable } -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) invocationsDone() bool { - if len(mmUpdateMessage.expectations) == 0 && mmUpdateMessage.defaultExpectation == nil && mmUpdateMessage.mock.funcUpdateMessage == nil { +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) invocationsDone() bool { + if len(mmUpdateTable.expectations) == 0 && mmUpdateTable.defaultExpectation == nil && mmUpdateTable.mock.funcUpdateTable == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmUpdateMessage.mock.afterUpdateMessageCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmUpdateMessage.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmUpdateTable.mock.afterUpdateTableCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUpdateTable.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// UpdateMessage implements mm_appv1alpha.AppPublicServiceServer -func (mmUpdateMessage *AppPublicServiceServerMock) UpdateMessage(ctx context.Context, up1 *mm_appv1alpha.UpdateMessageRequest) (up2 *mm_appv1alpha.UpdateMessageResponse, err error) { - mm_atomic.AddUint64(&mmUpdateMessage.beforeUpdateMessageCounter, 1) - defer mm_atomic.AddUint64(&mmUpdateMessage.afterUpdateMessageCounter, 1) +// UpdateTable implements mm_appv1alpha.AppPublicServiceServer +func (mmUpdateTable *AppPublicServiceServerMock) UpdateTable(ctx context.Context, up1 *mm_appv1alpha.UpdateTableRequest) (up2 *mm_appv1alpha.UpdateTableResponse, err error) { + mm_atomic.AddUint64(&mmUpdateTable.beforeUpdateTableCounter, 1) + defer mm_atomic.AddUint64(&mmUpdateTable.afterUpdateTableCounter, 1) - mmUpdateMessage.t.Helper() + mmUpdateTable.t.Helper() - if mmUpdateMessage.inspectFuncUpdateMessage != nil { - mmUpdateMessage.inspectFuncUpdateMessage(ctx, up1) + if mmUpdateTable.inspectFuncUpdateTable != nil { + mmUpdateTable.inspectFuncUpdateTable(ctx, up1) } - mm_params := AppPublicServiceServerMockUpdateMessageParams{ctx, up1} + mm_params := AppPublicServiceServerMockUpdateTableParams{ctx, up1} // Record call args - mmUpdateMessage.UpdateMessageMock.mutex.Lock() - mmUpdateMessage.UpdateMessageMock.callArgs = append(mmUpdateMessage.UpdateMessageMock.callArgs, &mm_params) - mmUpdateMessage.UpdateMessageMock.mutex.Unlock() + mmUpdateTable.UpdateTableMock.mutex.Lock() + mmUpdateTable.UpdateTableMock.callArgs = append(mmUpdateTable.UpdateTableMock.callArgs, &mm_params) + mmUpdateTable.UpdateTableMock.mutex.Unlock() - for _, e := range mmUpdateMessage.UpdateMessageMock.expectations { + for _, e := range mmUpdateTable.UpdateTableMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.up2, e.results.err } } - if mmUpdateMessage.UpdateMessageMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmUpdateMessage.UpdateMessageMock.defaultExpectation.Counter, 1) - mm_want := mmUpdateMessage.UpdateMessageMock.defaultExpectation.params - mm_want_ptrs := mmUpdateMessage.UpdateMessageMock.defaultExpectation.paramPtrs + if mmUpdateTable.UpdateTableMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUpdateTable.UpdateTableMock.defaultExpectation.Counter, 1) + mm_want := mmUpdateTable.UpdateTableMock.defaultExpectation.params + mm_want_ptrs := mmUpdateTable.UpdateTableMock.defaultExpectation.paramPtrs - mm_got := AppPublicServiceServerMockUpdateMessageParams{ctx, up1} + mm_got := AppPublicServiceServerMockUpdateTableParams{ctx, up1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateMessage.t.Errorf("AppPublicServiceServerMock.UpdateMessage got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateMessage.UpdateMessageMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateTable.t.Errorf("AppPublicServiceServerMock.UpdateTable got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateTable.UpdateTableMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.up1 != nil && !minimock.Equal(*mm_want_ptrs.up1, mm_got.up1) { - mmUpdateMessage.t.Errorf("AppPublicServiceServerMock.UpdateMessage got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateMessage.UpdateMessageMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) + mmUpdateTable.t.Errorf("AppPublicServiceServerMock.UpdateTable got unexpected parameter up1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateTable.UpdateTableMock.defaultExpectation.expectationOrigins.originUp1, *mm_want_ptrs.up1, mm_got.up1, minimock.Diff(*mm_want_ptrs.up1, mm_got.up1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateMessage.t.Errorf("AppPublicServiceServerMock.UpdateMessage got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmUpdateMessage.UpdateMessageMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateTable.t.Errorf("AppPublicServiceServerMock.UpdateTable got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateTable.UpdateTableMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmUpdateMessage.UpdateMessageMock.defaultExpectation.results + mm_results := mmUpdateTable.UpdateTableMock.defaultExpectation.results if mm_results == nil { - mmUpdateMessage.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateMessage") + mmUpdateTable.t.Fatal("No results are set for the AppPublicServiceServerMock.UpdateTable") } return (*mm_results).up2, (*mm_results).err } - if mmUpdateMessage.funcUpdateMessage != nil { - return mmUpdateMessage.funcUpdateMessage(ctx, up1) + if mmUpdateTable.funcUpdateTable != nil { + return mmUpdateTable.funcUpdateTable(ctx, up1) } - mmUpdateMessage.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateMessage. %v %v", ctx, up1) + mmUpdateTable.t.Fatalf("Unexpected call to AppPublicServiceServerMock.UpdateTable. %v %v", ctx, up1) return } -// UpdateMessageAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateMessage invocations -func (mmUpdateMessage *AppPublicServiceServerMock) UpdateMessageAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateMessage.afterUpdateMessageCounter) +// UpdateTableAfterCounter returns a count of finished AppPublicServiceServerMock.UpdateTable invocations +func (mmUpdateTable *AppPublicServiceServerMock) UpdateTableAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateTable.afterUpdateTableCounter) } -// UpdateMessageBeforeCounter returns a count of AppPublicServiceServerMock.UpdateMessage invocations -func (mmUpdateMessage *AppPublicServiceServerMock) UpdateMessageBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmUpdateMessage.beforeUpdateMessageCounter) +// UpdateTableBeforeCounter returns a count of AppPublicServiceServerMock.UpdateTable invocations +func (mmUpdateTable *AppPublicServiceServerMock) UpdateTableBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUpdateTable.beforeUpdateTableCounter) } -// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateMessage. +// Calls returns a list of arguments used in each call to AppPublicServiceServerMock.UpdateTable. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmUpdateMessage *mAppPublicServiceServerMockUpdateMessage) Calls() []*AppPublicServiceServerMockUpdateMessageParams { - mmUpdateMessage.mutex.RLock() +func (mmUpdateTable *mAppPublicServiceServerMockUpdateTable) Calls() []*AppPublicServiceServerMockUpdateTableParams { + mmUpdateTable.mutex.RLock() - argCopy := make([]*AppPublicServiceServerMockUpdateMessageParams, len(mmUpdateMessage.callArgs)) - copy(argCopy, mmUpdateMessage.callArgs) + argCopy := make([]*AppPublicServiceServerMockUpdateTableParams, len(mmUpdateTable.callArgs)) + copy(argCopy, mmUpdateTable.callArgs) - mmUpdateMessage.mutex.RUnlock() + mmUpdateTable.mutex.RUnlock() return argCopy } -// MinimockUpdateMessageDone returns true if the count of the UpdateMessage invocations corresponds +// MinimockUpdateTableDone returns true if the count of the UpdateTable invocations corresponds // the number of defined expectations -func (m *AppPublicServiceServerMock) MinimockUpdateMessageDone() bool { - if m.UpdateMessageMock.optional { +func (m *AppPublicServiceServerMock) MinimockUpdateTableDone() bool { + if m.UpdateTableMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.UpdateMessageMock.expectations { + for _, e := range m.UpdateTableMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.UpdateMessageMock.invocationsDone() + return m.UpdateTableMock.invocationsDone() } -// MinimockUpdateMessageInspect logs each unmet expectation -func (m *AppPublicServiceServerMock) MinimockUpdateMessageInspect() { - for _, e := range m.UpdateMessageMock.expectations { +// MinimockUpdateTableInspect logs each unmet expectation +func (m *AppPublicServiceServerMock) MinimockUpdateTableInspect() { + for _, e := range m.UpdateTableMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateTable at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterUpdateMessageCounter := mm_atomic.LoadUint64(&m.afterUpdateMessageCounter) + afterUpdateTableCounter := mm_atomic.LoadUint64(&m.afterUpdateTableCounter) // if default expectation was set then invocations count should be greater than zero - if m.UpdateMessageMock.defaultExpectation != nil && afterUpdateMessageCounter < 1 { - if m.UpdateMessageMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s", m.UpdateMessageMock.defaultExpectation.returnOrigin) + if m.UpdateTableMock.defaultExpectation != nil && afterUpdateTableCounter < 1 { + if m.UpdateTableMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateTable at\n%s", m.UpdateTableMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s with params: %#v", m.UpdateMessageMock.defaultExpectation.expectationOrigins.origin, *m.UpdateMessageMock.defaultExpectation.params) + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateTable at\n%s with params: %#v", m.UpdateTableMock.defaultExpectation.expectationOrigins.origin, *m.UpdateTableMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcUpdateMessage != nil && afterUpdateMessageCounter < 1 { - m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateMessage at\n%s", m.funcUpdateMessageOrigin) + if m.funcUpdateTable != nil && afterUpdateTableCounter < 1 { + m.t.Errorf("Expected call to AppPublicServiceServerMock.UpdateTable at\n%s", m.funcUpdateTableOrigin) } - if !m.UpdateMessageMock.invocationsDone() && afterUpdateMessageCounter > 0 { - m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateMessage at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.UpdateMessageMock.expectedInvocations), m.UpdateMessageMock.expectedInvocationsOrigin, afterUpdateMessageCounter) + if !m.UpdateTableMock.invocationsDone() && afterUpdateTableCounter > 0 { + m.t.Errorf("Expected %d calls to AppPublicServiceServerMock.UpdateTable at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateTableMock.expectedInvocations), m.UpdateTableMock.expectedInvocationsOrigin, afterUpdateTableCounter) } } @@ -9578,6 +15225,8 @@ func (m *AppPublicServiceServerMock) MinimockFinish() { m.MinimockCreateMessageInspect() + m.MinimockCreateTableInspect() + m.MinimockDeleteAgentInspect() m.MinimockDeleteAppInspect() @@ -9588,8 +15237,24 @@ func (m *AppPublicServiceServerMock) MinimockFinish() { m.MinimockDeleteMessageInspect() + m.MinimockDeleteRowInspect() + + m.MinimockDeleteRowsInspect() + + m.MinimockDeleteTableInspect() + + m.MinimockExportInspect() + + m.MinimockGetColumnDefinitionsInspect() + m.MinimockGetPlaygroundConversationInspect() + m.MinimockGetTableInspect() + + m.MinimockGetTableEventsInspect() + + m.MinimockInsertRowInspect() + m.MinimockListAgentsInspect() m.MinimockListAppsInspect() @@ -9602,10 +15267,16 @@ func (m *AppPublicServiceServerMock) MinimockFinish() { m.MinimockListMessagesInspect() + m.MinimockListRowsInspect() + + m.MinimockListTablesInspect() + m.MinimockListToolsInspect() m.MinimockLivenessInspect() + m.MinimockMoveRowsInspect() + m.MinimockReadinessInspect() m.MinimockRestartPlaygroundConversationInspect() @@ -9616,9 +15287,17 @@ func (m *AppPublicServiceServerMock) MinimockFinish() { m.MinimockUpdateChatInspect() + m.MinimockUpdateColumnDefinitionsInspect() + m.MinimockUpdateConversationInspect() m.MinimockUpdateMessageInspect() + + m.MinimockUpdateRowInspect() + + m.MinimockUpdateRowsInspect() + + m.MinimockUpdateTableInspect() } }) } @@ -9648,25 +15327,41 @@ func (m *AppPublicServiceServerMock) minimockDone() bool { m.MinimockCreateChatDone() && m.MinimockCreateConversationDone() && m.MinimockCreateMessageDone() && + m.MinimockCreateTableDone() && m.MinimockDeleteAgentDone() && m.MinimockDeleteAppDone() && m.MinimockDeleteChatDone() && m.MinimockDeleteConversationDone() && m.MinimockDeleteMessageDone() && + m.MinimockDeleteRowDone() && + m.MinimockDeleteRowsDone() && + m.MinimockDeleteTableDone() && + m.MinimockExportDone() && + m.MinimockGetColumnDefinitionsDone() && m.MinimockGetPlaygroundConversationDone() && + m.MinimockGetTableDone() && + m.MinimockGetTableEventsDone() && + m.MinimockInsertRowDone() && m.MinimockListAgentsDone() && m.MinimockListAppsDone() && m.MinimockListChatMessagesDone() && m.MinimockListChatsDone() && m.MinimockListConversationsDone() && m.MinimockListMessagesDone() && + m.MinimockListRowsDone() && + m.MinimockListTablesDone() && m.MinimockListToolsDone() && m.MinimockLivenessDone() && + m.MinimockMoveRowsDone() && m.MinimockReadinessDone() && m.MinimockRestartPlaygroundConversationDone() && m.MinimockUpdateAgentDone() && m.MinimockUpdateAppDone() && m.MinimockUpdateChatDone() && + m.MinimockUpdateColumnDefinitionsDone() && m.MinimockUpdateConversationDone() && - m.MinimockUpdateMessageDone() + m.MinimockUpdateMessageDone() && + m.MinimockUpdateRowDone() && + m.MinimockUpdateRowsDone() && + m.MinimockUpdateTableDone() } diff --git a/pkg/datamodel/datamodel.go b/pkg/datamodel/datamodel.go index 3061dabf4..e799f52cd 100644 --- a/pkg/datamodel/datamodel.go +++ b/pkg/datamodel/datamodel.go @@ -80,6 +80,11 @@ type Pipeline struct { Recipe *Recipe `gorm:"-"` RecipeYAML string `gorm:"recipe_yaml"` + UseTemplate bool + TemplatePipelineUID uuid.UUID + TemplatePipelineReleaseUID uuid.UUID + TemplateOverrides datatypes.JSON `gorm:"type:jsonb"` + DefaultReleaseUID uuid.UUID Sharing *Sharing `gorm:"type:jsonb"` ShareCode string diff --git a/pkg/db/migration/000040_template.down.sql b/pkg/db/migration/000040_template.down.sql new file mode 100644 index 000000000..efc9f11f0 --- /dev/null +++ b/pkg/db/migration/000040_template.down.sql @@ -0,0 +1,8 @@ +BEGIN; + +ALTER TABLE pipeline DROP COLUMN IF EXISTS template_overrides; +ALTER TABLE pipeline DROP COLUMN IF EXISTS template_pipeline_release_uid; +ALTER TABLE pipeline DROP COLUMN IF EXISTS template_pipeline_uid; +ALTER TABLE pipeline DROP COLUMN IF EXISTS use_template; + +COMMIT; diff --git a/pkg/db/migration/000040_template.up.sql b/pkg/db/migration/000040_template.up.sql new file mode 100644 index 000000000..934195a0c --- /dev/null +++ b/pkg/db/migration/000040_template.up.sql @@ -0,0 +1,15 @@ +BEGIN; + +-- Add column to indicate if pipeline is using a template +ALTER TABLE pipeline ADD COLUMN IF NOT EXISTS use_template BOOLEAN DEFAULT FALSE; + +-- Add column to store the UUID of the template pipeline being used +ALTER TABLE pipeline ADD COLUMN IF NOT EXISTS template_pipeline_uid UUID; + +-- Add column to store the UUID of the specific template pipeline release being used +ALTER TABLE pipeline ADD COLUMN IF NOT EXISTS template_pipeline_release_uid UUID; + +-- Add column to store JSON overrides for template customization +ALTER TABLE pipeline ADD COLUMN IF NOT EXISTS template_overrides JSONB; + +COMMIT; diff --git a/pkg/errors/errors.go b/pkg/errors/errors.go index fc35d99b7..95cfe49d7 100644 --- a/pkg/errors/errors.go +++ b/pkg/errors/errors.go @@ -29,4 +29,7 @@ var ( // ErrAlreadyExists is used when a resource can't be created because it // already exists. ErrAlreadyExists = errmsg.AddMessage(fmt.Errorf("resource already exists"), "Resource already exists.") + // ErrCanNotUpdatePipelineWithTemplate is used when a request want to update + // a pipeline with template. + ErrCanNotUpdatePipelineWithTemplate = fmt.Errorf("can not update pipeline with template") ) diff --git a/pkg/handler/pipeline.go b/pkg/handler/pipeline.go index 7e3bea6f3..80cf68e6a 100644 --- a/pkg/handler/pipeline.go +++ b/pkg/handler/pipeline.go @@ -860,6 +860,7 @@ func (h *PublicHandler) CloneNamespacePipeline(ctx context.Context, req *pb.Clon logger, _ := logger.GetZapLogger(ctx) + fmt.Println("0") ns, err := h.service.GetNamespaceByID(ctx, req.NamespaceId) if err != nil { span.SetStatus(1, err.Error()) @@ -869,6 +870,7 @@ func (h *PublicHandler) CloneNamespacePipeline(ctx context.Context, req *pb.Clon span.SetStatus(1, err.Error()) return nil, err } + fmt.Println("1") pbPipeline, err := h.service.CloneNamespacePipeline( ctx, @@ -878,6 +880,8 @@ func (h *PublicHandler) CloneNamespacePipeline(ctx context.Context, req *pb.Clon req.GetTargetPipelineId(), req.GetDescription(), req.GetSharing(), + req.GetAsTemplate(), + req.GetTemplateOverrides(), ) if err != nil { span.SetStatus(1, err.Error()) @@ -928,6 +932,8 @@ func (h *PublicHandler) CloneNamespacePipelineRelease(ctx context.Context, req * req.GetTargetPipelineId(), req.GetDescription(), req.GetSharing(), + req.GetAsTemplate(), + req.GetTemplateOverrides(), ) if err != nil { span.SetStatus(1, err.Error()) diff --git a/pkg/middleware/interceptor.go b/pkg/middleware/interceptor.go index b22f07855..adcf759c7 100644 --- a/pkg/middleware/interceptor.go +++ b/pkg/middleware/interceptor.go @@ -102,7 +102,8 @@ func AsGRPCError(err error) error { errors.Is(err, service.ErrTriggerFail), errors.Is(err, handler.ErrFieldMask), errors.Is(err, handler.ErrSematicVersion), - errors.Is(err, handler.ErrUpdateMask): + errors.Is(err, handler.ErrUpdateMask), + errors.Is(err, errdomain.ErrCanNotUpdatePipelineWithTemplate): code = codes.InvalidArgument case diff --git a/pkg/mock/repository_mock.gen.go b/pkg/mock/repository_mock.gen.go index d59dbbff1..5e882d09d 100644 --- a/pkg/mock/repository_mock.gen.go +++ b/pkg/mock/repository_mock.gen.go @@ -25,20 +25,6 @@ type RepositoryMock struct { t minimock.Tester finishOnce sync.Once - funcAddPipelineClones func(ctx context.Context, uid uuid.UUID) (err error) - funcAddPipelineClonesOrigin string - inspectFuncAddPipelineClones func(ctx context.Context, uid uuid.UUID) - afterAddPipelineClonesCounter uint64 - beforeAddPipelineClonesCounter uint64 - AddPipelineClonesMock mRepositoryMockAddPipelineClones - - funcAddPipelineRuns func(ctx context.Context, uid uuid.UUID) (err error) - funcAddPipelineRunsOrigin string - inspectFuncAddPipelineRuns func(ctx context.Context, uid uuid.UUID) - afterAddPipelineRunsCounter uint64 - beforeAddPipelineRunsCounter uint64 - AddPipelineRunsMock mRepositoryMockAddPipelineRuns - funcCheckPinnedUser func(ctx context.Context, dp1 *gorm.DB, table string) (dp2 *gorm.DB) funcCheckPinnedUserOrigin string inspectFuncCheckPinnedUser func(ctx context.Context, dp1 *gorm.DB, table string) @@ -235,6 +221,20 @@ type RepositoryMock struct { beforeGetPipelineRunByUIDCounter uint64 GetPipelineRunByUIDMock mRepositoryMockGetPipelineRunByUID + funcIncreasePipelineClones func(ctx context.Context, uid uuid.UUID) (err error) + funcIncreasePipelineClonesOrigin string + inspectFuncIncreasePipelineClones func(ctx context.Context, uid uuid.UUID) + afterIncreasePipelineClonesCounter uint64 + beforeIncreasePipelineClonesCounter uint64 + IncreasePipelineClonesMock mRepositoryMockIncreasePipelineClones + + funcIncreasePipelineRuns func(ctx context.Context, uid uuid.UUID) (err error) + funcIncreasePipelineRunsOrigin string + inspectFuncIncreasePipelineRuns func(ctx context.Context, uid uuid.UUID) + afterIncreasePipelineRunsCounter uint64 + beforeIncreasePipelineRunsCounter uint64 + IncreasePipelineRunsMock mRepositoryMockIncreasePipelineRuns + funcListComponentDefinitionUIDs func(ctx context.Context, l1 mm_repository.ListComponentDefinitionsParams) (uids []*datamodel.ComponentDefinition, totalSize int64, err error) funcListComponentDefinitionUIDsOrigin string inspectFuncListComponentDefinitionUIDs func(ctx context.Context, l1 mm_repository.ListComponentDefinitionsParams) @@ -419,12 +419,6 @@ func NewRepositoryMock(t minimock.Tester) *RepositoryMock { controller.RegisterMocker(m) } - m.AddPipelineClonesMock = mRepositoryMockAddPipelineClones{mock: m} - m.AddPipelineClonesMock.callArgs = []*RepositoryMockAddPipelineClonesParams{} - - m.AddPipelineRunsMock = mRepositoryMockAddPipelineRuns{mock: m} - m.AddPipelineRunsMock.callArgs = []*RepositoryMockAddPipelineRunsParams{} - m.CheckPinnedUserMock = mRepositoryMockCheckPinnedUser{mock: m} m.CheckPinnedUserMock.callArgs = []*RepositoryMockCheckPinnedUserParams{} @@ -509,6 +503,12 @@ func NewRepositoryMock(t minimock.Tester) *RepositoryMock { m.GetPipelineRunByUIDMock = mRepositoryMockGetPipelineRunByUID{mock: m} m.GetPipelineRunByUIDMock.callArgs = []*RepositoryMockGetPipelineRunByUIDParams{} + m.IncreasePipelineClonesMock = mRepositoryMockIncreasePipelineClones{mock: m} + m.IncreasePipelineClonesMock.callArgs = []*RepositoryMockIncreasePipelineClonesParams{} + + m.IncreasePipelineRunsMock = mRepositoryMockIncreasePipelineRuns{mock: m} + m.IncreasePipelineRunsMock.callArgs = []*RepositoryMockIncreasePipelineRunsParams{} + m.ListComponentDefinitionUIDsMock = mRepositoryMockListComponentDefinitionUIDs{mock: m} m.ListComponentDefinitionUIDsMock.callArgs = []*RepositoryMockListComponentDefinitionUIDsParams{} @@ -589,52 +589,55 @@ func NewRepositoryMock(t minimock.Tester) *RepositoryMock { return m } -type mRepositoryMockAddPipelineClones struct { +type mRepositoryMockCheckPinnedUser struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockAddPipelineClonesExpectation - expectations []*RepositoryMockAddPipelineClonesExpectation + defaultExpectation *RepositoryMockCheckPinnedUserExpectation + expectations []*RepositoryMockCheckPinnedUserExpectation - callArgs []*RepositoryMockAddPipelineClonesParams + callArgs []*RepositoryMockCheckPinnedUserParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockAddPipelineClonesExpectation specifies expectation struct of the Repository.AddPipelineClones -type RepositoryMockAddPipelineClonesExpectation struct { +// RepositoryMockCheckPinnedUserExpectation specifies expectation struct of the Repository.CheckPinnedUser +type RepositoryMockCheckPinnedUserExpectation struct { mock *RepositoryMock - params *RepositoryMockAddPipelineClonesParams - paramPtrs *RepositoryMockAddPipelineClonesParamPtrs - expectationOrigins RepositoryMockAddPipelineClonesExpectationOrigins - results *RepositoryMockAddPipelineClonesResults + params *RepositoryMockCheckPinnedUserParams + paramPtrs *RepositoryMockCheckPinnedUserParamPtrs + expectationOrigins RepositoryMockCheckPinnedUserExpectationOrigins + results *RepositoryMockCheckPinnedUserResults returnOrigin string Counter uint64 } -// RepositoryMockAddPipelineClonesParams contains parameters of the Repository.AddPipelineClones -type RepositoryMockAddPipelineClonesParams struct { - ctx context.Context - uid uuid.UUID +// RepositoryMockCheckPinnedUserParams contains parameters of the Repository.CheckPinnedUser +type RepositoryMockCheckPinnedUserParams struct { + ctx context.Context + dp1 *gorm.DB + table string } -// RepositoryMockAddPipelineClonesParamPtrs contains pointers to parameters of the Repository.AddPipelineClones -type RepositoryMockAddPipelineClonesParamPtrs struct { - ctx *context.Context - uid *uuid.UUID +// RepositoryMockCheckPinnedUserParamPtrs contains pointers to parameters of the Repository.CheckPinnedUser +type RepositoryMockCheckPinnedUserParamPtrs struct { + ctx *context.Context + dp1 **gorm.DB + table *string } -// RepositoryMockAddPipelineClonesResults contains results of the Repository.AddPipelineClones -type RepositoryMockAddPipelineClonesResults struct { - err error +// RepositoryMockCheckPinnedUserResults contains results of the Repository.CheckPinnedUser +type RepositoryMockCheckPinnedUserResults struct { + dp2 *gorm.DB } -// RepositoryMockAddPipelineClonesOrigins contains origins of expectations of the Repository.AddPipelineClones -type RepositoryMockAddPipelineClonesExpectationOrigins struct { - origin string - originCtx string - originUid string +// RepositoryMockCheckPinnedUserOrigins contains origins of expectations of the Repository.CheckPinnedUser +type RepositoryMockCheckPinnedUserExpectationOrigins struct { + origin string + originCtx string + originDp1 string + originTable string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -642,341 +645,370 @@ type RepositoryMockAddPipelineClonesExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Optional() *mRepositoryMockAddPipelineClones { - mmAddPipelineClones.optional = true - return mmAddPipelineClones +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Optional() *mRepositoryMockCheckPinnedUser { + mmCheckPinnedUser.optional = true + return mmCheckPinnedUser } -// Expect sets up expected params for Repository.AddPipelineClones -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Expect(ctx context.Context, uid uuid.UUID) *mRepositoryMockAddPipelineClones { - if mmAddPipelineClones.mock.funcAddPipelineClones != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Set") +// Expect sets up expected params for Repository.CheckPinnedUser +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Expect(ctx context.Context, dp1 *gorm.DB, table string) *mRepositoryMockCheckPinnedUser { + if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") } - if mmAddPipelineClones.defaultExpectation == nil { - mmAddPipelineClones.defaultExpectation = &RepositoryMockAddPipelineClonesExpectation{} + if mmCheckPinnedUser.defaultExpectation == nil { + mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} } - if mmAddPipelineClones.defaultExpectation.paramPtrs != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by ExpectParams functions") + if mmCheckPinnedUser.defaultExpectation.paramPtrs != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by ExpectParams functions") } - mmAddPipelineClones.defaultExpectation.params = &RepositoryMockAddPipelineClonesParams{ctx, uid} - mmAddPipelineClones.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmAddPipelineClones.expectations { - if minimock.Equal(e.params, mmAddPipelineClones.defaultExpectation.params) { - mmAddPipelineClones.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAddPipelineClones.defaultExpectation.params) + mmCheckPinnedUser.defaultExpectation.params = &RepositoryMockCheckPinnedUserParams{ctx, dp1, table} + mmCheckPinnedUser.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCheckPinnedUser.expectations { + if minimock.Equal(e.params, mmCheckPinnedUser.defaultExpectation.params) { + mmCheckPinnedUser.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckPinnedUser.defaultExpectation.params) } } - return mmAddPipelineClones + return mmCheckPinnedUser +} + +// ExpectCtxParam1 sets up expected param ctx for Repository.CheckPinnedUser +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCheckPinnedUser { + if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") + } + + if mmCheckPinnedUser.defaultExpectation == nil { + mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} + } + + if mmCheckPinnedUser.defaultExpectation.params != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Expect") + } + + if mmCheckPinnedUser.defaultExpectation.paramPtrs == nil { + mmCheckPinnedUser.defaultExpectation.paramPtrs = &RepositoryMockCheckPinnedUserParamPtrs{} + } + mmCheckPinnedUser.defaultExpectation.paramPtrs.ctx = &ctx + mmCheckPinnedUser.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmCheckPinnedUser } -// ExpectCtxParam1 sets up expected param ctx for Repository.AddPipelineClones -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) ExpectCtxParam1(ctx context.Context) *mRepositoryMockAddPipelineClones { - if mmAddPipelineClones.mock.funcAddPipelineClones != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Set") +// ExpectDp1Param2 sets up expected param dp1 for Repository.CheckPinnedUser +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) ExpectDp1Param2(dp1 *gorm.DB) *mRepositoryMockCheckPinnedUser { + if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") } - if mmAddPipelineClones.defaultExpectation == nil { - mmAddPipelineClones.defaultExpectation = &RepositoryMockAddPipelineClonesExpectation{} + if mmCheckPinnedUser.defaultExpectation == nil { + mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} } - if mmAddPipelineClones.defaultExpectation.params != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Expect") + if mmCheckPinnedUser.defaultExpectation.params != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Expect") } - if mmAddPipelineClones.defaultExpectation.paramPtrs == nil { - mmAddPipelineClones.defaultExpectation.paramPtrs = &RepositoryMockAddPipelineClonesParamPtrs{} + if mmCheckPinnedUser.defaultExpectation.paramPtrs == nil { + mmCheckPinnedUser.defaultExpectation.paramPtrs = &RepositoryMockCheckPinnedUserParamPtrs{} } - mmAddPipelineClones.defaultExpectation.paramPtrs.ctx = &ctx - mmAddPipelineClones.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmCheckPinnedUser.defaultExpectation.paramPtrs.dp1 = &dp1 + mmCheckPinnedUser.defaultExpectation.expectationOrigins.originDp1 = minimock.CallerInfo(1) - return mmAddPipelineClones + return mmCheckPinnedUser } -// ExpectUidParam2 sets up expected param uid for Repository.AddPipelineClones -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockAddPipelineClones { - if mmAddPipelineClones.mock.funcAddPipelineClones != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Set") +// ExpectTableParam3 sets up expected param table for Repository.CheckPinnedUser +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) ExpectTableParam3(table string) *mRepositoryMockCheckPinnedUser { + if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") } - if mmAddPipelineClones.defaultExpectation == nil { - mmAddPipelineClones.defaultExpectation = &RepositoryMockAddPipelineClonesExpectation{} + if mmCheckPinnedUser.defaultExpectation == nil { + mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} } - if mmAddPipelineClones.defaultExpectation.params != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Expect") + if mmCheckPinnedUser.defaultExpectation.params != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Expect") } - if mmAddPipelineClones.defaultExpectation.paramPtrs == nil { - mmAddPipelineClones.defaultExpectation.paramPtrs = &RepositoryMockAddPipelineClonesParamPtrs{} + if mmCheckPinnedUser.defaultExpectation.paramPtrs == nil { + mmCheckPinnedUser.defaultExpectation.paramPtrs = &RepositoryMockCheckPinnedUserParamPtrs{} } - mmAddPipelineClones.defaultExpectation.paramPtrs.uid = &uid - mmAddPipelineClones.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) + mmCheckPinnedUser.defaultExpectation.paramPtrs.table = &table + mmCheckPinnedUser.defaultExpectation.expectationOrigins.originTable = minimock.CallerInfo(1) - return mmAddPipelineClones + return mmCheckPinnedUser } -// Inspect accepts an inspector function that has same arguments as the Repository.AddPipelineClones -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Inspect(f func(ctx context.Context, uid uuid.UUID)) *mRepositoryMockAddPipelineClones { - if mmAddPipelineClones.mock.inspectFuncAddPipelineClones != nil { - mmAddPipelineClones.mock.t.Fatalf("Inspect function is already set for RepositoryMock.AddPipelineClones") +// Inspect accepts an inspector function that has same arguments as the Repository.CheckPinnedUser +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Inspect(f func(ctx context.Context, dp1 *gorm.DB, table string)) *mRepositoryMockCheckPinnedUser { + if mmCheckPinnedUser.mock.inspectFuncCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CheckPinnedUser") } - mmAddPipelineClones.mock.inspectFuncAddPipelineClones = f + mmCheckPinnedUser.mock.inspectFuncCheckPinnedUser = f - return mmAddPipelineClones + return mmCheckPinnedUser } -// Return sets up results that will be returned by Repository.AddPipelineClones -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Return(err error) *RepositoryMock { - if mmAddPipelineClones.mock.funcAddPipelineClones != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Set") +// Return sets up results that will be returned by Repository.CheckPinnedUser +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Return(dp2 *gorm.DB) *RepositoryMock { + if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") } - if mmAddPipelineClones.defaultExpectation == nil { - mmAddPipelineClones.defaultExpectation = &RepositoryMockAddPipelineClonesExpectation{mock: mmAddPipelineClones.mock} + if mmCheckPinnedUser.defaultExpectation == nil { + mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{mock: mmCheckPinnedUser.mock} } - mmAddPipelineClones.defaultExpectation.results = &RepositoryMockAddPipelineClonesResults{err} - mmAddPipelineClones.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmAddPipelineClones.mock + mmCheckPinnedUser.defaultExpectation.results = &RepositoryMockCheckPinnedUserResults{dp2} + mmCheckPinnedUser.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCheckPinnedUser.mock } -// Set uses given function f to mock the Repository.AddPipelineClones method -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Set(f func(ctx context.Context, uid uuid.UUID) (err error)) *RepositoryMock { - if mmAddPipelineClones.defaultExpectation != nil { - mmAddPipelineClones.mock.t.Fatalf("Default expectation is already set for the Repository.AddPipelineClones method") +// Set uses given function f to mock the Repository.CheckPinnedUser method +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Set(f func(ctx context.Context, dp1 *gorm.DB, table string) (dp2 *gorm.DB)) *RepositoryMock { + if mmCheckPinnedUser.defaultExpectation != nil { + mmCheckPinnedUser.mock.t.Fatalf("Default expectation is already set for the Repository.CheckPinnedUser method") } - if len(mmAddPipelineClones.expectations) > 0 { - mmAddPipelineClones.mock.t.Fatalf("Some expectations are already set for the Repository.AddPipelineClones method") + if len(mmCheckPinnedUser.expectations) > 0 { + mmCheckPinnedUser.mock.t.Fatalf("Some expectations are already set for the Repository.CheckPinnedUser method") } - mmAddPipelineClones.mock.funcAddPipelineClones = f - mmAddPipelineClones.mock.funcAddPipelineClonesOrigin = minimock.CallerInfo(1) - return mmAddPipelineClones.mock + mmCheckPinnedUser.mock.funcCheckPinnedUser = f + mmCheckPinnedUser.mock.funcCheckPinnedUserOrigin = minimock.CallerInfo(1) + return mmCheckPinnedUser.mock } -// When sets expectation for the Repository.AddPipelineClones which will trigger the result defined by the following +// When sets expectation for the Repository.CheckPinnedUser which will trigger the result defined by the following // Then helper -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) When(ctx context.Context, uid uuid.UUID) *RepositoryMockAddPipelineClonesExpectation { - if mmAddPipelineClones.mock.funcAddPipelineClones != nil { - mmAddPipelineClones.mock.t.Fatalf("RepositoryMock.AddPipelineClones mock is already set by Set") +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) When(ctx context.Context, dp1 *gorm.DB, table string) *RepositoryMockCheckPinnedUserExpectation { + if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { + mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") } - expectation := &RepositoryMockAddPipelineClonesExpectation{ - mock: mmAddPipelineClones.mock, - params: &RepositoryMockAddPipelineClonesParams{ctx, uid}, - expectationOrigins: RepositoryMockAddPipelineClonesExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockCheckPinnedUserExpectation{ + mock: mmCheckPinnedUser.mock, + params: &RepositoryMockCheckPinnedUserParams{ctx, dp1, table}, + expectationOrigins: RepositoryMockCheckPinnedUserExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmAddPipelineClones.expectations = append(mmAddPipelineClones.expectations, expectation) + mmCheckPinnedUser.expectations = append(mmCheckPinnedUser.expectations, expectation) return expectation } -// Then sets up Repository.AddPipelineClones return parameters for the expectation previously defined by the When method -func (e *RepositoryMockAddPipelineClonesExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockAddPipelineClonesResults{err} +// Then sets up Repository.CheckPinnedUser return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCheckPinnedUserExpectation) Then(dp2 *gorm.DB) *RepositoryMock { + e.results = &RepositoryMockCheckPinnedUserResults{dp2} return e.mock } -// Times sets number of times Repository.AddPipelineClones should be invoked -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Times(n uint64) *mRepositoryMockAddPipelineClones { +// Times sets number of times Repository.CheckPinnedUser should be invoked +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Times(n uint64) *mRepositoryMockCheckPinnedUser { if n == 0 { - mmAddPipelineClones.mock.t.Fatalf("Times of RepositoryMock.AddPipelineClones mock can not be zero") + mmCheckPinnedUser.mock.t.Fatalf("Times of RepositoryMock.CheckPinnedUser mock can not be zero") } - mm_atomic.StoreUint64(&mmAddPipelineClones.expectedInvocations, n) - mmAddPipelineClones.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmAddPipelineClones + mm_atomic.StoreUint64(&mmCheckPinnedUser.expectedInvocations, n) + mmCheckPinnedUser.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCheckPinnedUser } -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) invocationsDone() bool { - if len(mmAddPipelineClones.expectations) == 0 && mmAddPipelineClones.defaultExpectation == nil && mmAddPipelineClones.mock.funcAddPipelineClones == nil { +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) invocationsDone() bool { + if len(mmCheckPinnedUser.expectations) == 0 && mmCheckPinnedUser.defaultExpectation == nil && mmCheckPinnedUser.mock.funcCheckPinnedUser == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmAddPipelineClones.mock.afterAddPipelineClonesCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmAddPipelineClones.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCheckPinnedUser.mock.afterCheckPinnedUserCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCheckPinnedUser.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// AddPipelineClones implements mm_repository.Repository -func (mmAddPipelineClones *RepositoryMock) AddPipelineClones(ctx context.Context, uid uuid.UUID) (err error) { - mm_atomic.AddUint64(&mmAddPipelineClones.beforeAddPipelineClonesCounter, 1) - defer mm_atomic.AddUint64(&mmAddPipelineClones.afterAddPipelineClonesCounter, 1) +// CheckPinnedUser implements mm_repository.Repository +func (mmCheckPinnedUser *RepositoryMock) CheckPinnedUser(ctx context.Context, dp1 *gorm.DB, table string) (dp2 *gorm.DB) { + mm_atomic.AddUint64(&mmCheckPinnedUser.beforeCheckPinnedUserCounter, 1) + defer mm_atomic.AddUint64(&mmCheckPinnedUser.afterCheckPinnedUserCounter, 1) - mmAddPipelineClones.t.Helper() + mmCheckPinnedUser.t.Helper() - if mmAddPipelineClones.inspectFuncAddPipelineClones != nil { - mmAddPipelineClones.inspectFuncAddPipelineClones(ctx, uid) + if mmCheckPinnedUser.inspectFuncCheckPinnedUser != nil { + mmCheckPinnedUser.inspectFuncCheckPinnedUser(ctx, dp1, table) } - mm_params := RepositoryMockAddPipelineClonesParams{ctx, uid} + mm_params := RepositoryMockCheckPinnedUserParams{ctx, dp1, table} // Record call args - mmAddPipelineClones.AddPipelineClonesMock.mutex.Lock() - mmAddPipelineClones.AddPipelineClonesMock.callArgs = append(mmAddPipelineClones.AddPipelineClonesMock.callArgs, &mm_params) - mmAddPipelineClones.AddPipelineClonesMock.mutex.Unlock() + mmCheckPinnedUser.CheckPinnedUserMock.mutex.Lock() + mmCheckPinnedUser.CheckPinnedUserMock.callArgs = append(mmCheckPinnedUser.CheckPinnedUserMock.callArgs, &mm_params) + mmCheckPinnedUser.CheckPinnedUserMock.mutex.Unlock() - for _, e := range mmAddPipelineClones.AddPipelineClonesMock.expectations { + for _, e := range mmCheckPinnedUser.CheckPinnedUserMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.err + return e.results.dp2 } } - if mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.Counter, 1) - mm_want := mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.params - mm_want_ptrs := mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.paramPtrs + if mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.Counter, 1) + mm_want := mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.params + mm_want_ptrs := mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockAddPipelineClonesParams{ctx, uid} + mm_got := RepositoryMockCheckPinnedUserParams{ctx, dp1, table} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmAddPipelineClones.t.Errorf("RepositoryMock.AddPipelineClones got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { - mmAddPipelineClones.t.Errorf("RepositoryMock.AddPipelineClones got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) + if mm_want_ptrs.dp1 != nil && !minimock.Equal(*mm_want_ptrs.dp1, mm_got.dp1) { + mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameter dp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.originDp1, *mm_want_ptrs.dp1, mm_got.dp1, minimock.Diff(*mm_want_ptrs.dp1, mm_got.dp1)) + } + + if mm_want_ptrs.table != nil && !minimock.Equal(*mm_want_ptrs.table, mm_got.table) { + mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameter table, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.originTable, *mm_want_ptrs.table, mm_got.table, minimock.Diff(*mm_want_ptrs.table, mm_got.table)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmAddPipelineClones.t.Errorf("RepositoryMock.AddPipelineClones got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmAddPipelineClones.AddPipelineClonesMock.defaultExpectation.results + mm_results := mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.results if mm_results == nil { - mmAddPipelineClones.t.Fatal("No results are set for the RepositoryMock.AddPipelineClones") + mmCheckPinnedUser.t.Fatal("No results are set for the RepositoryMock.CheckPinnedUser") } - return (*mm_results).err + return (*mm_results).dp2 } - if mmAddPipelineClones.funcAddPipelineClones != nil { - return mmAddPipelineClones.funcAddPipelineClones(ctx, uid) + if mmCheckPinnedUser.funcCheckPinnedUser != nil { + return mmCheckPinnedUser.funcCheckPinnedUser(ctx, dp1, table) } - mmAddPipelineClones.t.Fatalf("Unexpected call to RepositoryMock.AddPipelineClones. %v %v", ctx, uid) + mmCheckPinnedUser.t.Fatalf("Unexpected call to RepositoryMock.CheckPinnedUser. %v %v %v", ctx, dp1, table) return } -// AddPipelineClonesAfterCounter returns a count of finished RepositoryMock.AddPipelineClones invocations -func (mmAddPipelineClones *RepositoryMock) AddPipelineClonesAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmAddPipelineClones.afterAddPipelineClonesCounter) +// CheckPinnedUserAfterCounter returns a count of finished RepositoryMock.CheckPinnedUser invocations +func (mmCheckPinnedUser *RepositoryMock) CheckPinnedUserAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCheckPinnedUser.afterCheckPinnedUserCounter) } -// AddPipelineClonesBeforeCounter returns a count of RepositoryMock.AddPipelineClones invocations -func (mmAddPipelineClones *RepositoryMock) AddPipelineClonesBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmAddPipelineClones.beforeAddPipelineClonesCounter) +// CheckPinnedUserBeforeCounter returns a count of RepositoryMock.CheckPinnedUser invocations +func (mmCheckPinnedUser *RepositoryMock) CheckPinnedUserBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCheckPinnedUser.beforeCheckPinnedUserCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.AddPipelineClones. +// Calls returns a list of arguments used in each call to RepositoryMock.CheckPinnedUser. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmAddPipelineClones *mRepositoryMockAddPipelineClones) Calls() []*RepositoryMockAddPipelineClonesParams { - mmAddPipelineClones.mutex.RLock() +func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Calls() []*RepositoryMockCheckPinnedUserParams { + mmCheckPinnedUser.mutex.RLock() - argCopy := make([]*RepositoryMockAddPipelineClonesParams, len(mmAddPipelineClones.callArgs)) - copy(argCopy, mmAddPipelineClones.callArgs) + argCopy := make([]*RepositoryMockCheckPinnedUserParams, len(mmCheckPinnedUser.callArgs)) + copy(argCopy, mmCheckPinnedUser.callArgs) - mmAddPipelineClones.mutex.RUnlock() + mmCheckPinnedUser.mutex.RUnlock() return argCopy } -// MinimockAddPipelineClonesDone returns true if the count of the AddPipelineClones invocations corresponds +// MinimockCheckPinnedUserDone returns true if the count of the CheckPinnedUser invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockAddPipelineClonesDone() bool { - if m.AddPipelineClonesMock.optional { +func (m *RepositoryMock) MinimockCheckPinnedUserDone() bool { + if m.CheckPinnedUserMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.AddPipelineClonesMock.expectations { + for _, e := range m.CheckPinnedUserMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.AddPipelineClonesMock.invocationsDone() + return m.CheckPinnedUserMock.invocationsDone() } -// MinimockAddPipelineClonesInspect logs each unmet expectation -func (m *RepositoryMock) MinimockAddPipelineClonesInspect() { - for _, e := range m.AddPipelineClonesMock.expectations { +// MinimockCheckPinnedUserInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCheckPinnedUserInspect() { + for _, e := range m.CheckPinnedUserMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineClones at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterAddPipelineClonesCounter := mm_atomic.LoadUint64(&m.afterAddPipelineClonesCounter) + afterCheckPinnedUserCounter := mm_atomic.LoadUint64(&m.afterCheckPinnedUserCounter) // if default expectation was set then invocations count should be greater than zero - if m.AddPipelineClonesMock.defaultExpectation != nil && afterAddPipelineClonesCounter < 1 { - if m.AddPipelineClonesMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineClones at\n%s", m.AddPipelineClonesMock.defaultExpectation.returnOrigin) + if m.CheckPinnedUserMock.defaultExpectation != nil && afterCheckPinnedUserCounter < 1 { + if m.CheckPinnedUserMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s", m.CheckPinnedUserMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineClones at\n%s with params: %#v", m.AddPipelineClonesMock.defaultExpectation.expectationOrigins.origin, *m.AddPipelineClonesMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s with params: %#v", m.CheckPinnedUserMock.defaultExpectation.expectationOrigins.origin, *m.CheckPinnedUserMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcAddPipelineClones != nil && afterAddPipelineClonesCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineClones at\n%s", m.funcAddPipelineClonesOrigin) + if m.funcCheckPinnedUser != nil && afterCheckPinnedUserCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s", m.funcCheckPinnedUserOrigin) } - if !m.AddPipelineClonesMock.invocationsDone() && afterAddPipelineClonesCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.AddPipelineClones at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.AddPipelineClonesMock.expectedInvocations), m.AddPipelineClonesMock.expectedInvocationsOrigin, afterAddPipelineClonesCounter) + if !m.CheckPinnedUserMock.invocationsDone() && afterCheckPinnedUserCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CheckPinnedUser at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CheckPinnedUserMock.expectedInvocations), m.CheckPinnedUserMock.expectedInvocationsOrigin, afterCheckPinnedUserCounter) } } -type mRepositoryMockAddPipelineRuns struct { +type mRepositoryMockCreateNamespaceConnection struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockAddPipelineRunsExpectation - expectations []*RepositoryMockAddPipelineRunsExpectation + defaultExpectation *RepositoryMockCreateNamespaceConnectionExpectation + expectations []*RepositoryMockCreateNamespaceConnectionExpectation - callArgs []*RepositoryMockAddPipelineRunsParams + callArgs []*RepositoryMockCreateNamespaceConnectionParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockAddPipelineRunsExpectation specifies expectation struct of the Repository.AddPipelineRuns -type RepositoryMockAddPipelineRunsExpectation struct { +// RepositoryMockCreateNamespaceConnectionExpectation specifies expectation struct of the Repository.CreateNamespaceConnection +type RepositoryMockCreateNamespaceConnectionExpectation struct { mock *RepositoryMock - params *RepositoryMockAddPipelineRunsParams - paramPtrs *RepositoryMockAddPipelineRunsParamPtrs - expectationOrigins RepositoryMockAddPipelineRunsExpectationOrigins - results *RepositoryMockAddPipelineRunsResults + params *RepositoryMockCreateNamespaceConnectionParams + paramPtrs *RepositoryMockCreateNamespaceConnectionParamPtrs + expectationOrigins RepositoryMockCreateNamespaceConnectionExpectationOrigins + results *RepositoryMockCreateNamespaceConnectionResults returnOrigin string Counter uint64 } -// RepositoryMockAddPipelineRunsParams contains parameters of the Repository.AddPipelineRuns -type RepositoryMockAddPipelineRunsParams struct { +// RepositoryMockCreateNamespaceConnectionParams contains parameters of the Repository.CreateNamespaceConnection +type RepositoryMockCreateNamespaceConnectionParams struct { ctx context.Context - uid uuid.UUID + cp1 *datamodel.Connection } -// RepositoryMockAddPipelineRunsParamPtrs contains pointers to parameters of the Repository.AddPipelineRuns -type RepositoryMockAddPipelineRunsParamPtrs struct { +// RepositoryMockCreateNamespaceConnectionParamPtrs contains pointers to parameters of the Repository.CreateNamespaceConnection +type RepositoryMockCreateNamespaceConnectionParamPtrs struct { ctx *context.Context - uid *uuid.UUID + cp1 **datamodel.Connection } -// RepositoryMockAddPipelineRunsResults contains results of the Repository.AddPipelineRuns -type RepositoryMockAddPipelineRunsResults struct { +// RepositoryMockCreateNamespaceConnectionResults contains results of the Repository.CreateNamespaceConnection +type RepositoryMockCreateNamespaceConnectionResults struct { + cp2 *datamodel.Connection err error } -// RepositoryMockAddPipelineRunsOrigins contains origins of expectations of the Repository.AddPipelineRuns -type RepositoryMockAddPipelineRunsExpectationOrigins struct { +// RepositoryMockCreateNamespaceConnectionOrigins contains origins of expectations of the Repository.CreateNamespaceConnection +type RepositoryMockCreateNamespaceConnectionExpectationOrigins struct { origin string originCtx string - originUid string + originCp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -984,344 +1016,341 @@ type RepositoryMockAddPipelineRunsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Optional() *mRepositoryMockAddPipelineRuns { - mmAddPipelineRuns.optional = true - return mmAddPipelineRuns +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Optional() *mRepositoryMockCreateNamespaceConnection { + mmCreateNamespaceConnection.optional = true + return mmCreateNamespaceConnection } -// Expect sets up expected params for Repository.AddPipelineRuns -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Expect(ctx context.Context, uid uuid.UUID) *mRepositoryMockAddPipelineRuns { - if mmAddPipelineRuns.mock.funcAddPipelineRuns != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Set") - } - - if mmAddPipelineRuns.defaultExpectation == nil { - mmAddPipelineRuns.defaultExpectation = &RepositoryMockAddPipelineRunsExpectation{} +// Expect sets up expected params for Repository.CreateNamespaceConnection +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Expect(ctx context.Context, cp1 *datamodel.Connection) *mRepositoryMockCreateNamespaceConnection { + if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") + } + + if mmCreateNamespaceConnection.defaultExpectation == nil { + mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{} } - if mmAddPipelineRuns.defaultExpectation.paramPtrs != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by ExpectParams functions") + if mmCreateNamespaceConnection.defaultExpectation.paramPtrs != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by ExpectParams functions") } - mmAddPipelineRuns.defaultExpectation.params = &RepositoryMockAddPipelineRunsParams{ctx, uid} - mmAddPipelineRuns.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmAddPipelineRuns.expectations { - if minimock.Equal(e.params, mmAddPipelineRuns.defaultExpectation.params) { - mmAddPipelineRuns.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAddPipelineRuns.defaultExpectation.params) + mmCreateNamespaceConnection.defaultExpectation.params = &RepositoryMockCreateNamespaceConnectionParams{ctx, cp1} + mmCreateNamespaceConnection.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreateNamespaceConnection.expectations { + if minimock.Equal(e.params, mmCreateNamespaceConnection.defaultExpectation.params) { + mmCreateNamespaceConnection.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespaceConnection.defaultExpectation.params) } } - return mmAddPipelineRuns + return mmCreateNamespaceConnection } -// ExpectCtxParam1 sets up expected param ctx for Repository.AddPipelineRuns -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) ExpectCtxParam1(ctx context.Context) *mRepositoryMockAddPipelineRuns { - if mmAddPipelineRuns.mock.funcAddPipelineRuns != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespaceConnection +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespaceConnection { + if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") } - if mmAddPipelineRuns.defaultExpectation == nil { - mmAddPipelineRuns.defaultExpectation = &RepositoryMockAddPipelineRunsExpectation{} + if mmCreateNamespaceConnection.defaultExpectation == nil { + mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{} } - if mmAddPipelineRuns.defaultExpectation.params != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Expect") + if mmCreateNamespaceConnection.defaultExpectation.params != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Expect") } - if mmAddPipelineRuns.defaultExpectation.paramPtrs == nil { - mmAddPipelineRuns.defaultExpectation.paramPtrs = &RepositoryMockAddPipelineRunsParamPtrs{} + if mmCreateNamespaceConnection.defaultExpectation.paramPtrs == nil { + mmCreateNamespaceConnection.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceConnectionParamPtrs{} } - mmAddPipelineRuns.defaultExpectation.paramPtrs.ctx = &ctx - mmAddPipelineRuns.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmCreateNamespaceConnection.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateNamespaceConnection.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmAddPipelineRuns + return mmCreateNamespaceConnection } -// ExpectUidParam2 sets up expected param uid for Repository.AddPipelineRuns -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockAddPipelineRuns { - if mmAddPipelineRuns.mock.funcAddPipelineRuns != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Set") +// ExpectCp1Param2 sets up expected param cp1 for Repository.CreateNamespaceConnection +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) ExpectCp1Param2(cp1 *datamodel.Connection) *mRepositoryMockCreateNamespaceConnection { + if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") } - if mmAddPipelineRuns.defaultExpectation == nil { - mmAddPipelineRuns.defaultExpectation = &RepositoryMockAddPipelineRunsExpectation{} + if mmCreateNamespaceConnection.defaultExpectation == nil { + mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{} } - if mmAddPipelineRuns.defaultExpectation.params != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Expect") + if mmCreateNamespaceConnection.defaultExpectation.params != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Expect") } - if mmAddPipelineRuns.defaultExpectation.paramPtrs == nil { - mmAddPipelineRuns.defaultExpectation.paramPtrs = &RepositoryMockAddPipelineRunsParamPtrs{} + if mmCreateNamespaceConnection.defaultExpectation.paramPtrs == nil { + mmCreateNamespaceConnection.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceConnectionParamPtrs{} } - mmAddPipelineRuns.defaultExpectation.paramPtrs.uid = &uid - mmAddPipelineRuns.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) + mmCreateNamespaceConnection.defaultExpectation.paramPtrs.cp1 = &cp1 + mmCreateNamespaceConnection.defaultExpectation.expectationOrigins.originCp1 = minimock.CallerInfo(1) - return mmAddPipelineRuns + return mmCreateNamespaceConnection } -// Inspect accepts an inspector function that has same arguments as the Repository.AddPipelineRuns -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Inspect(f func(ctx context.Context, uid uuid.UUID)) *mRepositoryMockAddPipelineRuns { - if mmAddPipelineRuns.mock.inspectFuncAddPipelineRuns != nil { - mmAddPipelineRuns.mock.t.Fatalf("Inspect function is already set for RepositoryMock.AddPipelineRuns") +// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespaceConnection +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Inspect(f func(ctx context.Context, cp1 *datamodel.Connection)) *mRepositoryMockCreateNamespaceConnection { + if mmCreateNamespaceConnection.mock.inspectFuncCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespaceConnection") } - mmAddPipelineRuns.mock.inspectFuncAddPipelineRuns = f + mmCreateNamespaceConnection.mock.inspectFuncCreateNamespaceConnection = f - return mmAddPipelineRuns + return mmCreateNamespaceConnection } -// Return sets up results that will be returned by Repository.AddPipelineRuns -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Return(err error) *RepositoryMock { - if mmAddPipelineRuns.mock.funcAddPipelineRuns != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Set") +// Return sets up results that will be returned by Repository.CreateNamespaceConnection +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Return(cp2 *datamodel.Connection, err error) *RepositoryMock { + if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") } - if mmAddPipelineRuns.defaultExpectation == nil { - mmAddPipelineRuns.defaultExpectation = &RepositoryMockAddPipelineRunsExpectation{mock: mmAddPipelineRuns.mock} + if mmCreateNamespaceConnection.defaultExpectation == nil { + mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{mock: mmCreateNamespaceConnection.mock} } - mmAddPipelineRuns.defaultExpectation.results = &RepositoryMockAddPipelineRunsResults{err} - mmAddPipelineRuns.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmAddPipelineRuns.mock + mmCreateNamespaceConnection.defaultExpectation.results = &RepositoryMockCreateNamespaceConnectionResults{cp2, err} + mmCreateNamespaceConnection.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreateNamespaceConnection.mock } -// Set uses given function f to mock the Repository.AddPipelineRuns method -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Set(f func(ctx context.Context, uid uuid.UUID) (err error)) *RepositoryMock { - if mmAddPipelineRuns.defaultExpectation != nil { - mmAddPipelineRuns.mock.t.Fatalf("Default expectation is already set for the Repository.AddPipelineRuns method") +// Set uses given function f to mock the Repository.CreateNamespaceConnection method +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Set(f func(ctx context.Context, cp1 *datamodel.Connection) (cp2 *datamodel.Connection, err error)) *RepositoryMock { + if mmCreateNamespaceConnection.defaultExpectation != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespaceConnection method") } - if len(mmAddPipelineRuns.expectations) > 0 { - mmAddPipelineRuns.mock.t.Fatalf("Some expectations are already set for the Repository.AddPipelineRuns method") + if len(mmCreateNamespaceConnection.expectations) > 0 { + mmCreateNamespaceConnection.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespaceConnection method") } - mmAddPipelineRuns.mock.funcAddPipelineRuns = f - mmAddPipelineRuns.mock.funcAddPipelineRunsOrigin = minimock.CallerInfo(1) - return mmAddPipelineRuns.mock + mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection = f + mmCreateNamespaceConnection.mock.funcCreateNamespaceConnectionOrigin = minimock.CallerInfo(1) + return mmCreateNamespaceConnection.mock } -// When sets expectation for the Repository.AddPipelineRuns which will trigger the result defined by the following +// When sets expectation for the Repository.CreateNamespaceConnection which will trigger the result defined by the following // Then helper -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) When(ctx context.Context, uid uuid.UUID) *RepositoryMockAddPipelineRunsExpectation { - if mmAddPipelineRuns.mock.funcAddPipelineRuns != nil { - mmAddPipelineRuns.mock.t.Fatalf("RepositoryMock.AddPipelineRuns mock is already set by Set") +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) When(ctx context.Context, cp1 *datamodel.Connection) *RepositoryMockCreateNamespaceConnectionExpectation { + if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") } - expectation := &RepositoryMockAddPipelineRunsExpectation{ - mock: mmAddPipelineRuns.mock, - params: &RepositoryMockAddPipelineRunsParams{ctx, uid}, - expectationOrigins: RepositoryMockAddPipelineRunsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockCreateNamespaceConnectionExpectation{ + mock: mmCreateNamespaceConnection.mock, + params: &RepositoryMockCreateNamespaceConnectionParams{ctx, cp1}, + expectationOrigins: RepositoryMockCreateNamespaceConnectionExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmAddPipelineRuns.expectations = append(mmAddPipelineRuns.expectations, expectation) + mmCreateNamespaceConnection.expectations = append(mmCreateNamespaceConnection.expectations, expectation) return expectation } -// Then sets up Repository.AddPipelineRuns return parameters for the expectation previously defined by the When method -func (e *RepositoryMockAddPipelineRunsExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockAddPipelineRunsResults{err} +// Then sets up Repository.CreateNamespaceConnection return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCreateNamespaceConnectionExpectation) Then(cp2 *datamodel.Connection, err error) *RepositoryMock { + e.results = &RepositoryMockCreateNamespaceConnectionResults{cp2, err} return e.mock } -// Times sets number of times Repository.AddPipelineRuns should be invoked -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Times(n uint64) *mRepositoryMockAddPipelineRuns { +// Times sets number of times Repository.CreateNamespaceConnection should be invoked +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Times(n uint64) *mRepositoryMockCreateNamespaceConnection { if n == 0 { - mmAddPipelineRuns.mock.t.Fatalf("Times of RepositoryMock.AddPipelineRuns mock can not be zero") + mmCreateNamespaceConnection.mock.t.Fatalf("Times of RepositoryMock.CreateNamespaceConnection mock can not be zero") } - mm_atomic.StoreUint64(&mmAddPipelineRuns.expectedInvocations, n) - mmAddPipelineRuns.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmAddPipelineRuns + mm_atomic.StoreUint64(&mmCreateNamespaceConnection.expectedInvocations, n) + mmCreateNamespaceConnection.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreateNamespaceConnection } -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) invocationsDone() bool { - if len(mmAddPipelineRuns.expectations) == 0 && mmAddPipelineRuns.defaultExpectation == nil && mmAddPipelineRuns.mock.funcAddPipelineRuns == nil { +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) invocationsDone() bool { + if len(mmCreateNamespaceConnection.expectations) == 0 && mmCreateNamespaceConnection.defaultExpectation == nil && mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmAddPipelineRuns.mock.afterAddPipelineRunsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmAddPipelineRuns.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceConnection.mock.afterCreateNamespaceConnectionCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceConnection.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// AddPipelineRuns implements mm_repository.Repository -func (mmAddPipelineRuns *RepositoryMock) AddPipelineRuns(ctx context.Context, uid uuid.UUID) (err error) { - mm_atomic.AddUint64(&mmAddPipelineRuns.beforeAddPipelineRunsCounter, 1) - defer mm_atomic.AddUint64(&mmAddPipelineRuns.afterAddPipelineRunsCounter, 1) +// CreateNamespaceConnection implements mm_repository.Repository +func (mmCreateNamespaceConnection *RepositoryMock) CreateNamespaceConnection(ctx context.Context, cp1 *datamodel.Connection) (cp2 *datamodel.Connection, err error) { + mm_atomic.AddUint64(&mmCreateNamespaceConnection.beforeCreateNamespaceConnectionCounter, 1) + defer mm_atomic.AddUint64(&mmCreateNamespaceConnection.afterCreateNamespaceConnectionCounter, 1) - mmAddPipelineRuns.t.Helper() + mmCreateNamespaceConnection.t.Helper() - if mmAddPipelineRuns.inspectFuncAddPipelineRuns != nil { - mmAddPipelineRuns.inspectFuncAddPipelineRuns(ctx, uid) + if mmCreateNamespaceConnection.inspectFuncCreateNamespaceConnection != nil { + mmCreateNamespaceConnection.inspectFuncCreateNamespaceConnection(ctx, cp1) } - mm_params := RepositoryMockAddPipelineRunsParams{ctx, uid} + mm_params := RepositoryMockCreateNamespaceConnectionParams{ctx, cp1} // Record call args - mmAddPipelineRuns.AddPipelineRunsMock.mutex.Lock() - mmAddPipelineRuns.AddPipelineRunsMock.callArgs = append(mmAddPipelineRuns.AddPipelineRunsMock.callArgs, &mm_params) - mmAddPipelineRuns.AddPipelineRunsMock.mutex.Unlock() + mmCreateNamespaceConnection.CreateNamespaceConnectionMock.mutex.Lock() + mmCreateNamespaceConnection.CreateNamespaceConnectionMock.callArgs = append(mmCreateNamespaceConnection.CreateNamespaceConnectionMock.callArgs, &mm_params) + mmCreateNamespaceConnection.CreateNamespaceConnectionMock.mutex.Unlock() - for _, e := range mmAddPipelineRuns.AddPipelineRunsMock.expectations { + for _, e := range mmCreateNamespaceConnection.CreateNamespaceConnectionMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.err + return e.results.cp2, e.results.err } } - if mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.Counter, 1) - mm_want := mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.params - mm_want_ptrs := mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.paramPtrs + if mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.Counter, 1) + mm_want := mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.params + mm_want_ptrs := mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockAddPipelineRunsParams{ctx, uid} + mm_got := RepositoryMockCreateNamespaceConnectionParams{ctx, cp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmAddPipelineRuns.t.Errorf("RepositoryMock.AddPipelineRuns got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateNamespaceConnection.t.Errorf("RepositoryMock.CreateNamespaceConnection got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { - mmAddPipelineRuns.t.Errorf("RepositoryMock.AddPipelineRuns got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) + if mm_want_ptrs.cp1 != nil && !minimock.Equal(*mm_want_ptrs.cp1, mm_got.cp1) { + mmCreateNamespaceConnection.t.Errorf("RepositoryMock.CreateNamespaceConnection got unexpected parameter cp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.originCp1, *mm_want_ptrs.cp1, mm_got.cp1, minimock.Diff(*mm_want_ptrs.cp1, mm_got.cp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmAddPipelineRuns.t.Errorf("RepositoryMock.AddPipelineRuns got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateNamespaceConnection.t.Errorf("RepositoryMock.CreateNamespaceConnection got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmAddPipelineRuns.AddPipelineRunsMock.defaultExpectation.results + mm_results := mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.results if mm_results == nil { - mmAddPipelineRuns.t.Fatal("No results are set for the RepositoryMock.AddPipelineRuns") + mmCreateNamespaceConnection.t.Fatal("No results are set for the RepositoryMock.CreateNamespaceConnection") } - return (*mm_results).err + return (*mm_results).cp2, (*mm_results).err } - if mmAddPipelineRuns.funcAddPipelineRuns != nil { - return mmAddPipelineRuns.funcAddPipelineRuns(ctx, uid) + if mmCreateNamespaceConnection.funcCreateNamespaceConnection != nil { + return mmCreateNamespaceConnection.funcCreateNamespaceConnection(ctx, cp1) } - mmAddPipelineRuns.t.Fatalf("Unexpected call to RepositoryMock.AddPipelineRuns. %v %v", ctx, uid) + mmCreateNamespaceConnection.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespaceConnection. %v %v", ctx, cp1) return } -// AddPipelineRunsAfterCounter returns a count of finished RepositoryMock.AddPipelineRuns invocations -func (mmAddPipelineRuns *RepositoryMock) AddPipelineRunsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmAddPipelineRuns.afterAddPipelineRunsCounter) +// CreateNamespaceConnectionAfterCounter returns a count of finished RepositoryMock.CreateNamespaceConnection invocations +func (mmCreateNamespaceConnection *RepositoryMock) CreateNamespaceConnectionAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespaceConnection.afterCreateNamespaceConnectionCounter) } -// AddPipelineRunsBeforeCounter returns a count of RepositoryMock.AddPipelineRuns invocations -func (mmAddPipelineRuns *RepositoryMock) AddPipelineRunsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmAddPipelineRuns.beforeAddPipelineRunsCounter) +// CreateNamespaceConnectionBeforeCounter returns a count of RepositoryMock.CreateNamespaceConnection invocations +func (mmCreateNamespaceConnection *RepositoryMock) CreateNamespaceConnectionBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespaceConnection.beforeCreateNamespaceConnectionCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.AddPipelineRuns. +// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespaceConnection. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmAddPipelineRuns *mRepositoryMockAddPipelineRuns) Calls() []*RepositoryMockAddPipelineRunsParams { - mmAddPipelineRuns.mutex.RLock() +func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Calls() []*RepositoryMockCreateNamespaceConnectionParams { + mmCreateNamespaceConnection.mutex.RLock() - argCopy := make([]*RepositoryMockAddPipelineRunsParams, len(mmAddPipelineRuns.callArgs)) - copy(argCopy, mmAddPipelineRuns.callArgs) + argCopy := make([]*RepositoryMockCreateNamespaceConnectionParams, len(mmCreateNamespaceConnection.callArgs)) + copy(argCopy, mmCreateNamespaceConnection.callArgs) - mmAddPipelineRuns.mutex.RUnlock() + mmCreateNamespaceConnection.mutex.RUnlock() return argCopy } -// MinimockAddPipelineRunsDone returns true if the count of the AddPipelineRuns invocations corresponds +// MinimockCreateNamespaceConnectionDone returns true if the count of the CreateNamespaceConnection invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockAddPipelineRunsDone() bool { - if m.AddPipelineRunsMock.optional { +func (m *RepositoryMock) MinimockCreateNamespaceConnectionDone() bool { + if m.CreateNamespaceConnectionMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.AddPipelineRunsMock.expectations { + for _, e := range m.CreateNamespaceConnectionMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.AddPipelineRunsMock.invocationsDone() + return m.CreateNamespaceConnectionMock.invocationsDone() } -// MinimockAddPipelineRunsInspect logs each unmet expectation -func (m *RepositoryMock) MinimockAddPipelineRunsInspect() { - for _, e := range m.AddPipelineRunsMock.expectations { +// MinimockCreateNamespaceConnectionInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCreateNamespaceConnectionInspect() { + for _, e := range m.CreateNamespaceConnectionMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineRuns at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterAddPipelineRunsCounter := mm_atomic.LoadUint64(&m.afterAddPipelineRunsCounter) + afterCreateNamespaceConnectionCounter := mm_atomic.LoadUint64(&m.afterCreateNamespaceConnectionCounter) // if default expectation was set then invocations count should be greater than zero - if m.AddPipelineRunsMock.defaultExpectation != nil && afterAddPipelineRunsCounter < 1 { - if m.AddPipelineRunsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineRuns at\n%s", m.AddPipelineRunsMock.defaultExpectation.returnOrigin) + if m.CreateNamespaceConnectionMock.defaultExpectation != nil && afterCreateNamespaceConnectionCounter < 1 { + if m.CreateNamespaceConnectionMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s", m.CreateNamespaceConnectionMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineRuns at\n%s with params: %#v", m.AddPipelineRunsMock.defaultExpectation.expectationOrigins.origin, *m.AddPipelineRunsMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s with params: %#v", m.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespaceConnectionMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcAddPipelineRuns != nil && afterAddPipelineRunsCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.AddPipelineRuns at\n%s", m.funcAddPipelineRunsOrigin) + if m.funcCreateNamespaceConnection != nil && afterCreateNamespaceConnectionCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s", m.funcCreateNamespaceConnectionOrigin) } - if !m.AddPipelineRunsMock.invocationsDone() && afterAddPipelineRunsCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.AddPipelineRuns at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.AddPipelineRunsMock.expectedInvocations), m.AddPipelineRunsMock.expectedInvocationsOrigin, afterAddPipelineRunsCounter) + if !m.CreateNamespaceConnectionMock.invocationsDone() && afterCreateNamespaceConnectionCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespaceConnection at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateNamespaceConnectionMock.expectedInvocations), m.CreateNamespaceConnectionMock.expectedInvocationsOrigin, afterCreateNamespaceConnectionCounter) } } -type mRepositoryMockCheckPinnedUser struct { +type mRepositoryMockCreateNamespacePipeline struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCheckPinnedUserExpectation - expectations []*RepositoryMockCheckPinnedUserExpectation + defaultExpectation *RepositoryMockCreateNamespacePipelineExpectation + expectations []*RepositoryMockCreateNamespacePipelineExpectation - callArgs []*RepositoryMockCheckPinnedUserParams + callArgs []*RepositoryMockCreateNamespacePipelineParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCheckPinnedUserExpectation specifies expectation struct of the Repository.CheckPinnedUser -type RepositoryMockCheckPinnedUserExpectation struct { +// RepositoryMockCreateNamespacePipelineExpectation specifies expectation struct of the Repository.CreateNamespacePipeline +type RepositoryMockCreateNamespacePipelineExpectation struct { mock *RepositoryMock - params *RepositoryMockCheckPinnedUserParams - paramPtrs *RepositoryMockCheckPinnedUserParamPtrs - expectationOrigins RepositoryMockCheckPinnedUserExpectationOrigins - results *RepositoryMockCheckPinnedUserResults + params *RepositoryMockCreateNamespacePipelineParams + paramPtrs *RepositoryMockCreateNamespacePipelineParamPtrs + expectationOrigins RepositoryMockCreateNamespacePipelineExpectationOrigins + results *RepositoryMockCreateNamespacePipelineResults returnOrigin string Counter uint64 } -// RepositoryMockCheckPinnedUserParams contains parameters of the Repository.CheckPinnedUser -type RepositoryMockCheckPinnedUserParams struct { - ctx context.Context - dp1 *gorm.DB - table string +// RepositoryMockCreateNamespacePipelineParams contains parameters of the Repository.CreateNamespacePipeline +type RepositoryMockCreateNamespacePipelineParams struct { + ctx context.Context + pipeline *datamodel.Pipeline } -// RepositoryMockCheckPinnedUserParamPtrs contains pointers to parameters of the Repository.CheckPinnedUser -type RepositoryMockCheckPinnedUserParamPtrs struct { - ctx *context.Context - dp1 **gorm.DB - table *string +// RepositoryMockCreateNamespacePipelineParamPtrs contains pointers to parameters of the Repository.CreateNamespacePipeline +type RepositoryMockCreateNamespacePipelineParamPtrs struct { + ctx *context.Context + pipeline **datamodel.Pipeline } -// RepositoryMockCheckPinnedUserResults contains results of the Repository.CheckPinnedUser -type RepositoryMockCheckPinnedUserResults struct { - dp2 *gorm.DB +// RepositoryMockCreateNamespacePipelineResults contains results of the Repository.CreateNamespacePipeline +type RepositoryMockCreateNamespacePipelineResults struct { + err error } -// RepositoryMockCheckPinnedUserOrigins contains origins of expectations of the Repository.CheckPinnedUser -type RepositoryMockCheckPinnedUserExpectationOrigins struct { - origin string - originCtx string - originDp1 string - originTable string +// RepositoryMockCreateNamespacePipelineOrigins contains origins of expectations of the Repository.CreateNamespacePipeline +type RepositoryMockCreateNamespacePipelineExpectationOrigins struct { + origin string + originCtx string + originPipeline string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -1329,370 +1358,347 @@ type RepositoryMockCheckPinnedUserExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Optional() *mRepositoryMockCheckPinnedUser { - mmCheckPinnedUser.optional = true - return mmCheckPinnedUser +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Optional() *mRepositoryMockCreateNamespacePipeline { + mmCreateNamespacePipeline.optional = true + return mmCreateNamespacePipeline } -// Expect sets up expected params for Repository.CheckPinnedUser -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Expect(ctx context.Context, dp1 *gorm.DB, table string) *mRepositoryMockCheckPinnedUser { - if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") +// Expect sets up expected params for Repository.CreateNamespacePipeline +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Expect(ctx context.Context, pipeline *datamodel.Pipeline) *mRepositoryMockCreateNamespacePipeline { + if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") } - if mmCheckPinnedUser.defaultExpectation == nil { - mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} + if mmCreateNamespacePipeline.defaultExpectation == nil { + mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{} } - if mmCheckPinnedUser.defaultExpectation.paramPtrs != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by ExpectParams functions") + if mmCreateNamespacePipeline.defaultExpectation.paramPtrs != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by ExpectParams functions") } - mmCheckPinnedUser.defaultExpectation.params = &RepositoryMockCheckPinnedUserParams{ctx, dp1, table} - mmCheckPinnedUser.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCheckPinnedUser.expectations { - if minimock.Equal(e.params, mmCheckPinnedUser.defaultExpectation.params) { - mmCheckPinnedUser.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckPinnedUser.defaultExpectation.params) + mmCreateNamespacePipeline.defaultExpectation.params = &RepositoryMockCreateNamespacePipelineParams{ctx, pipeline} + mmCreateNamespacePipeline.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreateNamespacePipeline.expectations { + if minimock.Equal(e.params, mmCreateNamespacePipeline.defaultExpectation.params) { + mmCreateNamespacePipeline.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespacePipeline.defaultExpectation.params) } } - return mmCheckPinnedUser + return mmCreateNamespacePipeline } -// ExpectCtxParam1 sets up expected param ctx for Repository.CheckPinnedUser -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCheckPinnedUser { - if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespacePipeline +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespacePipeline { + if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") } - if mmCheckPinnedUser.defaultExpectation == nil { - mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} + if mmCreateNamespacePipeline.defaultExpectation == nil { + mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{} } - if mmCheckPinnedUser.defaultExpectation.params != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Expect") - } - - if mmCheckPinnedUser.defaultExpectation.paramPtrs == nil { - mmCheckPinnedUser.defaultExpectation.paramPtrs = &RepositoryMockCheckPinnedUserParamPtrs{} - } - mmCheckPinnedUser.defaultExpectation.paramPtrs.ctx = &ctx - mmCheckPinnedUser.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmCheckPinnedUser -} - -// ExpectDp1Param2 sets up expected param dp1 for Repository.CheckPinnedUser -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) ExpectDp1Param2(dp1 *gorm.DB) *mRepositoryMockCheckPinnedUser { - if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") - } - - if mmCheckPinnedUser.defaultExpectation == nil { - mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} - } - - if mmCheckPinnedUser.defaultExpectation.params != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Expect") + if mmCreateNamespacePipeline.defaultExpectation.params != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Expect") } - if mmCheckPinnedUser.defaultExpectation.paramPtrs == nil { - mmCheckPinnedUser.defaultExpectation.paramPtrs = &RepositoryMockCheckPinnedUserParamPtrs{} + if mmCreateNamespacePipeline.defaultExpectation.paramPtrs == nil { + mmCreateNamespacePipeline.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineParamPtrs{} } - mmCheckPinnedUser.defaultExpectation.paramPtrs.dp1 = &dp1 - mmCheckPinnedUser.defaultExpectation.expectationOrigins.originDp1 = minimock.CallerInfo(1) + mmCreateNamespacePipeline.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateNamespacePipeline.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCheckPinnedUser + return mmCreateNamespacePipeline } -// ExpectTableParam3 sets up expected param table for Repository.CheckPinnedUser -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) ExpectTableParam3(table string) *mRepositoryMockCheckPinnedUser { - if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") +// ExpectPipelineParam2 sets up expected param pipeline for Repository.CreateNamespacePipeline +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) ExpectPipelineParam2(pipeline *datamodel.Pipeline) *mRepositoryMockCreateNamespacePipeline { + if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") } - if mmCheckPinnedUser.defaultExpectation == nil { - mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{} + if mmCreateNamespacePipeline.defaultExpectation == nil { + mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{} } - if mmCheckPinnedUser.defaultExpectation.params != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Expect") + if mmCreateNamespacePipeline.defaultExpectation.params != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Expect") } - if mmCheckPinnedUser.defaultExpectation.paramPtrs == nil { - mmCheckPinnedUser.defaultExpectation.paramPtrs = &RepositoryMockCheckPinnedUserParamPtrs{} + if mmCreateNamespacePipeline.defaultExpectation.paramPtrs == nil { + mmCreateNamespacePipeline.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineParamPtrs{} } - mmCheckPinnedUser.defaultExpectation.paramPtrs.table = &table - mmCheckPinnedUser.defaultExpectation.expectationOrigins.originTable = minimock.CallerInfo(1) + mmCreateNamespacePipeline.defaultExpectation.paramPtrs.pipeline = &pipeline + mmCreateNamespacePipeline.defaultExpectation.expectationOrigins.originPipeline = minimock.CallerInfo(1) - return mmCheckPinnedUser + return mmCreateNamespacePipeline } -// Inspect accepts an inspector function that has same arguments as the Repository.CheckPinnedUser -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Inspect(f func(ctx context.Context, dp1 *gorm.DB, table string)) *mRepositoryMockCheckPinnedUser { - if mmCheckPinnedUser.mock.inspectFuncCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CheckPinnedUser") +// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespacePipeline +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Inspect(f func(ctx context.Context, pipeline *datamodel.Pipeline)) *mRepositoryMockCreateNamespacePipeline { + if mmCreateNamespacePipeline.mock.inspectFuncCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespacePipeline") } - mmCheckPinnedUser.mock.inspectFuncCheckPinnedUser = f + mmCreateNamespacePipeline.mock.inspectFuncCreateNamespacePipeline = f - return mmCheckPinnedUser + return mmCreateNamespacePipeline } -// Return sets up results that will be returned by Repository.CheckPinnedUser -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Return(dp2 *gorm.DB) *RepositoryMock { - if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") +// Return sets up results that will be returned by Repository.CreateNamespacePipeline +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Return(err error) *RepositoryMock { + if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") } - if mmCheckPinnedUser.defaultExpectation == nil { - mmCheckPinnedUser.defaultExpectation = &RepositoryMockCheckPinnedUserExpectation{mock: mmCheckPinnedUser.mock} + if mmCreateNamespacePipeline.defaultExpectation == nil { + mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{mock: mmCreateNamespacePipeline.mock} } - mmCheckPinnedUser.defaultExpectation.results = &RepositoryMockCheckPinnedUserResults{dp2} - mmCheckPinnedUser.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCheckPinnedUser.mock + mmCreateNamespacePipeline.defaultExpectation.results = &RepositoryMockCreateNamespacePipelineResults{err} + mmCreateNamespacePipeline.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreateNamespacePipeline.mock } -// Set uses given function f to mock the Repository.CheckPinnedUser method -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Set(f func(ctx context.Context, dp1 *gorm.DB, table string) (dp2 *gorm.DB)) *RepositoryMock { - if mmCheckPinnedUser.defaultExpectation != nil { - mmCheckPinnedUser.mock.t.Fatalf("Default expectation is already set for the Repository.CheckPinnedUser method") +// Set uses given function f to mock the Repository.CreateNamespacePipeline method +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Set(f func(ctx context.Context, pipeline *datamodel.Pipeline) (err error)) *RepositoryMock { + if mmCreateNamespacePipeline.defaultExpectation != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespacePipeline method") } - if len(mmCheckPinnedUser.expectations) > 0 { - mmCheckPinnedUser.mock.t.Fatalf("Some expectations are already set for the Repository.CheckPinnedUser method") + if len(mmCreateNamespacePipeline.expectations) > 0 { + mmCreateNamespacePipeline.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespacePipeline method") } - mmCheckPinnedUser.mock.funcCheckPinnedUser = f - mmCheckPinnedUser.mock.funcCheckPinnedUserOrigin = minimock.CallerInfo(1) - return mmCheckPinnedUser.mock + mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline = f + mmCreateNamespacePipeline.mock.funcCreateNamespacePipelineOrigin = minimock.CallerInfo(1) + return mmCreateNamespacePipeline.mock } -// When sets expectation for the Repository.CheckPinnedUser which will trigger the result defined by the following +// When sets expectation for the Repository.CreateNamespacePipeline which will trigger the result defined by the following // Then helper -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) When(ctx context.Context, dp1 *gorm.DB, table string) *RepositoryMockCheckPinnedUserExpectation { - if mmCheckPinnedUser.mock.funcCheckPinnedUser != nil { - mmCheckPinnedUser.mock.t.Fatalf("RepositoryMock.CheckPinnedUser mock is already set by Set") +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) When(ctx context.Context, pipeline *datamodel.Pipeline) *RepositoryMockCreateNamespacePipelineExpectation { + if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") } - expectation := &RepositoryMockCheckPinnedUserExpectation{ - mock: mmCheckPinnedUser.mock, - params: &RepositoryMockCheckPinnedUserParams{ctx, dp1, table}, - expectationOrigins: RepositoryMockCheckPinnedUserExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockCreateNamespacePipelineExpectation{ + mock: mmCreateNamespacePipeline.mock, + params: &RepositoryMockCreateNamespacePipelineParams{ctx, pipeline}, + expectationOrigins: RepositoryMockCreateNamespacePipelineExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmCheckPinnedUser.expectations = append(mmCheckPinnedUser.expectations, expectation) + mmCreateNamespacePipeline.expectations = append(mmCreateNamespacePipeline.expectations, expectation) return expectation } -// Then sets up Repository.CheckPinnedUser return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCheckPinnedUserExpectation) Then(dp2 *gorm.DB) *RepositoryMock { - e.results = &RepositoryMockCheckPinnedUserResults{dp2} +// Then sets up Repository.CreateNamespacePipeline return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCreateNamespacePipelineExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockCreateNamespacePipelineResults{err} return e.mock } -// Times sets number of times Repository.CheckPinnedUser should be invoked -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Times(n uint64) *mRepositoryMockCheckPinnedUser { +// Times sets number of times Repository.CreateNamespacePipeline should be invoked +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Times(n uint64) *mRepositoryMockCreateNamespacePipeline { if n == 0 { - mmCheckPinnedUser.mock.t.Fatalf("Times of RepositoryMock.CheckPinnedUser mock can not be zero") + mmCreateNamespacePipeline.mock.t.Fatalf("Times of RepositoryMock.CreateNamespacePipeline mock can not be zero") } - mm_atomic.StoreUint64(&mmCheckPinnedUser.expectedInvocations, n) - mmCheckPinnedUser.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCheckPinnedUser + mm_atomic.StoreUint64(&mmCreateNamespacePipeline.expectedInvocations, n) + mmCreateNamespacePipeline.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreateNamespacePipeline } -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) invocationsDone() bool { - if len(mmCheckPinnedUser.expectations) == 0 && mmCheckPinnedUser.defaultExpectation == nil && mmCheckPinnedUser.mock.funcCheckPinnedUser == nil { +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) invocationsDone() bool { + if len(mmCreateNamespacePipeline.expectations) == 0 && mmCreateNamespacePipeline.defaultExpectation == nil && mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCheckPinnedUser.mock.afterCheckPinnedUserCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCheckPinnedUser.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipeline.mock.afterCreateNamespacePipelineCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipeline.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CheckPinnedUser implements mm_repository.Repository -func (mmCheckPinnedUser *RepositoryMock) CheckPinnedUser(ctx context.Context, dp1 *gorm.DB, table string) (dp2 *gorm.DB) { - mm_atomic.AddUint64(&mmCheckPinnedUser.beforeCheckPinnedUserCounter, 1) - defer mm_atomic.AddUint64(&mmCheckPinnedUser.afterCheckPinnedUserCounter, 1) +// CreateNamespacePipeline implements mm_repository.Repository +func (mmCreateNamespacePipeline *RepositoryMock) CreateNamespacePipeline(ctx context.Context, pipeline *datamodel.Pipeline) (err error) { + mm_atomic.AddUint64(&mmCreateNamespacePipeline.beforeCreateNamespacePipelineCounter, 1) + defer mm_atomic.AddUint64(&mmCreateNamespacePipeline.afterCreateNamespacePipelineCounter, 1) - mmCheckPinnedUser.t.Helper() + mmCreateNamespacePipeline.t.Helper() - if mmCheckPinnedUser.inspectFuncCheckPinnedUser != nil { - mmCheckPinnedUser.inspectFuncCheckPinnedUser(ctx, dp1, table) + if mmCreateNamespacePipeline.inspectFuncCreateNamespacePipeline != nil { + mmCreateNamespacePipeline.inspectFuncCreateNamespacePipeline(ctx, pipeline) } - mm_params := RepositoryMockCheckPinnedUserParams{ctx, dp1, table} + mm_params := RepositoryMockCreateNamespacePipelineParams{ctx, pipeline} // Record call args - mmCheckPinnedUser.CheckPinnedUserMock.mutex.Lock() - mmCheckPinnedUser.CheckPinnedUserMock.callArgs = append(mmCheckPinnedUser.CheckPinnedUserMock.callArgs, &mm_params) - mmCheckPinnedUser.CheckPinnedUserMock.mutex.Unlock() + mmCreateNamespacePipeline.CreateNamespacePipelineMock.mutex.Lock() + mmCreateNamespacePipeline.CreateNamespacePipelineMock.callArgs = append(mmCreateNamespacePipeline.CreateNamespacePipelineMock.callArgs, &mm_params) + mmCreateNamespacePipeline.CreateNamespacePipelineMock.mutex.Unlock() - for _, e := range mmCheckPinnedUser.CheckPinnedUserMock.expectations { + for _, e := range mmCreateNamespacePipeline.CreateNamespacePipelineMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.dp2 + return e.results.err } } - if mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.Counter, 1) - mm_want := mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.params - mm_want_ptrs := mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.paramPtrs + if mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.Counter, 1) + mm_want := mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.params + mm_want_ptrs := mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCheckPinnedUserParams{ctx, dp1, table} + mm_got := RepositoryMockCreateNamespacePipelineParams{ctx, pipeline} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.dp1 != nil && !minimock.Equal(*mm_want_ptrs.dp1, mm_got.dp1) { - mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameter dp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.originDp1, *mm_want_ptrs.dp1, mm_got.dp1, minimock.Diff(*mm_want_ptrs.dp1, mm_got.dp1)) + mmCreateNamespacePipeline.t.Errorf("RepositoryMock.CreateNamespacePipeline got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.table != nil && !minimock.Equal(*mm_want_ptrs.table, mm_got.table) { - mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameter table, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.originTable, *mm_want_ptrs.table, mm_got.table, minimock.Diff(*mm_want_ptrs.table, mm_got.table)) + if mm_want_ptrs.pipeline != nil && !minimock.Equal(*mm_want_ptrs.pipeline, mm_got.pipeline) { + mmCreateNamespacePipeline.t.Errorf("RepositoryMock.CreateNamespacePipeline got unexpected parameter pipeline, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.originPipeline, *mm_want_ptrs.pipeline, mm_got.pipeline, minimock.Diff(*mm_want_ptrs.pipeline, mm_got.pipeline)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCheckPinnedUser.t.Errorf("RepositoryMock.CheckPinnedUser got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateNamespacePipeline.t.Errorf("RepositoryMock.CreateNamespacePipeline got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCheckPinnedUser.CheckPinnedUserMock.defaultExpectation.results + mm_results := mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.results if mm_results == nil { - mmCheckPinnedUser.t.Fatal("No results are set for the RepositoryMock.CheckPinnedUser") + mmCreateNamespacePipeline.t.Fatal("No results are set for the RepositoryMock.CreateNamespacePipeline") } - return (*mm_results).dp2 + return (*mm_results).err } - if mmCheckPinnedUser.funcCheckPinnedUser != nil { - return mmCheckPinnedUser.funcCheckPinnedUser(ctx, dp1, table) + if mmCreateNamespacePipeline.funcCreateNamespacePipeline != nil { + return mmCreateNamespacePipeline.funcCreateNamespacePipeline(ctx, pipeline) } - mmCheckPinnedUser.t.Fatalf("Unexpected call to RepositoryMock.CheckPinnedUser. %v %v %v", ctx, dp1, table) + mmCreateNamespacePipeline.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespacePipeline. %v %v", ctx, pipeline) return } -// CheckPinnedUserAfterCounter returns a count of finished RepositoryMock.CheckPinnedUser invocations -func (mmCheckPinnedUser *RepositoryMock) CheckPinnedUserAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCheckPinnedUser.afterCheckPinnedUserCounter) +// CreateNamespacePipelineAfterCounter returns a count of finished RepositoryMock.CreateNamespacePipeline invocations +func (mmCreateNamespacePipeline *RepositoryMock) CreateNamespacePipelineAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespacePipeline.afterCreateNamespacePipelineCounter) } -// CheckPinnedUserBeforeCounter returns a count of RepositoryMock.CheckPinnedUser invocations -func (mmCheckPinnedUser *RepositoryMock) CheckPinnedUserBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCheckPinnedUser.beforeCheckPinnedUserCounter) +// CreateNamespacePipelineBeforeCounter returns a count of RepositoryMock.CreateNamespacePipeline invocations +func (mmCreateNamespacePipeline *RepositoryMock) CreateNamespacePipelineBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespacePipeline.beforeCreateNamespacePipelineCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CheckPinnedUser. +// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespacePipeline. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCheckPinnedUser *mRepositoryMockCheckPinnedUser) Calls() []*RepositoryMockCheckPinnedUserParams { - mmCheckPinnedUser.mutex.RLock() +func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Calls() []*RepositoryMockCreateNamespacePipelineParams { + mmCreateNamespacePipeline.mutex.RLock() - argCopy := make([]*RepositoryMockCheckPinnedUserParams, len(mmCheckPinnedUser.callArgs)) - copy(argCopy, mmCheckPinnedUser.callArgs) + argCopy := make([]*RepositoryMockCreateNamespacePipelineParams, len(mmCreateNamespacePipeline.callArgs)) + copy(argCopy, mmCreateNamespacePipeline.callArgs) - mmCheckPinnedUser.mutex.RUnlock() + mmCreateNamespacePipeline.mutex.RUnlock() return argCopy } -// MinimockCheckPinnedUserDone returns true if the count of the CheckPinnedUser invocations corresponds +// MinimockCreateNamespacePipelineDone returns true if the count of the CreateNamespacePipeline invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCheckPinnedUserDone() bool { - if m.CheckPinnedUserMock.optional { +func (m *RepositoryMock) MinimockCreateNamespacePipelineDone() bool { + if m.CreateNamespacePipelineMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CheckPinnedUserMock.expectations { + for _, e := range m.CreateNamespacePipelineMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CheckPinnedUserMock.invocationsDone() + return m.CreateNamespacePipelineMock.invocationsDone() } -// MinimockCheckPinnedUserInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCheckPinnedUserInspect() { - for _, e := range m.CheckPinnedUserMock.expectations { +// MinimockCreateNamespacePipelineInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCreateNamespacePipelineInspect() { + for _, e := range m.CreateNamespacePipelineMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCheckPinnedUserCounter := mm_atomic.LoadUint64(&m.afterCheckPinnedUserCounter) + afterCreateNamespacePipelineCounter := mm_atomic.LoadUint64(&m.afterCreateNamespacePipelineCounter) // if default expectation was set then invocations count should be greater than zero - if m.CheckPinnedUserMock.defaultExpectation != nil && afterCheckPinnedUserCounter < 1 { - if m.CheckPinnedUserMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s", m.CheckPinnedUserMock.defaultExpectation.returnOrigin) + if m.CreateNamespacePipelineMock.defaultExpectation != nil && afterCreateNamespacePipelineCounter < 1 { + if m.CreateNamespacePipelineMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s", m.CreateNamespacePipelineMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s with params: %#v", m.CheckPinnedUserMock.defaultExpectation.expectationOrigins.origin, *m.CheckPinnedUserMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s with params: %#v", m.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespacePipelineMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCheckPinnedUser != nil && afterCheckPinnedUserCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CheckPinnedUser at\n%s", m.funcCheckPinnedUserOrigin) + if m.funcCreateNamespacePipeline != nil && afterCreateNamespacePipelineCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s", m.funcCreateNamespacePipelineOrigin) } - if !m.CheckPinnedUserMock.invocationsDone() && afterCheckPinnedUserCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CheckPinnedUser at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CheckPinnedUserMock.expectedInvocations), m.CheckPinnedUserMock.expectedInvocationsOrigin, afterCheckPinnedUserCounter) + if !m.CreateNamespacePipelineMock.invocationsDone() && afterCreateNamespacePipelineCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespacePipeline at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateNamespacePipelineMock.expectedInvocations), m.CreateNamespacePipelineMock.expectedInvocationsOrigin, afterCreateNamespacePipelineCounter) } } -type mRepositoryMockCreateNamespaceConnection struct { +type mRepositoryMockCreateNamespacePipelineRelease struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCreateNamespaceConnectionExpectation - expectations []*RepositoryMockCreateNamespaceConnectionExpectation + defaultExpectation *RepositoryMockCreateNamespacePipelineReleaseExpectation + expectations []*RepositoryMockCreateNamespacePipelineReleaseExpectation - callArgs []*RepositoryMockCreateNamespaceConnectionParams + callArgs []*RepositoryMockCreateNamespacePipelineReleaseParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCreateNamespaceConnectionExpectation specifies expectation struct of the Repository.CreateNamespaceConnection -type RepositoryMockCreateNamespaceConnectionExpectation struct { +// RepositoryMockCreateNamespacePipelineReleaseExpectation specifies expectation struct of the Repository.CreateNamespacePipelineRelease +type RepositoryMockCreateNamespacePipelineReleaseExpectation struct { mock *RepositoryMock - params *RepositoryMockCreateNamespaceConnectionParams - paramPtrs *RepositoryMockCreateNamespaceConnectionParamPtrs - expectationOrigins RepositoryMockCreateNamespaceConnectionExpectationOrigins - results *RepositoryMockCreateNamespaceConnectionResults + params *RepositoryMockCreateNamespacePipelineReleaseParams + paramPtrs *RepositoryMockCreateNamespacePipelineReleaseParamPtrs + expectationOrigins RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins + results *RepositoryMockCreateNamespacePipelineReleaseResults returnOrigin string Counter uint64 } -// RepositoryMockCreateNamespaceConnectionParams contains parameters of the Repository.CreateNamespaceConnection -type RepositoryMockCreateNamespaceConnectionParams struct { - ctx context.Context - cp1 *datamodel.Connection +// RepositoryMockCreateNamespacePipelineReleaseParams contains parameters of the Repository.CreateNamespacePipelineRelease +type RepositoryMockCreateNamespacePipelineReleaseParams struct { + ctx context.Context + ownerPermalink string + pipelineUID uuid.UUID + pipelineRelease *datamodel.PipelineRelease } -// RepositoryMockCreateNamespaceConnectionParamPtrs contains pointers to parameters of the Repository.CreateNamespaceConnection -type RepositoryMockCreateNamespaceConnectionParamPtrs struct { - ctx *context.Context - cp1 **datamodel.Connection +// RepositoryMockCreateNamespacePipelineReleaseParamPtrs contains pointers to parameters of the Repository.CreateNamespacePipelineRelease +type RepositoryMockCreateNamespacePipelineReleaseParamPtrs struct { + ctx *context.Context + ownerPermalink *string + pipelineUID *uuid.UUID + pipelineRelease **datamodel.PipelineRelease } -// RepositoryMockCreateNamespaceConnectionResults contains results of the Repository.CreateNamespaceConnection -type RepositoryMockCreateNamespaceConnectionResults struct { - cp2 *datamodel.Connection +// RepositoryMockCreateNamespacePipelineReleaseResults contains results of the Repository.CreateNamespacePipelineRelease +type RepositoryMockCreateNamespacePipelineReleaseResults struct { err error } -// RepositoryMockCreateNamespaceConnectionOrigins contains origins of expectations of the Repository.CreateNamespaceConnection -type RepositoryMockCreateNamespaceConnectionExpectationOrigins struct { - origin string - originCtx string - originCp1 string +// RepositoryMockCreateNamespacePipelineReleaseOrigins contains origins of expectations of the Repository.CreateNamespacePipelineRelease +type RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins struct { + origin string + originCtx string + originOwnerPermalink string + originPipelineUID string + originPipelineRelease string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -1700,341 +1706,400 @@ type RepositoryMockCreateNamespaceConnectionExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Optional() *mRepositoryMockCreateNamespaceConnection { - mmCreateNamespaceConnection.optional = true - return mmCreateNamespaceConnection +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Optional() *mRepositoryMockCreateNamespacePipelineRelease { + mmCreateNamespacePipelineRelease.optional = true + return mmCreateNamespacePipelineRelease } -// Expect sets up expected params for Repository.CreateNamespaceConnection -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Expect(ctx context.Context, cp1 *datamodel.Connection) *mRepositoryMockCreateNamespaceConnection { - if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") +// Expect sets up expected params for Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) *mRepositoryMockCreateNamespacePipelineRelease { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") } - if mmCreateNamespaceConnection.defaultExpectation == nil { - mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{} + if mmCreateNamespacePipelineRelease.defaultExpectation == nil { + mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} } - if mmCreateNamespaceConnection.defaultExpectation.paramPtrs != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by ExpectParams functions") + if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by ExpectParams functions") } - mmCreateNamespaceConnection.defaultExpectation.params = &RepositoryMockCreateNamespaceConnectionParams{ctx, cp1} - mmCreateNamespaceConnection.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCreateNamespaceConnection.expectations { - if minimock.Equal(e.params, mmCreateNamespaceConnection.defaultExpectation.params) { - mmCreateNamespaceConnection.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespaceConnection.defaultExpectation.params) + mmCreateNamespacePipelineRelease.defaultExpectation.params = &RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease} + mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreateNamespacePipelineRelease.expectations { + if minimock.Equal(e.params, mmCreateNamespacePipelineRelease.defaultExpectation.params) { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespacePipelineRelease.defaultExpectation.params) } } - return mmCreateNamespaceConnection + return mmCreateNamespacePipelineRelease } -// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespaceConnection -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespaceConnection { - if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespacePipelineRelease { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") } - if mmCreateNamespaceConnection.defaultExpectation == nil { - mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{} + if mmCreateNamespacePipelineRelease.defaultExpectation == nil { + mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} } - if mmCreateNamespaceConnection.defaultExpectation.params != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Expect") + if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") } - if mmCreateNamespaceConnection.defaultExpectation.paramPtrs == nil { - mmCreateNamespaceConnection.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceConnectionParamPtrs{} + if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} } - mmCreateNamespaceConnection.defaultExpectation.paramPtrs.ctx = &ctx - mmCreateNamespaceConnection.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCreateNamespaceConnection + return mmCreateNamespacePipelineRelease } -// ExpectCp1Param2 sets up expected param cp1 for Repository.CreateNamespaceConnection -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) ExpectCp1Param2(cp1 *datamodel.Connection) *mRepositoryMockCreateNamespaceConnection { - if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockCreateNamespacePipelineRelease { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") } - if mmCreateNamespaceConnection.defaultExpectation == nil { - mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{} + if mmCreateNamespacePipelineRelease.defaultExpectation == nil { + mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} } - if mmCreateNamespaceConnection.defaultExpectation.params != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Expect") + if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") } - if mmCreateNamespaceConnection.defaultExpectation.paramPtrs == nil { - mmCreateNamespaceConnection.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceConnectionParamPtrs{} + if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} } - mmCreateNamespaceConnection.defaultExpectation.paramPtrs.cp1 = &cp1 - mmCreateNamespaceConnection.defaultExpectation.expectationOrigins.originCp1 = minimock.CallerInfo(1) + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmCreateNamespaceConnection + return mmCreateNamespacePipelineRelease } -// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespaceConnection -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Inspect(f func(ctx context.Context, cp1 *datamodel.Connection)) *mRepositoryMockCreateNamespaceConnection { - if mmCreateNamespaceConnection.mock.inspectFuncCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespaceConnection") +// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockCreateNamespacePipelineRelease { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") } - mmCreateNamespaceConnection.mock.inspectFuncCreateNamespaceConnection = f - - return mmCreateNamespaceConnection -} + if mmCreateNamespacePipelineRelease.defaultExpectation == nil { + mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} + } -// Return sets up results that will be returned by Repository.CreateNamespaceConnection -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Return(cp2 *datamodel.Connection, err error) *RepositoryMock { - if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") + if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") } - if mmCreateNamespaceConnection.defaultExpectation == nil { - mmCreateNamespaceConnection.defaultExpectation = &RepositoryMockCreateNamespaceConnectionExpectation{mock: mmCreateNamespaceConnection.mock} + if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} } - mmCreateNamespaceConnection.defaultExpectation.results = &RepositoryMockCreateNamespaceConnectionResults{cp2, err} - mmCreateNamespaceConnection.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCreateNamespaceConnection.mock + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) + + return mmCreateNamespacePipelineRelease } -// Set uses given function f to mock the Repository.CreateNamespaceConnection method -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Set(f func(ctx context.Context, cp1 *datamodel.Connection) (cp2 *datamodel.Connection, err error)) *RepositoryMock { - if mmCreateNamespaceConnection.defaultExpectation != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespaceConnection method") +// ExpectPipelineReleaseParam4 sets up expected param pipelineRelease for Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectPipelineReleaseParam4(pipelineRelease *datamodel.PipelineRelease) *mRepositoryMockCreateNamespacePipelineRelease { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") } - if len(mmCreateNamespaceConnection.expectations) > 0 { - mmCreateNamespaceConnection.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespaceConnection method") + if mmCreateNamespacePipelineRelease.defaultExpectation == nil { + mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} } - mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection = f - mmCreateNamespaceConnection.mock.funcCreateNamespaceConnectionOrigin = minimock.CallerInfo(1) - return mmCreateNamespaceConnection.mock -} - -// When sets expectation for the Repository.CreateNamespaceConnection which will trigger the result defined by the following -// Then helper -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) When(ctx context.Context, cp1 *datamodel.Connection) *RepositoryMockCreateNamespaceConnectionExpectation { - if mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.mock.t.Fatalf("RepositoryMock.CreateNamespaceConnection mock is already set by Set") + if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") } - expectation := &RepositoryMockCreateNamespaceConnectionExpectation{ - mock: mmCreateNamespaceConnection.mock, - params: &RepositoryMockCreateNamespaceConnectionParams{ctx, cp1}, - expectationOrigins: RepositoryMockCreateNamespaceConnectionExpectationOrigins{origin: minimock.CallerInfo(1)}, + if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} } - mmCreateNamespaceConnection.expectations = append(mmCreateNamespaceConnection.expectations, expectation) - return expectation -} + mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.pipelineRelease = &pipelineRelease + mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originPipelineRelease = minimock.CallerInfo(1) -// Then sets up Repository.CreateNamespaceConnection return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCreateNamespaceConnectionExpectation) Then(cp2 *datamodel.Connection, err error) *RepositoryMock { - e.results = &RepositoryMockCreateNamespaceConnectionResults{cp2, err} - return e.mock + return mmCreateNamespacePipelineRelease } -// Times sets number of times Repository.CreateNamespaceConnection should be invoked -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Times(n uint64) *mRepositoryMockCreateNamespaceConnection { - if n == 0 { - mmCreateNamespaceConnection.mock.t.Fatalf("Times of RepositoryMock.CreateNamespaceConnection mock can not be zero") +// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease)) *mRepositoryMockCreateNamespacePipelineRelease { + if mmCreateNamespacePipelineRelease.mock.inspectFuncCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespacePipelineRelease") } - mm_atomic.StoreUint64(&mmCreateNamespaceConnection.expectedInvocations, n) - mmCreateNamespaceConnection.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCreateNamespaceConnection + + mmCreateNamespacePipelineRelease.mock.inspectFuncCreateNamespacePipelineRelease = f + + return mmCreateNamespacePipelineRelease } -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) invocationsDone() bool { - if len(mmCreateNamespaceConnection.expectations) == 0 && mmCreateNamespaceConnection.defaultExpectation == nil && mmCreateNamespaceConnection.mock.funcCreateNamespaceConnection == nil { +// Return sets up results that will be returned by Repository.CreateNamespacePipelineRelease +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Return(err error) *RepositoryMock { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") + } + + if mmCreateNamespacePipelineRelease.defaultExpectation == nil { + mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{mock: mmCreateNamespacePipelineRelease.mock} + } + mmCreateNamespacePipelineRelease.defaultExpectation.results = &RepositoryMockCreateNamespacePipelineReleaseResults{err} + mmCreateNamespacePipelineRelease.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreateNamespacePipelineRelease.mock +} + +// Set uses given function f to mock the Repository.CreateNamespacePipelineRelease method +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) (err error)) *RepositoryMock { + if mmCreateNamespacePipelineRelease.defaultExpectation != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespacePipelineRelease method") + } + + if len(mmCreateNamespacePipelineRelease.expectations) > 0 { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespacePipelineRelease method") + } + + mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease = f + mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineReleaseOrigin = minimock.CallerInfo(1) + return mmCreateNamespacePipelineRelease.mock +} + +// When sets expectation for the Repository.CreateNamespacePipelineRelease which will trigger the result defined by the following +// Then helper +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) *RepositoryMockCreateNamespacePipelineReleaseExpectation { + if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") + } + + expectation := &RepositoryMockCreateNamespacePipelineReleaseExpectation{ + mock: mmCreateNamespacePipelineRelease.mock, + params: &RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease}, + expectationOrigins: RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmCreateNamespacePipelineRelease.expectations = append(mmCreateNamespacePipelineRelease.expectations, expectation) + return expectation +} + +// Then sets up Repository.CreateNamespacePipelineRelease return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCreateNamespacePipelineReleaseExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockCreateNamespacePipelineReleaseResults{err} + return e.mock +} + +// Times sets number of times Repository.CreateNamespacePipelineRelease should be invoked +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Times(n uint64) *mRepositoryMockCreateNamespacePipelineRelease { + if n == 0 { + mmCreateNamespacePipelineRelease.mock.t.Fatalf("Times of RepositoryMock.CreateNamespacePipelineRelease mock can not be zero") + } + mm_atomic.StoreUint64(&mmCreateNamespacePipelineRelease.expectedInvocations, n) + mmCreateNamespacePipelineRelease.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreateNamespacePipelineRelease +} + +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) invocationsDone() bool { + if len(mmCreateNamespacePipelineRelease.expectations) == 0 && mmCreateNamespacePipelineRelease.defaultExpectation == nil && mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceConnection.mock.afterCreateNamespaceConnectionCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceConnection.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.mock.afterCreateNamespacePipelineReleaseCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CreateNamespaceConnection implements mm_repository.Repository -func (mmCreateNamespaceConnection *RepositoryMock) CreateNamespaceConnection(ctx context.Context, cp1 *datamodel.Connection) (cp2 *datamodel.Connection, err error) { - mm_atomic.AddUint64(&mmCreateNamespaceConnection.beforeCreateNamespaceConnectionCounter, 1) - defer mm_atomic.AddUint64(&mmCreateNamespaceConnection.afterCreateNamespaceConnectionCounter, 1) +// CreateNamespacePipelineRelease implements mm_repository.Repository +func (mmCreateNamespacePipelineRelease *RepositoryMock) CreateNamespacePipelineRelease(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) (err error) { + mm_atomic.AddUint64(&mmCreateNamespacePipelineRelease.beforeCreateNamespacePipelineReleaseCounter, 1) + defer mm_atomic.AddUint64(&mmCreateNamespacePipelineRelease.afterCreateNamespacePipelineReleaseCounter, 1) - mmCreateNamespaceConnection.t.Helper() + mmCreateNamespacePipelineRelease.t.Helper() - if mmCreateNamespaceConnection.inspectFuncCreateNamespaceConnection != nil { - mmCreateNamespaceConnection.inspectFuncCreateNamespaceConnection(ctx, cp1) + if mmCreateNamespacePipelineRelease.inspectFuncCreateNamespacePipelineRelease != nil { + mmCreateNamespacePipelineRelease.inspectFuncCreateNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, pipelineRelease) } - mm_params := RepositoryMockCreateNamespaceConnectionParams{ctx, cp1} + mm_params := RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease} // Record call args - mmCreateNamespaceConnection.CreateNamespaceConnectionMock.mutex.Lock() - mmCreateNamespaceConnection.CreateNamespaceConnectionMock.callArgs = append(mmCreateNamespaceConnection.CreateNamespaceConnectionMock.callArgs, &mm_params) - mmCreateNamespaceConnection.CreateNamespaceConnectionMock.mutex.Unlock() + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.mutex.Lock() + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.callArgs = append(mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.callArgs, &mm_params) + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.mutex.Unlock() - for _, e := range mmCreateNamespaceConnection.CreateNamespaceConnectionMock.expectations { + for _, e := range mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.cp2, e.results.err + return e.results.err } } - if mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.Counter, 1) - mm_want := mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.params - mm_want_ptrs := mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.paramPtrs + if mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.Counter, 1) + mm_want := mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.params + mm_want_ptrs := mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCreateNamespaceConnectionParams{ctx, cp1} + mm_got := RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateNamespaceConnection.t.Errorf("RepositoryMock.CreateNamespaceConnection got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.cp1 != nil && !minimock.Equal(*mm_want_ptrs.cp1, mm_got.cp1) { - mmCreateNamespaceConnection.t.Errorf("RepositoryMock.CreateNamespaceConnection got unexpected parameter cp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.originCp1, *mm_want_ptrs.cp1, mm_got.cp1, minimock.Diff(*mm_want_ptrs.cp1, mm_got.cp1)) + if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { + mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + } + + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + } + + if mm_want_ptrs.pipelineRelease != nil && !minimock.Equal(*mm_want_ptrs.pipelineRelease, mm_got.pipelineRelease) { + mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter pipelineRelease, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originPipelineRelease, *mm_want_ptrs.pipelineRelease, mm_got.pipelineRelease, minimock.Diff(*mm_want_ptrs.pipelineRelease, mm_got.pipelineRelease)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateNamespaceConnection.t.Errorf("RepositoryMock.CreateNamespaceConnection got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCreateNamespaceConnection.CreateNamespaceConnectionMock.defaultExpectation.results + mm_results := mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.results if mm_results == nil { - mmCreateNamespaceConnection.t.Fatal("No results are set for the RepositoryMock.CreateNamespaceConnection") + mmCreateNamespacePipelineRelease.t.Fatal("No results are set for the RepositoryMock.CreateNamespacePipelineRelease") } - return (*mm_results).cp2, (*mm_results).err + return (*mm_results).err } - if mmCreateNamespaceConnection.funcCreateNamespaceConnection != nil { - return mmCreateNamespaceConnection.funcCreateNamespaceConnection(ctx, cp1) + if mmCreateNamespacePipelineRelease.funcCreateNamespacePipelineRelease != nil { + return mmCreateNamespacePipelineRelease.funcCreateNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, pipelineRelease) } - mmCreateNamespaceConnection.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespaceConnection. %v %v", ctx, cp1) + mmCreateNamespacePipelineRelease.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespacePipelineRelease. %v %v %v %v", ctx, ownerPermalink, pipelineUID, pipelineRelease) return } -// CreateNamespaceConnectionAfterCounter returns a count of finished RepositoryMock.CreateNamespaceConnection invocations -func (mmCreateNamespaceConnection *RepositoryMock) CreateNamespaceConnectionAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespaceConnection.afterCreateNamespaceConnectionCounter) +// CreateNamespacePipelineReleaseAfterCounter returns a count of finished RepositoryMock.CreateNamespacePipelineRelease invocations +func (mmCreateNamespacePipelineRelease *RepositoryMock) CreateNamespacePipelineReleaseAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.afterCreateNamespacePipelineReleaseCounter) } -// CreateNamespaceConnectionBeforeCounter returns a count of RepositoryMock.CreateNamespaceConnection invocations -func (mmCreateNamespaceConnection *RepositoryMock) CreateNamespaceConnectionBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespaceConnection.beforeCreateNamespaceConnectionCounter) +// CreateNamespacePipelineReleaseBeforeCounter returns a count of RepositoryMock.CreateNamespacePipelineRelease invocations +func (mmCreateNamespacePipelineRelease *RepositoryMock) CreateNamespacePipelineReleaseBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.beforeCreateNamespacePipelineReleaseCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespaceConnection. +// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespacePipelineRelease. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCreateNamespaceConnection *mRepositoryMockCreateNamespaceConnection) Calls() []*RepositoryMockCreateNamespaceConnectionParams { - mmCreateNamespaceConnection.mutex.RLock() +func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Calls() []*RepositoryMockCreateNamespacePipelineReleaseParams { + mmCreateNamespacePipelineRelease.mutex.RLock() - argCopy := make([]*RepositoryMockCreateNamespaceConnectionParams, len(mmCreateNamespaceConnection.callArgs)) - copy(argCopy, mmCreateNamespaceConnection.callArgs) + argCopy := make([]*RepositoryMockCreateNamespacePipelineReleaseParams, len(mmCreateNamespacePipelineRelease.callArgs)) + copy(argCopy, mmCreateNamespacePipelineRelease.callArgs) - mmCreateNamespaceConnection.mutex.RUnlock() + mmCreateNamespacePipelineRelease.mutex.RUnlock() return argCopy } -// MinimockCreateNamespaceConnectionDone returns true if the count of the CreateNamespaceConnection invocations corresponds +// MinimockCreateNamespacePipelineReleaseDone returns true if the count of the CreateNamespacePipelineRelease invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCreateNamespaceConnectionDone() bool { - if m.CreateNamespaceConnectionMock.optional { +func (m *RepositoryMock) MinimockCreateNamespacePipelineReleaseDone() bool { + if m.CreateNamespacePipelineReleaseMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CreateNamespaceConnectionMock.expectations { + for _, e := range m.CreateNamespacePipelineReleaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CreateNamespaceConnectionMock.invocationsDone() + return m.CreateNamespacePipelineReleaseMock.invocationsDone() } -// MinimockCreateNamespaceConnectionInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCreateNamespaceConnectionInspect() { - for _, e := range m.CreateNamespaceConnectionMock.expectations { +// MinimockCreateNamespacePipelineReleaseInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCreateNamespacePipelineReleaseInspect() { + for _, e := range m.CreateNamespacePipelineReleaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCreateNamespaceConnectionCounter := mm_atomic.LoadUint64(&m.afterCreateNamespaceConnectionCounter) + afterCreateNamespacePipelineReleaseCounter := mm_atomic.LoadUint64(&m.afterCreateNamespacePipelineReleaseCounter) // if default expectation was set then invocations count should be greater than zero - if m.CreateNamespaceConnectionMock.defaultExpectation != nil && afterCreateNamespaceConnectionCounter < 1 { - if m.CreateNamespaceConnectionMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s", m.CreateNamespaceConnectionMock.defaultExpectation.returnOrigin) + if m.CreateNamespacePipelineReleaseMock.defaultExpectation != nil && afterCreateNamespacePipelineReleaseCounter < 1 { + if m.CreateNamespacePipelineReleaseMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s", m.CreateNamespacePipelineReleaseMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s with params: %#v", m.CreateNamespaceConnectionMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespaceConnectionMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s with params: %#v", m.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespacePipelineReleaseMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCreateNamespaceConnection != nil && afterCreateNamespaceConnectionCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceConnection at\n%s", m.funcCreateNamespaceConnectionOrigin) + if m.funcCreateNamespacePipelineRelease != nil && afterCreateNamespacePipelineReleaseCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s", m.funcCreateNamespacePipelineReleaseOrigin) } - if !m.CreateNamespaceConnectionMock.invocationsDone() && afterCreateNamespaceConnectionCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespaceConnection at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CreateNamespaceConnectionMock.expectedInvocations), m.CreateNamespaceConnectionMock.expectedInvocationsOrigin, afterCreateNamespaceConnectionCounter) + if !m.CreateNamespacePipelineReleaseMock.invocationsDone() && afterCreateNamespacePipelineReleaseCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespacePipelineRelease at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateNamespacePipelineReleaseMock.expectedInvocations), m.CreateNamespacePipelineReleaseMock.expectedInvocationsOrigin, afterCreateNamespacePipelineReleaseCounter) } } -type mRepositoryMockCreateNamespacePipeline struct { +type mRepositoryMockCreateNamespaceSecret struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCreateNamespacePipelineExpectation - expectations []*RepositoryMockCreateNamespacePipelineExpectation + defaultExpectation *RepositoryMockCreateNamespaceSecretExpectation + expectations []*RepositoryMockCreateNamespaceSecretExpectation - callArgs []*RepositoryMockCreateNamespacePipelineParams + callArgs []*RepositoryMockCreateNamespaceSecretParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCreateNamespacePipelineExpectation specifies expectation struct of the Repository.CreateNamespacePipeline -type RepositoryMockCreateNamespacePipelineExpectation struct { +// RepositoryMockCreateNamespaceSecretExpectation specifies expectation struct of the Repository.CreateNamespaceSecret +type RepositoryMockCreateNamespaceSecretExpectation struct { mock *RepositoryMock - params *RepositoryMockCreateNamespacePipelineParams - paramPtrs *RepositoryMockCreateNamespacePipelineParamPtrs - expectationOrigins RepositoryMockCreateNamespacePipelineExpectationOrigins - results *RepositoryMockCreateNamespacePipelineResults + params *RepositoryMockCreateNamespaceSecretParams + paramPtrs *RepositoryMockCreateNamespaceSecretParamPtrs + expectationOrigins RepositoryMockCreateNamespaceSecretExpectationOrigins + results *RepositoryMockCreateNamespaceSecretResults returnOrigin string Counter uint64 } -// RepositoryMockCreateNamespacePipelineParams contains parameters of the Repository.CreateNamespacePipeline -type RepositoryMockCreateNamespacePipelineParams struct { - ctx context.Context - pipeline *datamodel.Pipeline +// RepositoryMockCreateNamespaceSecretParams contains parameters of the Repository.CreateNamespaceSecret +type RepositoryMockCreateNamespaceSecretParams struct { + ctx context.Context + ownerPermalink string + secret *datamodel.Secret } -// RepositoryMockCreateNamespacePipelineParamPtrs contains pointers to parameters of the Repository.CreateNamespacePipeline -type RepositoryMockCreateNamespacePipelineParamPtrs struct { - ctx *context.Context - pipeline **datamodel.Pipeline +// RepositoryMockCreateNamespaceSecretParamPtrs contains pointers to parameters of the Repository.CreateNamespaceSecret +type RepositoryMockCreateNamespaceSecretParamPtrs struct { + ctx *context.Context + ownerPermalink *string + secret **datamodel.Secret } -// RepositoryMockCreateNamespacePipelineResults contains results of the Repository.CreateNamespacePipeline -type RepositoryMockCreateNamespacePipelineResults struct { +// RepositoryMockCreateNamespaceSecretResults contains results of the Repository.CreateNamespaceSecret +type RepositoryMockCreateNamespaceSecretResults struct { err error } -// RepositoryMockCreateNamespacePipelineOrigins contains origins of expectations of the Repository.CreateNamespacePipeline -type RepositoryMockCreateNamespacePipelineExpectationOrigins struct { - origin string - originCtx string - originPipeline string +// RepositoryMockCreateNamespaceSecretOrigins contains origins of expectations of the Repository.CreateNamespaceSecret +type RepositoryMockCreateNamespaceSecretExpectationOrigins struct { + origin string + originCtx string + originOwnerPermalink string + originSecret string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -2042,347 +2107,369 @@ type RepositoryMockCreateNamespacePipelineExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Optional() *mRepositoryMockCreateNamespacePipeline { - mmCreateNamespacePipeline.optional = true - return mmCreateNamespacePipeline +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Optional() *mRepositoryMockCreateNamespaceSecret { + mmCreateNamespaceSecret.optional = true + return mmCreateNamespaceSecret } -// Expect sets up expected params for Repository.CreateNamespacePipeline -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Expect(ctx context.Context, pipeline *datamodel.Pipeline) *mRepositoryMockCreateNamespacePipeline { - if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") +// Expect sets up expected params for Repository.CreateNamespaceSecret +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Expect(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) *mRepositoryMockCreateNamespaceSecret { + if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") } - if mmCreateNamespacePipeline.defaultExpectation == nil { - mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{} + if mmCreateNamespaceSecret.defaultExpectation == nil { + mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} } - if mmCreateNamespacePipeline.defaultExpectation.paramPtrs != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by ExpectParams functions") + if mmCreateNamespaceSecret.defaultExpectation.paramPtrs != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by ExpectParams functions") } - mmCreateNamespacePipeline.defaultExpectation.params = &RepositoryMockCreateNamespacePipelineParams{ctx, pipeline} - mmCreateNamespacePipeline.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCreateNamespacePipeline.expectations { - if minimock.Equal(e.params, mmCreateNamespacePipeline.defaultExpectation.params) { - mmCreateNamespacePipeline.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespacePipeline.defaultExpectation.params) + mmCreateNamespaceSecret.defaultExpectation.params = &RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret} + mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreateNamespaceSecret.expectations { + if minimock.Equal(e.params, mmCreateNamespaceSecret.defaultExpectation.params) { + mmCreateNamespaceSecret.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespaceSecret.defaultExpectation.params) } } - return mmCreateNamespacePipeline + return mmCreateNamespaceSecret } -// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespacePipeline -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespacePipeline { - if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespaceSecret +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespaceSecret { + if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") } - if mmCreateNamespacePipeline.defaultExpectation == nil { - mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{} + if mmCreateNamespaceSecret.defaultExpectation == nil { + mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} } - if mmCreateNamespacePipeline.defaultExpectation.params != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Expect") + if mmCreateNamespaceSecret.defaultExpectation.params != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Expect") } - if mmCreateNamespacePipeline.defaultExpectation.paramPtrs == nil { - mmCreateNamespacePipeline.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineParamPtrs{} + if mmCreateNamespaceSecret.defaultExpectation.paramPtrs == nil { + mmCreateNamespaceSecret.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceSecretParamPtrs{} } - mmCreateNamespacePipeline.defaultExpectation.paramPtrs.ctx = &ctx - mmCreateNamespacePipeline.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmCreateNamespaceSecret.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCreateNamespacePipeline + return mmCreateNamespaceSecret } -// ExpectPipelineParam2 sets up expected param pipeline for Repository.CreateNamespacePipeline -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) ExpectPipelineParam2(pipeline *datamodel.Pipeline) *mRepositoryMockCreateNamespacePipeline { - if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.CreateNamespaceSecret +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockCreateNamespaceSecret { + if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") } - if mmCreateNamespacePipeline.defaultExpectation == nil { - mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{} + if mmCreateNamespaceSecret.defaultExpectation == nil { + mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} } - if mmCreateNamespacePipeline.defaultExpectation.params != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Expect") + if mmCreateNamespaceSecret.defaultExpectation.params != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Expect") } - if mmCreateNamespacePipeline.defaultExpectation.paramPtrs == nil { - mmCreateNamespacePipeline.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineParamPtrs{} + if mmCreateNamespaceSecret.defaultExpectation.paramPtrs == nil { + mmCreateNamespaceSecret.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceSecretParamPtrs{} } - mmCreateNamespacePipeline.defaultExpectation.paramPtrs.pipeline = &pipeline - mmCreateNamespacePipeline.defaultExpectation.expectationOrigins.originPipeline = minimock.CallerInfo(1) + mmCreateNamespaceSecret.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmCreateNamespacePipeline + return mmCreateNamespaceSecret } -// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespacePipeline -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Inspect(f func(ctx context.Context, pipeline *datamodel.Pipeline)) *mRepositoryMockCreateNamespacePipeline { - if mmCreateNamespacePipeline.mock.inspectFuncCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespacePipeline") +// ExpectSecretParam3 sets up expected param secret for Repository.CreateNamespaceSecret +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) ExpectSecretParam3(secret *datamodel.Secret) *mRepositoryMockCreateNamespaceSecret { + if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") } - mmCreateNamespacePipeline.mock.inspectFuncCreateNamespacePipeline = f + if mmCreateNamespaceSecret.defaultExpectation == nil { + mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} + } - return mmCreateNamespacePipeline + if mmCreateNamespaceSecret.defaultExpectation.params != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Expect") + } + + if mmCreateNamespaceSecret.defaultExpectation.paramPtrs == nil { + mmCreateNamespaceSecret.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceSecretParamPtrs{} + } + mmCreateNamespaceSecret.defaultExpectation.paramPtrs.secret = &secret + mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.originSecret = minimock.CallerInfo(1) + + return mmCreateNamespaceSecret } -// Return sets up results that will be returned by Repository.CreateNamespacePipeline -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Return(err error) *RepositoryMock { - if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespaceSecret +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Inspect(f func(ctx context.Context, ownerPermalink string, secret *datamodel.Secret)) *mRepositoryMockCreateNamespaceSecret { + if mmCreateNamespaceSecret.mock.inspectFuncCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespaceSecret") } - if mmCreateNamespacePipeline.defaultExpectation == nil { - mmCreateNamespacePipeline.defaultExpectation = &RepositoryMockCreateNamespacePipelineExpectation{mock: mmCreateNamespacePipeline.mock} + mmCreateNamespaceSecret.mock.inspectFuncCreateNamespaceSecret = f + + return mmCreateNamespaceSecret +} + +// Return sets up results that will be returned by Repository.CreateNamespaceSecret +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Return(err error) *RepositoryMock { + if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") } - mmCreateNamespacePipeline.defaultExpectation.results = &RepositoryMockCreateNamespacePipelineResults{err} - mmCreateNamespacePipeline.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCreateNamespacePipeline.mock + + if mmCreateNamespaceSecret.defaultExpectation == nil { + mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{mock: mmCreateNamespaceSecret.mock} + } + mmCreateNamespaceSecret.defaultExpectation.results = &RepositoryMockCreateNamespaceSecretResults{err} + mmCreateNamespaceSecret.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreateNamespaceSecret.mock } -// Set uses given function f to mock the Repository.CreateNamespacePipeline method -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Set(f func(ctx context.Context, pipeline *datamodel.Pipeline) (err error)) *RepositoryMock { - if mmCreateNamespacePipeline.defaultExpectation != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespacePipeline method") +// Set uses given function f to mock the Repository.CreateNamespaceSecret method +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Set(f func(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) (err error)) *RepositoryMock { + if mmCreateNamespaceSecret.defaultExpectation != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespaceSecret method") } - if len(mmCreateNamespacePipeline.expectations) > 0 { - mmCreateNamespacePipeline.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespacePipeline method") + if len(mmCreateNamespaceSecret.expectations) > 0 { + mmCreateNamespaceSecret.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespaceSecret method") } - mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline = f - mmCreateNamespacePipeline.mock.funcCreateNamespacePipelineOrigin = minimock.CallerInfo(1) - return mmCreateNamespacePipeline.mock + mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret = f + mmCreateNamespaceSecret.mock.funcCreateNamespaceSecretOrigin = minimock.CallerInfo(1) + return mmCreateNamespaceSecret.mock } -// When sets expectation for the Repository.CreateNamespacePipeline which will trigger the result defined by the following +// When sets expectation for the Repository.CreateNamespaceSecret which will trigger the result defined by the following // Then helper -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) When(ctx context.Context, pipeline *datamodel.Pipeline) *RepositoryMockCreateNamespacePipelineExpectation { - if mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.mock.t.Fatalf("RepositoryMock.CreateNamespacePipeline mock is already set by Set") +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) When(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) *RepositoryMockCreateNamespaceSecretExpectation { + if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") } - expectation := &RepositoryMockCreateNamespacePipelineExpectation{ - mock: mmCreateNamespacePipeline.mock, - params: &RepositoryMockCreateNamespacePipelineParams{ctx, pipeline}, - expectationOrigins: RepositoryMockCreateNamespacePipelineExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockCreateNamespaceSecretExpectation{ + mock: mmCreateNamespaceSecret.mock, + params: &RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret}, + expectationOrigins: RepositoryMockCreateNamespaceSecretExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmCreateNamespacePipeline.expectations = append(mmCreateNamespacePipeline.expectations, expectation) + mmCreateNamespaceSecret.expectations = append(mmCreateNamespaceSecret.expectations, expectation) return expectation } -// Then sets up Repository.CreateNamespacePipeline return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCreateNamespacePipelineExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockCreateNamespacePipelineResults{err} +// Then sets up Repository.CreateNamespaceSecret return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCreateNamespaceSecretExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockCreateNamespaceSecretResults{err} return e.mock } -// Times sets number of times Repository.CreateNamespacePipeline should be invoked -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Times(n uint64) *mRepositoryMockCreateNamespacePipeline { +// Times sets number of times Repository.CreateNamespaceSecret should be invoked +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Times(n uint64) *mRepositoryMockCreateNamespaceSecret { if n == 0 { - mmCreateNamespacePipeline.mock.t.Fatalf("Times of RepositoryMock.CreateNamespacePipeline mock can not be zero") + mmCreateNamespaceSecret.mock.t.Fatalf("Times of RepositoryMock.CreateNamespaceSecret mock can not be zero") } - mm_atomic.StoreUint64(&mmCreateNamespacePipeline.expectedInvocations, n) - mmCreateNamespacePipeline.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCreateNamespacePipeline + mm_atomic.StoreUint64(&mmCreateNamespaceSecret.expectedInvocations, n) + mmCreateNamespaceSecret.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreateNamespaceSecret } -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) invocationsDone() bool { - if len(mmCreateNamespacePipeline.expectations) == 0 && mmCreateNamespacePipeline.defaultExpectation == nil && mmCreateNamespacePipeline.mock.funcCreateNamespacePipeline == nil { +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) invocationsDone() bool { + if len(mmCreateNamespaceSecret.expectations) == 0 && mmCreateNamespaceSecret.defaultExpectation == nil && mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipeline.mock.afterCreateNamespacePipelineCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipeline.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceSecret.mock.afterCreateNamespaceSecretCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceSecret.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CreateNamespacePipeline implements mm_repository.Repository -func (mmCreateNamespacePipeline *RepositoryMock) CreateNamespacePipeline(ctx context.Context, pipeline *datamodel.Pipeline) (err error) { - mm_atomic.AddUint64(&mmCreateNamespacePipeline.beforeCreateNamespacePipelineCounter, 1) - defer mm_atomic.AddUint64(&mmCreateNamespacePipeline.afterCreateNamespacePipelineCounter, 1) +// CreateNamespaceSecret implements mm_repository.Repository +func (mmCreateNamespaceSecret *RepositoryMock) CreateNamespaceSecret(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) (err error) { + mm_atomic.AddUint64(&mmCreateNamespaceSecret.beforeCreateNamespaceSecretCounter, 1) + defer mm_atomic.AddUint64(&mmCreateNamespaceSecret.afterCreateNamespaceSecretCounter, 1) - mmCreateNamespacePipeline.t.Helper() + mmCreateNamespaceSecret.t.Helper() - if mmCreateNamespacePipeline.inspectFuncCreateNamespacePipeline != nil { - mmCreateNamespacePipeline.inspectFuncCreateNamespacePipeline(ctx, pipeline) + if mmCreateNamespaceSecret.inspectFuncCreateNamespaceSecret != nil { + mmCreateNamespaceSecret.inspectFuncCreateNamespaceSecret(ctx, ownerPermalink, secret) } - mm_params := RepositoryMockCreateNamespacePipelineParams{ctx, pipeline} + mm_params := RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret} // Record call args - mmCreateNamespacePipeline.CreateNamespacePipelineMock.mutex.Lock() - mmCreateNamespacePipeline.CreateNamespacePipelineMock.callArgs = append(mmCreateNamespacePipeline.CreateNamespacePipelineMock.callArgs, &mm_params) - mmCreateNamespacePipeline.CreateNamespacePipelineMock.mutex.Unlock() + mmCreateNamespaceSecret.CreateNamespaceSecretMock.mutex.Lock() + mmCreateNamespaceSecret.CreateNamespaceSecretMock.callArgs = append(mmCreateNamespaceSecret.CreateNamespaceSecretMock.callArgs, &mm_params) + mmCreateNamespaceSecret.CreateNamespaceSecretMock.mutex.Unlock() - for _, e := range mmCreateNamespacePipeline.CreateNamespacePipelineMock.expectations { + for _, e := range mmCreateNamespaceSecret.CreateNamespaceSecretMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.Counter, 1) - mm_want := mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.params - mm_want_ptrs := mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.paramPtrs + if mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.Counter, 1) + mm_want := mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.params + mm_want_ptrs := mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCreateNamespacePipelineParams{ctx, pipeline} + mm_got := RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateNamespacePipeline.t.Errorf("RepositoryMock.CreateNamespacePipeline got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.pipeline != nil && !minimock.Equal(*mm_want_ptrs.pipeline, mm_got.pipeline) { - mmCreateNamespacePipeline.t.Errorf("RepositoryMock.CreateNamespacePipeline got unexpected parameter pipeline, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.originPipeline, *mm_want_ptrs.pipeline, mm_got.pipeline, minimock.Diff(*mm_want_ptrs.pipeline, mm_got.pipeline)) + if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { + mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + } + + if mm_want_ptrs.secret != nil && !minimock.Equal(*mm_want_ptrs.secret, mm_got.secret) { + mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameter secret, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.originSecret, *mm_want_ptrs.secret, mm_got.secret, minimock.Diff(*mm_want_ptrs.secret, mm_got.secret)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateNamespacePipeline.t.Errorf("RepositoryMock.CreateNamespacePipeline got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCreateNamespacePipeline.CreateNamespacePipelineMock.defaultExpectation.results + mm_results := mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.results if mm_results == nil { - mmCreateNamespacePipeline.t.Fatal("No results are set for the RepositoryMock.CreateNamespacePipeline") + mmCreateNamespaceSecret.t.Fatal("No results are set for the RepositoryMock.CreateNamespaceSecret") } return (*mm_results).err } - if mmCreateNamespacePipeline.funcCreateNamespacePipeline != nil { - return mmCreateNamespacePipeline.funcCreateNamespacePipeline(ctx, pipeline) + if mmCreateNamespaceSecret.funcCreateNamespaceSecret != nil { + return mmCreateNamespaceSecret.funcCreateNamespaceSecret(ctx, ownerPermalink, secret) } - mmCreateNamespacePipeline.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespacePipeline. %v %v", ctx, pipeline) + mmCreateNamespaceSecret.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespaceSecret. %v %v %v", ctx, ownerPermalink, secret) return } -// CreateNamespacePipelineAfterCounter returns a count of finished RepositoryMock.CreateNamespacePipeline invocations -func (mmCreateNamespacePipeline *RepositoryMock) CreateNamespacePipelineAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespacePipeline.afterCreateNamespacePipelineCounter) +// CreateNamespaceSecretAfterCounter returns a count of finished RepositoryMock.CreateNamespaceSecret invocations +func (mmCreateNamespaceSecret *RepositoryMock) CreateNamespaceSecretAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespaceSecret.afterCreateNamespaceSecretCounter) } -// CreateNamespacePipelineBeforeCounter returns a count of RepositoryMock.CreateNamespacePipeline invocations -func (mmCreateNamespacePipeline *RepositoryMock) CreateNamespacePipelineBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespacePipeline.beforeCreateNamespacePipelineCounter) +// CreateNamespaceSecretBeforeCounter returns a count of RepositoryMock.CreateNamespaceSecret invocations +func (mmCreateNamespaceSecret *RepositoryMock) CreateNamespaceSecretBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateNamespaceSecret.beforeCreateNamespaceSecretCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespacePipeline. +// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespaceSecret. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCreateNamespacePipeline *mRepositoryMockCreateNamespacePipeline) Calls() []*RepositoryMockCreateNamespacePipelineParams { - mmCreateNamespacePipeline.mutex.RLock() +func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Calls() []*RepositoryMockCreateNamespaceSecretParams { + mmCreateNamespaceSecret.mutex.RLock() - argCopy := make([]*RepositoryMockCreateNamespacePipelineParams, len(mmCreateNamespacePipeline.callArgs)) - copy(argCopy, mmCreateNamespacePipeline.callArgs) + argCopy := make([]*RepositoryMockCreateNamespaceSecretParams, len(mmCreateNamespaceSecret.callArgs)) + copy(argCopy, mmCreateNamespaceSecret.callArgs) - mmCreateNamespacePipeline.mutex.RUnlock() + mmCreateNamespaceSecret.mutex.RUnlock() return argCopy } -// MinimockCreateNamespacePipelineDone returns true if the count of the CreateNamespacePipeline invocations corresponds +// MinimockCreateNamespaceSecretDone returns true if the count of the CreateNamespaceSecret invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCreateNamespacePipelineDone() bool { - if m.CreateNamespacePipelineMock.optional { +func (m *RepositoryMock) MinimockCreateNamespaceSecretDone() bool { + if m.CreateNamespaceSecretMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CreateNamespacePipelineMock.expectations { + for _, e := range m.CreateNamespaceSecretMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CreateNamespacePipelineMock.invocationsDone() + return m.CreateNamespaceSecretMock.invocationsDone() } -// MinimockCreateNamespacePipelineInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCreateNamespacePipelineInspect() { - for _, e := range m.CreateNamespacePipelineMock.expectations { +// MinimockCreateNamespaceSecretInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCreateNamespaceSecretInspect() { + for _, e := range m.CreateNamespaceSecretMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCreateNamespacePipelineCounter := mm_atomic.LoadUint64(&m.afterCreateNamespacePipelineCounter) + afterCreateNamespaceSecretCounter := mm_atomic.LoadUint64(&m.afterCreateNamespaceSecretCounter) // if default expectation was set then invocations count should be greater than zero - if m.CreateNamespacePipelineMock.defaultExpectation != nil && afterCreateNamespacePipelineCounter < 1 { - if m.CreateNamespacePipelineMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s", m.CreateNamespacePipelineMock.defaultExpectation.returnOrigin) + if m.CreateNamespaceSecretMock.defaultExpectation != nil && afterCreateNamespaceSecretCounter < 1 { + if m.CreateNamespaceSecretMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s", m.CreateNamespaceSecretMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s with params: %#v", m.CreateNamespacePipelineMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespacePipelineMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s with params: %#v", m.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespaceSecretMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCreateNamespacePipeline != nil && afterCreateNamespacePipelineCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipeline at\n%s", m.funcCreateNamespacePipelineOrigin) + if m.funcCreateNamespaceSecret != nil && afterCreateNamespaceSecretCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s", m.funcCreateNamespaceSecretOrigin) } - if !m.CreateNamespacePipelineMock.invocationsDone() && afterCreateNamespacePipelineCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespacePipeline at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CreateNamespacePipelineMock.expectedInvocations), m.CreateNamespacePipelineMock.expectedInvocationsOrigin, afterCreateNamespacePipelineCounter) + if !m.CreateNamespaceSecretMock.invocationsDone() && afterCreateNamespaceSecretCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespaceSecret at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateNamespaceSecretMock.expectedInvocations), m.CreateNamespaceSecretMock.expectedInvocationsOrigin, afterCreateNamespaceSecretCounter) } } -type mRepositoryMockCreateNamespacePipelineRelease struct { +type mRepositoryMockCreatePipelineRunOn struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCreateNamespacePipelineReleaseExpectation - expectations []*RepositoryMockCreateNamespacePipelineReleaseExpectation + defaultExpectation *RepositoryMockCreatePipelineRunOnExpectation + expectations []*RepositoryMockCreatePipelineRunOnExpectation - callArgs []*RepositoryMockCreateNamespacePipelineReleaseParams + callArgs []*RepositoryMockCreatePipelineRunOnParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCreateNamespacePipelineReleaseExpectation specifies expectation struct of the Repository.CreateNamespacePipelineRelease -type RepositoryMockCreateNamespacePipelineReleaseExpectation struct { +// RepositoryMockCreatePipelineRunOnExpectation specifies expectation struct of the Repository.CreatePipelineRunOn +type RepositoryMockCreatePipelineRunOnExpectation struct { mock *RepositoryMock - params *RepositoryMockCreateNamespacePipelineReleaseParams - paramPtrs *RepositoryMockCreateNamespacePipelineReleaseParamPtrs - expectationOrigins RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins - results *RepositoryMockCreateNamespacePipelineReleaseResults + params *RepositoryMockCreatePipelineRunOnParams + paramPtrs *RepositoryMockCreatePipelineRunOnParamPtrs + expectationOrigins RepositoryMockCreatePipelineRunOnExpectationOrigins + results *RepositoryMockCreatePipelineRunOnResults returnOrigin string Counter uint64 } -// RepositoryMockCreateNamespacePipelineReleaseParams contains parameters of the Repository.CreateNamespacePipelineRelease -type RepositoryMockCreateNamespacePipelineReleaseParams struct { - ctx context.Context - ownerPermalink string - pipelineUID uuid.UUID - pipelineRelease *datamodel.PipelineRelease +// RepositoryMockCreatePipelineRunOnParams contains parameters of the Repository.CreatePipelineRunOn +type RepositoryMockCreatePipelineRunOnParams struct { + ctx context.Context + pp1 *datamodel.PipelineRunOn } -// RepositoryMockCreateNamespacePipelineReleaseParamPtrs contains pointers to parameters of the Repository.CreateNamespacePipelineRelease -type RepositoryMockCreateNamespacePipelineReleaseParamPtrs struct { - ctx *context.Context - ownerPermalink *string - pipelineUID *uuid.UUID - pipelineRelease **datamodel.PipelineRelease +// RepositoryMockCreatePipelineRunOnParamPtrs contains pointers to parameters of the Repository.CreatePipelineRunOn +type RepositoryMockCreatePipelineRunOnParamPtrs struct { + ctx *context.Context + pp1 **datamodel.PipelineRunOn } -// RepositoryMockCreateNamespacePipelineReleaseResults contains results of the Repository.CreateNamespacePipelineRelease -type RepositoryMockCreateNamespacePipelineReleaseResults struct { +// RepositoryMockCreatePipelineRunOnResults contains results of the Repository.CreatePipelineRunOn +type RepositoryMockCreatePipelineRunOnResults struct { err error } -// RepositoryMockCreateNamespacePipelineReleaseOrigins contains origins of expectations of the Repository.CreateNamespacePipelineRelease -type RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins struct { - origin string - originCtx string - originOwnerPermalink string - originPipelineUID string - originPipelineRelease string +// RepositoryMockCreatePipelineRunOnOrigins contains origins of expectations of the Repository.CreatePipelineRunOn +type RepositoryMockCreatePipelineRunOnExpectationOrigins struct { + origin string + originCtx string + originPp1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -2390,400 +2477,344 @@ type RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Optional() *mRepositoryMockCreateNamespacePipelineRelease { - mmCreateNamespacePipelineRelease.optional = true - return mmCreateNamespacePipelineRelease +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Optional() *mRepositoryMockCreatePipelineRunOn { + mmCreatePipelineRunOn.optional = true + return mmCreatePipelineRunOn } -// Expect sets up expected params for Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) *mRepositoryMockCreateNamespacePipelineRelease { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") +// Expect sets up expected params for Repository.CreatePipelineRunOn +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Expect(ctx context.Context, pp1 *datamodel.PipelineRunOn) *mRepositoryMockCreatePipelineRunOn { + if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") } - if mmCreateNamespacePipelineRelease.defaultExpectation == nil { - mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} + if mmCreatePipelineRunOn.defaultExpectation == nil { + mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{} } - if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by ExpectParams functions") + if mmCreatePipelineRunOn.defaultExpectation.paramPtrs != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by ExpectParams functions") } - mmCreateNamespacePipelineRelease.defaultExpectation.params = &RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease} - mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCreateNamespacePipelineRelease.expectations { - if minimock.Equal(e.params, mmCreateNamespacePipelineRelease.defaultExpectation.params) { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespacePipelineRelease.defaultExpectation.params) + mmCreatePipelineRunOn.defaultExpectation.params = &RepositoryMockCreatePipelineRunOnParams{ctx, pp1} + mmCreatePipelineRunOn.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreatePipelineRunOn.expectations { + if minimock.Equal(e.params, mmCreatePipelineRunOn.defaultExpectation.params) { + mmCreatePipelineRunOn.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreatePipelineRunOn.defaultExpectation.params) } } - return mmCreateNamespacePipelineRelease + return mmCreatePipelineRunOn } -// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespacePipelineRelease { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.CreatePipelineRunOn +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreatePipelineRunOn { + if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") } - if mmCreateNamespacePipelineRelease.defaultExpectation == nil { - mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} + if mmCreatePipelineRunOn.defaultExpectation == nil { + mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{} } - if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") + if mmCreatePipelineRunOn.defaultExpectation.params != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Expect") } - if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} + if mmCreatePipelineRunOn.defaultExpectation.paramPtrs == nil { + mmCreatePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineRunOnParamPtrs{} } - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.ctx = &ctx - mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmCreatePipelineRunOn.defaultExpectation.paramPtrs.ctx = &ctx + mmCreatePipelineRunOn.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCreateNamespacePipelineRelease + return mmCreatePipelineRunOn } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockCreateNamespacePipelineRelease { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") +// ExpectPp1Param2 sets up expected param pp1 for Repository.CreatePipelineRunOn +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) ExpectPp1Param2(pp1 *datamodel.PipelineRunOn) *mRepositoryMockCreatePipelineRunOn { + if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") } - if mmCreateNamespacePipelineRelease.defaultExpectation == nil { - mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} + if mmCreatePipelineRunOn.defaultExpectation == nil { + mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{} } - if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") + if mmCreatePipelineRunOn.defaultExpectation.params != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Expect") } - if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} + if mmCreatePipelineRunOn.defaultExpectation.paramPtrs == nil { + mmCreatePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineRunOnParamPtrs{} } - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmCreatePipelineRunOn.defaultExpectation.paramPtrs.pp1 = &pp1 + mmCreatePipelineRunOn.defaultExpectation.expectationOrigins.originPp1 = minimock.CallerInfo(1) - return mmCreateNamespacePipelineRelease + return mmCreatePipelineRunOn } -// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockCreateNamespacePipelineRelease { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.CreatePipelineRunOn +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Inspect(f func(ctx context.Context, pp1 *datamodel.PipelineRunOn)) *mRepositoryMockCreatePipelineRunOn { + if mmCreatePipelineRunOn.mock.inspectFuncCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreatePipelineRunOn") } - if mmCreateNamespacePipelineRelease.defaultExpectation == nil { - mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} - } + mmCreatePipelineRunOn.mock.inspectFuncCreatePipelineRunOn = f - if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") - } + return mmCreatePipelineRunOn +} - if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} +// Return sets up results that will be returned by Repository.CreatePipelineRunOn +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Return(err error) *RepositoryMock { + if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") } - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - return mmCreateNamespacePipelineRelease + if mmCreatePipelineRunOn.defaultExpectation == nil { + mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{mock: mmCreatePipelineRunOn.mock} + } + mmCreatePipelineRunOn.defaultExpectation.results = &RepositoryMockCreatePipelineRunOnResults{err} + mmCreatePipelineRunOn.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreatePipelineRunOn.mock } -// ExpectPipelineReleaseParam4 sets up expected param pipelineRelease for Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) ExpectPipelineReleaseParam4(pipelineRelease *datamodel.PipelineRelease) *mRepositoryMockCreateNamespacePipelineRelease { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") +// Set uses given function f to mock the Repository.CreatePipelineRunOn method +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Set(f func(ctx context.Context, pp1 *datamodel.PipelineRunOn) (err error)) *RepositoryMock { + if mmCreatePipelineRunOn.defaultExpectation != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("Default expectation is already set for the Repository.CreatePipelineRunOn method") } - if mmCreateNamespacePipelineRelease.defaultExpectation == nil { - mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{} + if len(mmCreatePipelineRunOn.expectations) > 0 { + mmCreatePipelineRunOn.mock.t.Fatalf("Some expectations are already set for the Repository.CreatePipelineRunOn method") } - if mmCreateNamespacePipelineRelease.defaultExpectation.params != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Expect") - } - - if mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespacePipelineReleaseParamPtrs{} - } - mmCreateNamespacePipelineRelease.defaultExpectation.paramPtrs.pipelineRelease = &pipelineRelease - mmCreateNamespacePipelineRelease.defaultExpectation.expectationOrigins.originPipelineRelease = minimock.CallerInfo(1) - - return mmCreateNamespacePipelineRelease -} - -// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease)) *mRepositoryMockCreateNamespacePipelineRelease { - if mmCreateNamespacePipelineRelease.mock.inspectFuncCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespacePipelineRelease") - } - - mmCreateNamespacePipelineRelease.mock.inspectFuncCreateNamespacePipelineRelease = f - - return mmCreateNamespacePipelineRelease -} - -// Return sets up results that will be returned by Repository.CreateNamespacePipelineRelease -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Return(err error) *RepositoryMock { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") - } - - if mmCreateNamespacePipelineRelease.defaultExpectation == nil { - mmCreateNamespacePipelineRelease.defaultExpectation = &RepositoryMockCreateNamespacePipelineReleaseExpectation{mock: mmCreateNamespacePipelineRelease.mock} - } - mmCreateNamespacePipelineRelease.defaultExpectation.results = &RepositoryMockCreateNamespacePipelineReleaseResults{err} - mmCreateNamespacePipelineRelease.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCreateNamespacePipelineRelease.mock -} - -// Set uses given function f to mock the Repository.CreateNamespacePipelineRelease method -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) (err error)) *RepositoryMock { - if mmCreateNamespacePipelineRelease.defaultExpectation != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespacePipelineRelease method") - } - - if len(mmCreateNamespacePipelineRelease.expectations) > 0 { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespacePipelineRelease method") - } - - mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease = f - mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineReleaseOrigin = minimock.CallerInfo(1) - return mmCreateNamespacePipelineRelease.mock + mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn = f + mmCreatePipelineRunOn.mock.funcCreatePipelineRunOnOrigin = minimock.CallerInfo(1) + return mmCreatePipelineRunOn.mock } -// When sets expectation for the Repository.CreateNamespacePipelineRelease which will trigger the result defined by the following +// When sets expectation for the Repository.CreatePipelineRunOn which will trigger the result defined by the following // Then helper -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) *RepositoryMockCreateNamespacePipelineReleaseExpectation { - if mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.CreateNamespacePipelineRelease mock is already set by Set") +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) When(ctx context.Context, pp1 *datamodel.PipelineRunOn) *RepositoryMockCreatePipelineRunOnExpectation { + if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") } - expectation := &RepositoryMockCreateNamespacePipelineReleaseExpectation{ - mock: mmCreateNamespacePipelineRelease.mock, - params: &RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease}, - expectationOrigins: RepositoryMockCreateNamespacePipelineReleaseExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockCreatePipelineRunOnExpectation{ + mock: mmCreatePipelineRunOn.mock, + params: &RepositoryMockCreatePipelineRunOnParams{ctx, pp1}, + expectationOrigins: RepositoryMockCreatePipelineRunOnExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmCreateNamespacePipelineRelease.expectations = append(mmCreateNamespacePipelineRelease.expectations, expectation) + mmCreatePipelineRunOn.expectations = append(mmCreatePipelineRunOn.expectations, expectation) return expectation } -// Then sets up Repository.CreateNamespacePipelineRelease return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCreateNamespacePipelineReleaseExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockCreateNamespacePipelineReleaseResults{err} +// Then sets up Repository.CreatePipelineRunOn return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCreatePipelineRunOnExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockCreatePipelineRunOnResults{err} return e.mock } -// Times sets number of times Repository.CreateNamespacePipelineRelease should be invoked -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Times(n uint64) *mRepositoryMockCreateNamespacePipelineRelease { +// Times sets number of times Repository.CreatePipelineRunOn should be invoked +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Times(n uint64) *mRepositoryMockCreatePipelineRunOn { if n == 0 { - mmCreateNamespacePipelineRelease.mock.t.Fatalf("Times of RepositoryMock.CreateNamespacePipelineRelease mock can not be zero") + mmCreatePipelineRunOn.mock.t.Fatalf("Times of RepositoryMock.CreatePipelineRunOn mock can not be zero") } - mm_atomic.StoreUint64(&mmCreateNamespacePipelineRelease.expectedInvocations, n) - mmCreateNamespacePipelineRelease.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCreateNamespacePipelineRelease + mm_atomic.StoreUint64(&mmCreatePipelineRunOn.expectedInvocations, n) + mmCreatePipelineRunOn.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreatePipelineRunOn } -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) invocationsDone() bool { - if len(mmCreateNamespacePipelineRelease.expectations) == 0 && mmCreateNamespacePipelineRelease.defaultExpectation == nil && mmCreateNamespacePipelineRelease.mock.funcCreateNamespacePipelineRelease == nil { +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) invocationsDone() bool { + if len(mmCreatePipelineRunOn.expectations) == 0 && mmCreatePipelineRunOn.defaultExpectation == nil && mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.mock.afterCreateNamespacePipelineReleaseCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCreatePipelineRunOn.mock.afterCreatePipelineRunOnCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreatePipelineRunOn.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CreateNamespacePipelineRelease implements mm_repository.Repository -func (mmCreateNamespacePipelineRelease *RepositoryMock) CreateNamespacePipelineRelease(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) (err error) { - mm_atomic.AddUint64(&mmCreateNamespacePipelineRelease.beforeCreateNamespacePipelineReleaseCounter, 1) - defer mm_atomic.AddUint64(&mmCreateNamespacePipelineRelease.afterCreateNamespacePipelineReleaseCounter, 1) +// CreatePipelineRunOn implements mm_repository.Repository +func (mmCreatePipelineRunOn *RepositoryMock) CreatePipelineRunOn(ctx context.Context, pp1 *datamodel.PipelineRunOn) (err error) { + mm_atomic.AddUint64(&mmCreatePipelineRunOn.beforeCreatePipelineRunOnCounter, 1) + defer mm_atomic.AddUint64(&mmCreatePipelineRunOn.afterCreatePipelineRunOnCounter, 1) - mmCreateNamespacePipelineRelease.t.Helper() + mmCreatePipelineRunOn.t.Helper() - if mmCreateNamespacePipelineRelease.inspectFuncCreateNamespacePipelineRelease != nil { - mmCreateNamespacePipelineRelease.inspectFuncCreateNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, pipelineRelease) + if mmCreatePipelineRunOn.inspectFuncCreatePipelineRunOn != nil { + mmCreatePipelineRunOn.inspectFuncCreatePipelineRunOn(ctx, pp1) } - mm_params := RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease} + mm_params := RepositoryMockCreatePipelineRunOnParams{ctx, pp1} // Record call args - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.mutex.Lock() - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.callArgs = append(mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.callArgs, &mm_params) - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.mutex.Unlock() + mmCreatePipelineRunOn.CreatePipelineRunOnMock.mutex.Lock() + mmCreatePipelineRunOn.CreatePipelineRunOnMock.callArgs = append(mmCreatePipelineRunOn.CreatePipelineRunOnMock.callArgs, &mm_params) + mmCreatePipelineRunOn.CreatePipelineRunOnMock.mutex.Unlock() - for _, e := range mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.expectations { + for _, e := range mmCreatePipelineRunOn.CreatePipelineRunOnMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.Counter, 1) - mm_want := mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.params - mm_want_ptrs := mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.paramPtrs + if mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.Counter, 1) + mm_want := mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.params + mm_want_ptrs := mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCreateNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, pipelineRelease} + mm_got := RepositoryMockCreatePipelineRunOnParams{ctx, pp1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) - } - - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + mmCreatePipelineRunOn.t.Errorf("RepositoryMock.CreatePipelineRunOn got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.pipelineRelease != nil && !minimock.Equal(*mm_want_ptrs.pipelineRelease, mm_got.pipelineRelease) { - mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameter pipelineRelease, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originPipelineRelease, *mm_want_ptrs.pipelineRelease, mm_got.pipelineRelease, minimock.Diff(*mm_want_ptrs.pipelineRelease, mm_got.pipelineRelease)) + if mm_want_ptrs.pp1 != nil && !minimock.Equal(*mm_want_ptrs.pp1, mm_got.pp1) { + mmCreatePipelineRunOn.t.Errorf("RepositoryMock.CreatePipelineRunOn got unexpected parameter pp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.originPp1, *mm_want_ptrs.pp1, mm_got.pp1, minimock.Diff(*mm_want_ptrs.pp1, mm_got.pp1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateNamespacePipelineRelease.t.Errorf("RepositoryMock.CreateNamespacePipelineRelease got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreatePipelineRunOn.t.Errorf("RepositoryMock.CreatePipelineRunOn got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCreateNamespacePipelineRelease.CreateNamespacePipelineReleaseMock.defaultExpectation.results + mm_results := mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.results if mm_results == nil { - mmCreateNamespacePipelineRelease.t.Fatal("No results are set for the RepositoryMock.CreateNamespacePipelineRelease") + mmCreatePipelineRunOn.t.Fatal("No results are set for the RepositoryMock.CreatePipelineRunOn") } return (*mm_results).err } - if mmCreateNamespacePipelineRelease.funcCreateNamespacePipelineRelease != nil { - return mmCreateNamespacePipelineRelease.funcCreateNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, pipelineRelease) + if mmCreatePipelineRunOn.funcCreatePipelineRunOn != nil { + return mmCreatePipelineRunOn.funcCreatePipelineRunOn(ctx, pp1) } - mmCreateNamespacePipelineRelease.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespacePipelineRelease. %v %v %v %v", ctx, ownerPermalink, pipelineUID, pipelineRelease) + mmCreatePipelineRunOn.t.Fatalf("Unexpected call to RepositoryMock.CreatePipelineRunOn. %v %v", ctx, pp1) return } -// CreateNamespacePipelineReleaseAfterCounter returns a count of finished RepositoryMock.CreateNamespacePipelineRelease invocations -func (mmCreateNamespacePipelineRelease *RepositoryMock) CreateNamespacePipelineReleaseAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.afterCreateNamespacePipelineReleaseCounter) +// CreatePipelineRunOnAfterCounter returns a count of finished RepositoryMock.CreatePipelineRunOn invocations +func (mmCreatePipelineRunOn *RepositoryMock) CreatePipelineRunOnAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreatePipelineRunOn.afterCreatePipelineRunOnCounter) } -// CreateNamespacePipelineReleaseBeforeCounter returns a count of RepositoryMock.CreateNamespacePipelineRelease invocations -func (mmCreateNamespacePipelineRelease *RepositoryMock) CreateNamespacePipelineReleaseBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespacePipelineRelease.beforeCreateNamespacePipelineReleaseCounter) +// CreatePipelineRunOnBeforeCounter returns a count of RepositoryMock.CreatePipelineRunOn invocations +func (mmCreatePipelineRunOn *RepositoryMock) CreatePipelineRunOnBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreatePipelineRunOn.beforeCreatePipelineRunOnCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespacePipelineRelease. +// Calls returns a list of arguments used in each call to RepositoryMock.CreatePipelineRunOn. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCreateNamespacePipelineRelease *mRepositoryMockCreateNamespacePipelineRelease) Calls() []*RepositoryMockCreateNamespacePipelineReleaseParams { - mmCreateNamespacePipelineRelease.mutex.RLock() +func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Calls() []*RepositoryMockCreatePipelineRunOnParams { + mmCreatePipelineRunOn.mutex.RLock() - argCopy := make([]*RepositoryMockCreateNamespacePipelineReleaseParams, len(mmCreateNamespacePipelineRelease.callArgs)) - copy(argCopy, mmCreateNamespacePipelineRelease.callArgs) + argCopy := make([]*RepositoryMockCreatePipelineRunOnParams, len(mmCreatePipelineRunOn.callArgs)) + copy(argCopy, mmCreatePipelineRunOn.callArgs) - mmCreateNamespacePipelineRelease.mutex.RUnlock() + mmCreatePipelineRunOn.mutex.RUnlock() return argCopy } -// MinimockCreateNamespacePipelineReleaseDone returns true if the count of the CreateNamespacePipelineRelease invocations corresponds +// MinimockCreatePipelineRunOnDone returns true if the count of the CreatePipelineRunOn invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCreateNamespacePipelineReleaseDone() bool { - if m.CreateNamespacePipelineReleaseMock.optional { +func (m *RepositoryMock) MinimockCreatePipelineRunOnDone() bool { + if m.CreatePipelineRunOnMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CreateNamespacePipelineReleaseMock.expectations { + for _, e := range m.CreatePipelineRunOnMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CreateNamespacePipelineReleaseMock.invocationsDone() + return m.CreatePipelineRunOnMock.invocationsDone() } -// MinimockCreateNamespacePipelineReleaseInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCreateNamespacePipelineReleaseInspect() { - for _, e := range m.CreateNamespacePipelineReleaseMock.expectations { +// MinimockCreatePipelineRunOnInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCreatePipelineRunOnInspect() { + for _, e := range m.CreatePipelineRunOnMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCreateNamespacePipelineReleaseCounter := mm_atomic.LoadUint64(&m.afterCreateNamespacePipelineReleaseCounter) + afterCreatePipelineRunOnCounter := mm_atomic.LoadUint64(&m.afterCreatePipelineRunOnCounter) // if default expectation was set then invocations count should be greater than zero - if m.CreateNamespacePipelineReleaseMock.defaultExpectation != nil && afterCreateNamespacePipelineReleaseCounter < 1 { - if m.CreateNamespacePipelineReleaseMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s", m.CreateNamespacePipelineReleaseMock.defaultExpectation.returnOrigin) + if m.CreatePipelineRunOnMock.defaultExpectation != nil && afterCreatePipelineRunOnCounter < 1 { + if m.CreatePipelineRunOnMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s", m.CreatePipelineRunOnMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s with params: %#v", m.CreateNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespacePipelineReleaseMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s with params: %#v", m.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *m.CreatePipelineRunOnMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCreateNamespacePipelineRelease != nil && afterCreateNamespacePipelineReleaseCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespacePipelineRelease at\n%s", m.funcCreateNamespacePipelineReleaseOrigin) + if m.funcCreatePipelineRunOn != nil && afterCreatePipelineRunOnCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s", m.funcCreatePipelineRunOnOrigin) } - if !m.CreateNamespacePipelineReleaseMock.invocationsDone() && afterCreateNamespacePipelineReleaseCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespacePipelineRelease at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CreateNamespacePipelineReleaseMock.expectedInvocations), m.CreateNamespacePipelineReleaseMock.expectedInvocationsOrigin, afterCreateNamespacePipelineReleaseCounter) + if !m.CreatePipelineRunOnMock.invocationsDone() && afterCreatePipelineRunOnCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CreatePipelineRunOn at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreatePipelineRunOnMock.expectedInvocations), m.CreatePipelineRunOnMock.expectedInvocationsOrigin, afterCreatePipelineRunOnCounter) } } -type mRepositoryMockCreateNamespaceSecret struct { +type mRepositoryMockCreatePipelineTags struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCreateNamespaceSecretExpectation - expectations []*RepositoryMockCreateNamespaceSecretExpectation + defaultExpectation *RepositoryMockCreatePipelineTagsExpectation + expectations []*RepositoryMockCreatePipelineTagsExpectation - callArgs []*RepositoryMockCreateNamespaceSecretParams + callArgs []*RepositoryMockCreatePipelineTagsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCreateNamespaceSecretExpectation specifies expectation struct of the Repository.CreateNamespaceSecret -type RepositoryMockCreateNamespaceSecretExpectation struct { +// RepositoryMockCreatePipelineTagsExpectation specifies expectation struct of the Repository.CreatePipelineTags +type RepositoryMockCreatePipelineTagsExpectation struct { mock *RepositoryMock - params *RepositoryMockCreateNamespaceSecretParams - paramPtrs *RepositoryMockCreateNamespaceSecretParamPtrs - expectationOrigins RepositoryMockCreateNamespaceSecretExpectationOrigins - results *RepositoryMockCreateNamespaceSecretResults + params *RepositoryMockCreatePipelineTagsParams + paramPtrs *RepositoryMockCreatePipelineTagsParamPtrs + expectationOrigins RepositoryMockCreatePipelineTagsExpectationOrigins + results *RepositoryMockCreatePipelineTagsResults returnOrigin string Counter uint64 } -// RepositoryMockCreateNamespaceSecretParams contains parameters of the Repository.CreateNamespaceSecret -type RepositoryMockCreateNamespaceSecretParams struct { - ctx context.Context - ownerPermalink string - secret *datamodel.Secret -} - -// RepositoryMockCreateNamespaceSecretParamPtrs contains pointers to parameters of the Repository.CreateNamespaceSecret -type RepositoryMockCreateNamespaceSecretParamPtrs struct { - ctx *context.Context - ownerPermalink *string - secret **datamodel.Secret +// RepositoryMockCreatePipelineTagsParams contains parameters of the Repository.CreatePipelineTags +type RepositoryMockCreatePipelineTagsParams struct { + ctx context.Context + pipelineUID uuid.UUID + tagNames []string } -// RepositoryMockCreateNamespaceSecretResults contains results of the Repository.CreateNamespaceSecret -type RepositoryMockCreateNamespaceSecretResults struct { +// RepositoryMockCreatePipelineTagsParamPtrs contains pointers to parameters of the Repository.CreatePipelineTags +type RepositoryMockCreatePipelineTagsParamPtrs struct { + ctx *context.Context + pipelineUID *uuid.UUID + tagNames *[]string +} + +// RepositoryMockCreatePipelineTagsResults contains results of the Repository.CreatePipelineTags +type RepositoryMockCreatePipelineTagsResults struct { err error } -// RepositoryMockCreateNamespaceSecretOrigins contains origins of expectations of the Repository.CreateNamespaceSecret -type RepositoryMockCreateNamespaceSecretExpectationOrigins struct { - origin string - originCtx string - originOwnerPermalink string - originSecret string +// RepositoryMockCreatePipelineTagsOrigins contains origins of expectations of the Repository.CreatePipelineTags +type RepositoryMockCreatePipelineTagsExpectationOrigins struct { + origin string + originCtx string + originPipelineUID string + originTagNames string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -2791,369 +2822,372 @@ type RepositoryMockCreateNamespaceSecretExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Optional() *mRepositoryMockCreateNamespaceSecret { - mmCreateNamespaceSecret.optional = true - return mmCreateNamespaceSecret +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Optional() *mRepositoryMockCreatePipelineTags { + mmCreatePipelineTags.optional = true + return mmCreatePipelineTags } -// Expect sets up expected params for Repository.CreateNamespaceSecret -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Expect(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) *mRepositoryMockCreateNamespaceSecret { - if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") +// Expect sets up expected params for Repository.CreatePipelineTags +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Expect(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *mRepositoryMockCreatePipelineTags { + if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") } - if mmCreateNamespaceSecret.defaultExpectation == nil { - mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} + if mmCreatePipelineTags.defaultExpectation == nil { + mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} } - if mmCreateNamespaceSecret.defaultExpectation.paramPtrs != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by ExpectParams functions") + if mmCreatePipelineTags.defaultExpectation.paramPtrs != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by ExpectParams functions") } - mmCreateNamespaceSecret.defaultExpectation.params = &RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret} - mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCreateNamespaceSecret.expectations { - if minimock.Equal(e.params, mmCreateNamespaceSecret.defaultExpectation.params) { - mmCreateNamespaceSecret.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateNamespaceSecret.defaultExpectation.params) + mmCreatePipelineTags.defaultExpectation.params = &RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames} + mmCreatePipelineTags.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreatePipelineTags.expectations { + if minimock.Equal(e.params, mmCreatePipelineTags.defaultExpectation.params) { + mmCreatePipelineTags.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreatePipelineTags.defaultExpectation.params) } } - return mmCreateNamespaceSecret + return mmCreatePipelineTags } -// ExpectCtxParam1 sets up expected param ctx for Repository.CreateNamespaceSecret -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreateNamespaceSecret { - if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.CreatePipelineTags +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreatePipelineTags { + if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") } - if mmCreateNamespaceSecret.defaultExpectation == nil { - mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} + if mmCreatePipelineTags.defaultExpectation == nil { + mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} } - if mmCreateNamespaceSecret.defaultExpectation.params != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Expect") + if mmCreatePipelineTags.defaultExpectation.params != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Expect") } - if mmCreateNamespaceSecret.defaultExpectation.paramPtrs == nil { - mmCreateNamespaceSecret.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceSecretParamPtrs{} + if mmCreatePipelineTags.defaultExpectation.paramPtrs == nil { + mmCreatePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineTagsParamPtrs{} } - mmCreateNamespaceSecret.defaultExpectation.paramPtrs.ctx = &ctx - mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmCreatePipelineTags.defaultExpectation.paramPtrs.ctx = &ctx + mmCreatePipelineTags.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCreateNamespaceSecret + return mmCreatePipelineTags } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.CreateNamespaceSecret -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockCreateNamespaceSecret { - if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") +// ExpectPipelineUIDParam2 sets up expected param pipelineUID for Repository.CreatePipelineTags +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) ExpectPipelineUIDParam2(pipelineUID uuid.UUID) *mRepositoryMockCreatePipelineTags { + if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") } - if mmCreateNamespaceSecret.defaultExpectation == nil { - mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} + if mmCreatePipelineTags.defaultExpectation == nil { + mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} } - if mmCreateNamespaceSecret.defaultExpectation.params != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Expect") + if mmCreatePipelineTags.defaultExpectation.params != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Expect") } - if mmCreateNamespaceSecret.defaultExpectation.paramPtrs == nil { - mmCreateNamespaceSecret.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceSecretParamPtrs{} + if mmCreatePipelineTags.defaultExpectation.paramPtrs == nil { + mmCreatePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineTagsParamPtrs{} } - mmCreateNamespaceSecret.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmCreatePipelineTags.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmCreatePipelineTags.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - return mmCreateNamespaceSecret + return mmCreatePipelineTags } -// ExpectSecretParam3 sets up expected param secret for Repository.CreateNamespaceSecret -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) ExpectSecretParam3(secret *datamodel.Secret) *mRepositoryMockCreateNamespaceSecret { - if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") +// ExpectTagNamesParam3 sets up expected param tagNames for Repository.CreatePipelineTags +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) ExpectTagNamesParam3(tagNames []string) *mRepositoryMockCreatePipelineTags { + if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") } - if mmCreateNamespaceSecret.defaultExpectation == nil { - mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{} + if mmCreatePipelineTags.defaultExpectation == nil { + mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} } - if mmCreateNamespaceSecret.defaultExpectation.params != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Expect") + if mmCreatePipelineTags.defaultExpectation.params != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Expect") } - if mmCreateNamespaceSecret.defaultExpectation.paramPtrs == nil { - mmCreateNamespaceSecret.defaultExpectation.paramPtrs = &RepositoryMockCreateNamespaceSecretParamPtrs{} + if mmCreatePipelineTags.defaultExpectation.paramPtrs == nil { + mmCreatePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineTagsParamPtrs{} } - mmCreateNamespaceSecret.defaultExpectation.paramPtrs.secret = &secret - mmCreateNamespaceSecret.defaultExpectation.expectationOrigins.originSecret = minimock.CallerInfo(1) + mmCreatePipelineTags.defaultExpectation.paramPtrs.tagNames = &tagNames + mmCreatePipelineTags.defaultExpectation.expectationOrigins.originTagNames = minimock.CallerInfo(1) - return mmCreateNamespaceSecret + return mmCreatePipelineTags } -// Inspect accepts an inspector function that has same arguments as the Repository.CreateNamespaceSecret -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Inspect(f func(ctx context.Context, ownerPermalink string, secret *datamodel.Secret)) *mRepositoryMockCreateNamespaceSecret { - if mmCreateNamespaceSecret.mock.inspectFuncCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreateNamespaceSecret") +// Inspect accepts an inspector function that has same arguments as the Repository.CreatePipelineTags +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Inspect(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string)) *mRepositoryMockCreatePipelineTags { + if mmCreatePipelineTags.mock.inspectFuncCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreatePipelineTags") } - mmCreateNamespaceSecret.mock.inspectFuncCreateNamespaceSecret = f + mmCreatePipelineTags.mock.inspectFuncCreatePipelineTags = f - return mmCreateNamespaceSecret + return mmCreatePipelineTags } -// Return sets up results that will be returned by Repository.CreateNamespaceSecret -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Return(err error) *RepositoryMock { - if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") +// Return sets up results that will be returned by Repository.CreatePipelineTags +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Return(err error) *RepositoryMock { + if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") } - if mmCreateNamespaceSecret.defaultExpectation == nil { - mmCreateNamespaceSecret.defaultExpectation = &RepositoryMockCreateNamespaceSecretExpectation{mock: mmCreateNamespaceSecret.mock} + if mmCreatePipelineTags.defaultExpectation == nil { + mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{mock: mmCreatePipelineTags.mock} } - mmCreateNamespaceSecret.defaultExpectation.results = &RepositoryMockCreateNamespaceSecretResults{err} - mmCreateNamespaceSecret.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCreateNamespaceSecret.mock + mmCreatePipelineTags.defaultExpectation.results = &RepositoryMockCreatePipelineTagsResults{err} + mmCreatePipelineTags.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreatePipelineTags.mock } -// Set uses given function f to mock the Repository.CreateNamespaceSecret method -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Set(f func(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) (err error)) *RepositoryMock { - if mmCreateNamespaceSecret.defaultExpectation != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("Default expectation is already set for the Repository.CreateNamespaceSecret method") +// Set uses given function f to mock the Repository.CreatePipelineTags method +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Set(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error)) *RepositoryMock { + if mmCreatePipelineTags.defaultExpectation != nil { + mmCreatePipelineTags.mock.t.Fatalf("Default expectation is already set for the Repository.CreatePipelineTags method") } - if len(mmCreateNamespaceSecret.expectations) > 0 { - mmCreateNamespaceSecret.mock.t.Fatalf("Some expectations are already set for the Repository.CreateNamespaceSecret method") + if len(mmCreatePipelineTags.expectations) > 0 { + mmCreatePipelineTags.mock.t.Fatalf("Some expectations are already set for the Repository.CreatePipelineTags method") } - mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret = f - mmCreateNamespaceSecret.mock.funcCreateNamespaceSecretOrigin = minimock.CallerInfo(1) - return mmCreateNamespaceSecret.mock + mmCreatePipelineTags.mock.funcCreatePipelineTags = f + mmCreatePipelineTags.mock.funcCreatePipelineTagsOrigin = minimock.CallerInfo(1) + return mmCreatePipelineTags.mock } -// When sets expectation for the Repository.CreateNamespaceSecret which will trigger the result defined by the following +// When sets expectation for the Repository.CreatePipelineTags which will trigger the result defined by the following // Then helper -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) When(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) *RepositoryMockCreateNamespaceSecretExpectation { - if mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.mock.t.Fatalf("RepositoryMock.CreateNamespaceSecret mock is already set by Set") +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) When(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *RepositoryMockCreatePipelineTagsExpectation { + if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { + mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") } - expectation := &RepositoryMockCreateNamespaceSecretExpectation{ - mock: mmCreateNamespaceSecret.mock, - params: &RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret}, - expectationOrigins: RepositoryMockCreateNamespaceSecretExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockCreatePipelineTagsExpectation{ + mock: mmCreatePipelineTags.mock, + params: &RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames}, + expectationOrigins: RepositoryMockCreatePipelineTagsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmCreateNamespaceSecret.expectations = append(mmCreateNamespaceSecret.expectations, expectation) + mmCreatePipelineTags.expectations = append(mmCreatePipelineTags.expectations, expectation) return expectation } -// Then sets up Repository.CreateNamespaceSecret return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCreateNamespaceSecretExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockCreateNamespaceSecretResults{err} +// Then sets up Repository.CreatePipelineTags return parameters for the expectation previously defined by the When method +func (e *RepositoryMockCreatePipelineTagsExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockCreatePipelineTagsResults{err} return e.mock } -// Times sets number of times Repository.CreateNamespaceSecret should be invoked -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Times(n uint64) *mRepositoryMockCreateNamespaceSecret { +// Times sets number of times Repository.CreatePipelineTags should be invoked +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Times(n uint64) *mRepositoryMockCreatePipelineTags { if n == 0 { - mmCreateNamespaceSecret.mock.t.Fatalf("Times of RepositoryMock.CreateNamespaceSecret mock can not be zero") + mmCreatePipelineTags.mock.t.Fatalf("Times of RepositoryMock.CreatePipelineTags mock can not be zero") } - mm_atomic.StoreUint64(&mmCreateNamespaceSecret.expectedInvocations, n) - mmCreateNamespaceSecret.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCreateNamespaceSecret + mm_atomic.StoreUint64(&mmCreatePipelineTags.expectedInvocations, n) + mmCreatePipelineTags.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreatePipelineTags } -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) invocationsDone() bool { - if len(mmCreateNamespaceSecret.expectations) == 0 && mmCreateNamespaceSecret.defaultExpectation == nil && mmCreateNamespaceSecret.mock.funcCreateNamespaceSecret == nil { +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) invocationsDone() bool { + if len(mmCreatePipelineTags.expectations) == 0 && mmCreatePipelineTags.defaultExpectation == nil && mmCreatePipelineTags.mock.funcCreatePipelineTags == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceSecret.mock.afterCreateNamespaceSecretCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCreateNamespaceSecret.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmCreatePipelineTags.mock.afterCreatePipelineTagsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreatePipelineTags.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CreateNamespaceSecret implements mm_repository.Repository -func (mmCreateNamespaceSecret *RepositoryMock) CreateNamespaceSecret(ctx context.Context, ownerPermalink string, secret *datamodel.Secret) (err error) { - mm_atomic.AddUint64(&mmCreateNamespaceSecret.beforeCreateNamespaceSecretCounter, 1) - defer mm_atomic.AddUint64(&mmCreateNamespaceSecret.afterCreateNamespaceSecretCounter, 1) +// CreatePipelineTags implements mm_repository.Repository +func (mmCreatePipelineTags *RepositoryMock) CreatePipelineTags(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error) { + mm_atomic.AddUint64(&mmCreatePipelineTags.beforeCreatePipelineTagsCounter, 1) + defer mm_atomic.AddUint64(&mmCreatePipelineTags.afterCreatePipelineTagsCounter, 1) - mmCreateNamespaceSecret.t.Helper() + mmCreatePipelineTags.t.Helper() - if mmCreateNamespaceSecret.inspectFuncCreateNamespaceSecret != nil { - mmCreateNamespaceSecret.inspectFuncCreateNamespaceSecret(ctx, ownerPermalink, secret) + if mmCreatePipelineTags.inspectFuncCreatePipelineTags != nil { + mmCreatePipelineTags.inspectFuncCreatePipelineTags(ctx, pipelineUID, tagNames) } - mm_params := RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret} + mm_params := RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames} // Record call args - mmCreateNamespaceSecret.CreateNamespaceSecretMock.mutex.Lock() - mmCreateNamespaceSecret.CreateNamespaceSecretMock.callArgs = append(mmCreateNamespaceSecret.CreateNamespaceSecretMock.callArgs, &mm_params) - mmCreateNamespaceSecret.CreateNamespaceSecretMock.mutex.Unlock() - - for _, e := range mmCreateNamespaceSecret.CreateNamespaceSecretMock.expectations { + mmCreatePipelineTags.CreatePipelineTagsMock.mutex.Lock() + mmCreatePipelineTags.CreatePipelineTagsMock.callArgs = append(mmCreatePipelineTags.CreatePipelineTagsMock.callArgs, &mm_params) + mmCreatePipelineTags.CreatePipelineTagsMock.mutex.Unlock() + + for _, e := range mmCreatePipelineTags.CreatePipelineTagsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.Counter, 1) - mm_want := mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.params - mm_want_ptrs := mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.paramPtrs + if mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.Counter, 1) + mm_want := mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.params + mm_want_ptrs := mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCreateNamespaceSecretParams{ctx, ownerPermalink, secret} + mm_got := RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) } - if mm_want_ptrs.secret != nil && !minimock.Equal(*mm_want_ptrs.secret, mm_got.secret) { - mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameter secret, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.originSecret, *mm_want_ptrs.secret, mm_got.secret, minimock.Diff(*mm_want_ptrs.secret, mm_got.secret)) + if mm_want_ptrs.tagNames != nil && !minimock.Equal(*mm_want_ptrs.tagNames, mm_got.tagNames) { + mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameter tagNames, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.originTagNames, *mm_want_ptrs.tagNames, mm_got.tagNames, minimock.Diff(*mm_want_ptrs.tagNames, mm_got.tagNames)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateNamespaceSecret.t.Errorf("RepositoryMock.CreateNamespaceSecret got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCreateNamespaceSecret.CreateNamespaceSecretMock.defaultExpectation.results + mm_results := mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.results if mm_results == nil { - mmCreateNamespaceSecret.t.Fatal("No results are set for the RepositoryMock.CreateNamespaceSecret") + mmCreatePipelineTags.t.Fatal("No results are set for the RepositoryMock.CreatePipelineTags") } return (*mm_results).err } - if mmCreateNamespaceSecret.funcCreateNamespaceSecret != nil { - return mmCreateNamespaceSecret.funcCreateNamespaceSecret(ctx, ownerPermalink, secret) + if mmCreatePipelineTags.funcCreatePipelineTags != nil { + return mmCreatePipelineTags.funcCreatePipelineTags(ctx, pipelineUID, tagNames) } - mmCreateNamespaceSecret.t.Fatalf("Unexpected call to RepositoryMock.CreateNamespaceSecret. %v %v %v", ctx, ownerPermalink, secret) + mmCreatePipelineTags.t.Fatalf("Unexpected call to RepositoryMock.CreatePipelineTags. %v %v %v", ctx, pipelineUID, tagNames) return } -// CreateNamespaceSecretAfterCounter returns a count of finished RepositoryMock.CreateNamespaceSecret invocations -func (mmCreateNamespaceSecret *RepositoryMock) CreateNamespaceSecretAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespaceSecret.afterCreateNamespaceSecretCounter) +// CreatePipelineTagsAfterCounter returns a count of finished RepositoryMock.CreatePipelineTags invocations +func (mmCreatePipelineTags *RepositoryMock) CreatePipelineTagsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreatePipelineTags.afterCreatePipelineTagsCounter) } -// CreateNamespaceSecretBeforeCounter returns a count of RepositoryMock.CreateNamespaceSecret invocations -func (mmCreateNamespaceSecret *RepositoryMock) CreateNamespaceSecretBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreateNamespaceSecret.beforeCreateNamespaceSecretCounter) +// CreatePipelineTagsBeforeCounter returns a count of RepositoryMock.CreatePipelineTags invocations +func (mmCreatePipelineTags *RepositoryMock) CreatePipelineTagsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreatePipelineTags.beforeCreatePipelineTagsCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CreateNamespaceSecret. +// Calls returns a list of arguments used in each call to RepositoryMock.CreatePipelineTags. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCreateNamespaceSecret *mRepositoryMockCreateNamespaceSecret) Calls() []*RepositoryMockCreateNamespaceSecretParams { - mmCreateNamespaceSecret.mutex.RLock() +func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Calls() []*RepositoryMockCreatePipelineTagsParams { + mmCreatePipelineTags.mutex.RLock() - argCopy := make([]*RepositoryMockCreateNamespaceSecretParams, len(mmCreateNamespaceSecret.callArgs)) - copy(argCopy, mmCreateNamespaceSecret.callArgs) + argCopy := make([]*RepositoryMockCreatePipelineTagsParams, len(mmCreatePipelineTags.callArgs)) + copy(argCopy, mmCreatePipelineTags.callArgs) - mmCreateNamespaceSecret.mutex.RUnlock() + mmCreatePipelineTags.mutex.RUnlock() return argCopy } -// MinimockCreateNamespaceSecretDone returns true if the count of the CreateNamespaceSecret invocations corresponds +// MinimockCreatePipelineTagsDone returns true if the count of the CreatePipelineTags invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCreateNamespaceSecretDone() bool { - if m.CreateNamespaceSecretMock.optional { +func (m *RepositoryMock) MinimockCreatePipelineTagsDone() bool { + if m.CreatePipelineTagsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CreateNamespaceSecretMock.expectations { + for _, e := range m.CreatePipelineTagsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CreateNamespaceSecretMock.invocationsDone() + return m.CreatePipelineTagsMock.invocationsDone() } -// MinimockCreateNamespaceSecretInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCreateNamespaceSecretInspect() { - for _, e := range m.CreateNamespaceSecretMock.expectations { +// MinimockCreatePipelineTagsInspect logs each unmet expectation +func (m *RepositoryMock) MinimockCreatePipelineTagsInspect() { + for _, e := range m.CreatePipelineTagsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCreateNamespaceSecretCounter := mm_atomic.LoadUint64(&m.afterCreateNamespaceSecretCounter) + afterCreatePipelineTagsCounter := mm_atomic.LoadUint64(&m.afterCreatePipelineTagsCounter) // if default expectation was set then invocations count should be greater than zero - if m.CreateNamespaceSecretMock.defaultExpectation != nil && afterCreateNamespaceSecretCounter < 1 { - if m.CreateNamespaceSecretMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s", m.CreateNamespaceSecretMock.defaultExpectation.returnOrigin) + if m.CreatePipelineTagsMock.defaultExpectation != nil && afterCreatePipelineTagsCounter < 1 { + if m.CreatePipelineTagsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s", m.CreatePipelineTagsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s with params: %#v", m.CreateNamespaceSecretMock.defaultExpectation.expectationOrigins.origin, *m.CreateNamespaceSecretMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s with params: %#v", m.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *m.CreatePipelineTagsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCreateNamespaceSecret != nil && afterCreateNamespaceSecretCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreateNamespaceSecret at\n%s", m.funcCreateNamespaceSecretOrigin) + if m.funcCreatePipelineTags != nil && afterCreatePipelineTagsCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s", m.funcCreatePipelineTagsOrigin) } - if !m.CreateNamespaceSecretMock.invocationsDone() && afterCreateNamespaceSecretCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CreateNamespaceSecret at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CreateNamespaceSecretMock.expectedInvocations), m.CreateNamespaceSecretMock.expectedInvocationsOrigin, afterCreateNamespaceSecretCounter) + if !m.CreatePipelineTagsMock.invocationsDone() && afterCreatePipelineTagsCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.CreatePipelineTags at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreatePipelineTagsMock.expectedInvocations), m.CreatePipelineTagsMock.expectedInvocationsOrigin, afterCreatePipelineTagsCounter) } } -type mRepositoryMockCreatePipelineRunOn struct { +type mRepositoryMockDeleteNamespaceConnectionByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCreatePipelineRunOnExpectation - expectations []*RepositoryMockCreatePipelineRunOnExpectation + defaultExpectation *RepositoryMockDeleteNamespaceConnectionByIDExpectation + expectations []*RepositoryMockDeleteNamespaceConnectionByIDExpectation - callArgs []*RepositoryMockCreatePipelineRunOnParams + callArgs []*RepositoryMockDeleteNamespaceConnectionByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCreatePipelineRunOnExpectation specifies expectation struct of the Repository.CreatePipelineRunOn -type RepositoryMockCreatePipelineRunOnExpectation struct { +// RepositoryMockDeleteNamespaceConnectionByIDExpectation specifies expectation struct of the Repository.DeleteNamespaceConnectionByID +type RepositoryMockDeleteNamespaceConnectionByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockCreatePipelineRunOnParams - paramPtrs *RepositoryMockCreatePipelineRunOnParamPtrs - expectationOrigins RepositoryMockCreatePipelineRunOnExpectationOrigins - results *RepositoryMockCreatePipelineRunOnResults + params *RepositoryMockDeleteNamespaceConnectionByIDParams + paramPtrs *RepositoryMockDeleteNamespaceConnectionByIDParamPtrs + expectationOrigins RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins + results *RepositoryMockDeleteNamespaceConnectionByIDResults returnOrigin string Counter uint64 } -// RepositoryMockCreatePipelineRunOnParams contains parameters of the Repository.CreatePipelineRunOn -type RepositoryMockCreatePipelineRunOnParams struct { - ctx context.Context - pp1 *datamodel.PipelineRunOn +// RepositoryMockDeleteNamespaceConnectionByIDParams contains parameters of the Repository.DeleteNamespaceConnectionByID +type RepositoryMockDeleteNamespaceConnectionByIDParams struct { + ctx context.Context + nsUID uuid.UUID + id string } -// RepositoryMockCreatePipelineRunOnParamPtrs contains pointers to parameters of the Repository.CreatePipelineRunOn -type RepositoryMockCreatePipelineRunOnParamPtrs struct { - ctx *context.Context - pp1 **datamodel.PipelineRunOn +// RepositoryMockDeleteNamespaceConnectionByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespaceConnectionByID +type RepositoryMockDeleteNamespaceConnectionByIDParamPtrs struct { + ctx *context.Context + nsUID *uuid.UUID + id *string } -// RepositoryMockCreatePipelineRunOnResults contains results of the Repository.CreatePipelineRunOn -type RepositoryMockCreatePipelineRunOnResults struct { +// RepositoryMockDeleteNamespaceConnectionByIDResults contains results of the Repository.DeleteNamespaceConnectionByID +type RepositoryMockDeleteNamespaceConnectionByIDResults struct { err error } -// RepositoryMockCreatePipelineRunOnOrigins contains origins of expectations of the Repository.CreatePipelineRunOn -type RepositoryMockCreatePipelineRunOnExpectationOrigins struct { - origin string - originCtx string - originPp1 string +// RepositoryMockDeleteNamespaceConnectionByIDOrigins contains origins of expectations of the Repository.DeleteNamespaceConnectionByID +type RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins struct { + origin string + originCtx string + originNsUID string + originId string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -3161,344 +3195,372 @@ type RepositoryMockCreatePipelineRunOnExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Optional() *mRepositoryMockCreatePipelineRunOn { - mmCreatePipelineRunOn.optional = true - return mmCreatePipelineRunOn +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Optional() *mRepositoryMockDeleteNamespaceConnectionByID { + mmDeleteNamespaceConnectionByID.optional = true + return mmDeleteNamespaceConnectionByID } -// Expect sets up expected params for Repository.CreatePipelineRunOn -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Expect(ctx context.Context, pp1 *datamodel.PipelineRunOn) *mRepositoryMockCreatePipelineRunOn { - if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") +// Expect sets up expected params for Repository.DeleteNamespaceConnectionByID +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Expect(ctx context.Context, nsUID uuid.UUID, id string) *mRepositoryMockDeleteNamespaceConnectionByID { + if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") } - if mmCreatePipelineRunOn.defaultExpectation == nil { - mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{} + if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} } - if mmCreatePipelineRunOn.defaultExpectation.paramPtrs != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by ExpectParams functions") + if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by ExpectParams functions") } - mmCreatePipelineRunOn.defaultExpectation.params = &RepositoryMockCreatePipelineRunOnParams{ctx, pp1} - mmCreatePipelineRunOn.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCreatePipelineRunOn.expectations { - if minimock.Equal(e.params, mmCreatePipelineRunOn.defaultExpectation.params) { - mmCreatePipelineRunOn.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreatePipelineRunOn.defaultExpectation.params) + mmDeleteNamespaceConnectionByID.defaultExpectation.params = &RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id} + mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteNamespaceConnectionByID.expectations { + if minimock.Equal(e.params, mmDeleteNamespaceConnectionByID.defaultExpectation.params) { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespaceConnectionByID.defaultExpectation.params) } } - return mmCreatePipelineRunOn + return mmDeleteNamespaceConnectionByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.CreatePipelineRunOn -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreatePipelineRunOn { - if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespaceConnectionByID +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespaceConnectionByID { + if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") } - if mmCreatePipelineRunOn.defaultExpectation == nil { - mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{} + if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} } - if mmCreatePipelineRunOn.defaultExpectation.params != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Expect") + if mmDeleteNamespaceConnectionByID.defaultExpectation.params != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Expect") } - if mmCreatePipelineRunOn.defaultExpectation.paramPtrs == nil { - mmCreatePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineRunOnParamPtrs{} + if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceConnectionByIDParamPtrs{} } - mmCreatePipelineRunOn.defaultExpectation.paramPtrs.ctx = &ctx - mmCreatePipelineRunOn.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCreatePipelineRunOn + return mmDeleteNamespaceConnectionByID } -// ExpectPp1Param2 sets up expected param pp1 for Repository.CreatePipelineRunOn -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) ExpectPp1Param2(pp1 *datamodel.PipelineRunOn) *mRepositoryMockCreatePipelineRunOn { - if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") +// ExpectNsUIDParam2 sets up expected param nsUID for Repository.DeleteNamespaceConnectionByID +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) ExpectNsUIDParam2(nsUID uuid.UUID) *mRepositoryMockDeleteNamespaceConnectionByID { + if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") } - if mmCreatePipelineRunOn.defaultExpectation == nil { - mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{} + if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} } - if mmCreatePipelineRunOn.defaultExpectation.params != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Expect") + if mmDeleteNamespaceConnectionByID.defaultExpectation.params != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Expect") } - if mmCreatePipelineRunOn.defaultExpectation.paramPtrs == nil { - mmCreatePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineRunOnParamPtrs{} + if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceConnectionByIDParamPtrs{} } - mmCreatePipelineRunOn.defaultExpectation.paramPtrs.pp1 = &pp1 - mmCreatePipelineRunOn.defaultExpectation.expectationOrigins.originPp1 = minimock.CallerInfo(1) + mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs.nsUID = &nsUID + mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.originNsUID = minimock.CallerInfo(1) - return mmCreatePipelineRunOn + return mmDeleteNamespaceConnectionByID } -// Inspect accepts an inspector function that has same arguments as the Repository.CreatePipelineRunOn -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Inspect(f func(ctx context.Context, pp1 *datamodel.PipelineRunOn)) *mRepositoryMockCreatePipelineRunOn { - if mmCreatePipelineRunOn.mock.inspectFuncCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreatePipelineRunOn") +// ExpectIdParam3 sets up expected param id for Repository.DeleteNamespaceConnectionByID +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) ExpectIdParam3(id string) *mRepositoryMockDeleteNamespaceConnectionByID { + if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") } - mmCreatePipelineRunOn.mock.inspectFuncCreatePipelineRunOn = f + if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} + } - return mmCreatePipelineRunOn + if mmDeleteNamespaceConnectionByID.defaultExpectation.params != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Expect") + } + + if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceConnectionByIDParamPtrs{} + } + mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs.id = &id + mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + + return mmDeleteNamespaceConnectionByID } -// Return sets up results that will be returned by Repository.CreatePipelineRunOn -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Return(err error) *RepositoryMock { - if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespaceConnectionByID +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Inspect(f func(ctx context.Context, nsUID uuid.UUID, id string)) *mRepositoryMockDeleteNamespaceConnectionByID { + if mmDeleteNamespaceConnectionByID.mock.inspectFuncDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespaceConnectionByID") } - if mmCreatePipelineRunOn.defaultExpectation == nil { - mmCreatePipelineRunOn.defaultExpectation = &RepositoryMockCreatePipelineRunOnExpectation{mock: mmCreatePipelineRunOn.mock} + mmDeleteNamespaceConnectionByID.mock.inspectFuncDeleteNamespaceConnectionByID = f + + return mmDeleteNamespaceConnectionByID +} + +// Return sets up results that will be returned by Repository.DeleteNamespaceConnectionByID +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Return(err error) *RepositoryMock { + if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") } - mmCreatePipelineRunOn.defaultExpectation.results = &RepositoryMockCreatePipelineRunOnResults{err} - mmCreatePipelineRunOn.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCreatePipelineRunOn.mock + + if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { + mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{mock: mmDeleteNamespaceConnectionByID.mock} + } + mmDeleteNamespaceConnectionByID.defaultExpectation.results = &RepositoryMockDeleteNamespaceConnectionByIDResults{err} + mmDeleteNamespaceConnectionByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteNamespaceConnectionByID.mock } -// Set uses given function f to mock the Repository.CreatePipelineRunOn method -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Set(f func(ctx context.Context, pp1 *datamodel.PipelineRunOn) (err error)) *RepositoryMock { - if mmCreatePipelineRunOn.defaultExpectation != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("Default expectation is already set for the Repository.CreatePipelineRunOn method") +// Set uses given function f to mock the Repository.DeleteNamespaceConnectionByID method +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Set(f func(ctx context.Context, nsUID uuid.UUID, id string) (err error)) *RepositoryMock { + if mmDeleteNamespaceConnectionByID.defaultExpectation != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespaceConnectionByID method") } - if len(mmCreatePipelineRunOn.expectations) > 0 { - mmCreatePipelineRunOn.mock.t.Fatalf("Some expectations are already set for the Repository.CreatePipelineRunOn method") + if len(mmDeleteNamespaceConnectionByID.expectations) > 0 { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespaceConnectionByID method") } - mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn = f - mmCreatePipelineRunOn.mock.funcCreatePipelineRunOnOrigin = minimock.CallerInfo(1) - return mmCreatePipelineRunOn.mock + mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID = f + mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByIDOrigin = minimock.CallerInfo(1) + return mmDeleteNamespaceConnectionByID.mock } -// When sets expectation for the Repository.CreatePipelineRunOn which will trigger the result defined by the following +// When sets expectation for the Repository.DeleteNamespaceConnectionByID which will trigger the result defined by the following // Then helper -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) When(ctx context.Context, pp1 *datamodel.PipelineRunOn) *RepositoryMockCreatePipelineRunOnExpectation { - if mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.mock.t.Fatalf("RepositoryMock.CreatePipelineRunOn mock is already set by Set") +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) When(ctx context.Context, nsUID uuid.UUID, id string) *RepositoryMockDeleteNamespaceConnectionByIDExpectation { + if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") } - expectation := &RepositoryMockCreatePipelineRunOnExpectation{ - mock: mmCreatePipelineRunOn.mock, - params: &RepositoryMockCreatePipelineRunOnParams{ctx, pp1}, - expectationOrigins: RepositoryMockCreatePipelineRunOnExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockDeleteNamespaceConnectionByIDExpectation{ + mock: mmDeleteNamespaceConnectionByID.mock, + params: &RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id}, + expectationOrigins: RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmCreatePipelineRunOn.expectations = append(mmCreatePipelineRunOn.expectations, expectation) + mmDeleteNamespaceConnectionByID.expectations = append(mmDeleteNamespaceConnectionByID.expectations, expectation) return expectation } -// Then sets up Repository.CreatePipelineRunOn return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCreatePipelineRunOnExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockCreatePipelineRunOnResults{err} +// Then sets up Repository.DeleteNamespaceConnectionByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockDeleteNamespaceConnectionByIDExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockDeleteNamespaceConnectionByIDResults{err} return e.mock } -// Times sets number of times Repository.CreatePipelineRunOn should be invoked -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Times(n uint64) *mRepositoryMockCreatePipelineRunOn { +// Times sets number of times Repository.DeleteNamespaceConnectionByID should be invoked +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Times(n uint64) *mRepositoryMockDeleteNamespaceConnectionByID { if n == 0 { - mmCreatePipelineRunOn.mock.t.Fatalf("Times of RepositoryMock.CreatePipelineRunOn mock can not be zero") + mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespaceConnectionByID mock can not be zero") } - mm_atomic.StoreUint64(&mmCreatePipelineRunOn.expectedInvocations, n) - mmCreatePipelineRunOn.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCreatePipelineRunOn + mm_atomic.StoreUint64(&mmDeleteNamespaceConnectionByID.expectedInvocations, n) + mmDeleteNamespaceConnectionByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteNamespaceConnectionByID } -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) invocationsDone() bool { - if len(mmCreatePipelineRunOn.expectations) == 0 && mmCreatePipelineRunOn.defaultExpectation == nil && mmCreatePipelineRunOn.mock.funcCreatePipelineRunOn == nil { +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) invocationsDone() bool { + if len(mmDeleteNamespaceConnectionByID.expectations) == 0 && mmDeleteNamespaceConnectionByID.defaultExpectation == nil && mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCreatePipelineRunOn.mock.afterCreatePipelineRunOnCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCreatePipelineRunOn.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.mock.afterDeleteNamespaceConnectionByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CreatePipelineRunOn implements mm_repository.Repository -func (mmCreatePipelineRunOn *RepositoryMock) CreatePipelineRunOn(ctx context.Context, pp1 *datamodel.PipelineRunOn) (err error) { - mm_atomic.AddUint64(&mmCreatePipelineRunOn.beforeCreatePipelineRunOnCounter, 1) - defer mm_atomic.AddUint64(&mmCreatePipelineRunOn.afterCreatePipelineRunOnCounter, 1) +// DeleteNamespaceConnectionByID implements mm_repository.Repository +func (mmDeleteNamespaceConnectionByID *RepositoryMock) DeleteNamespaceConnectionByID(ctx context.Context, nsUID uuid.UUID, id string) (err error) { + mm_atomic.AddUint64(&mmDeleteNamespaceConnectionByID.beforeDeleteNamespaceConnectionByIDCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteNamespaceConnectionByID.afterDeleteNamespaceConnectionByIDCounter, 1) - mmCreatePipelineRunOn.t.Helper() + mmDeleteNamespaceConnectionByID.t.Helper() - if mmCreatePipelineRunOn.inspectFuncCreatePipelineRunOn != nil { - mmCreatePipelineRunOn.inspectFuncCreatePipelineRunOn(ctx, pp1) + if mmDeleteNamespaceConnectionByID.inspectFuncDeleteNamespaceConnectionByID != nil { + mmDeleteNamespaceConnectionByID.inspectFuncDeleteNamespaceConnectionByID(ctx, nsUID, id) } - mm_params := RepositoryMockCreatePipelineRunOnParams{ctx, pp1} + mm_params := RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id} // Record call args - mmCreatePipelineRunOn.CreatePipelineRunOnMock.mutex.Lock() - mmCreatePipelineRunOn.CreatePipelineRunOnMock.callArgs = append(mmCreatePipelineRunOn.CreatePipelineRunOnMock.callArgs, &mm_params) - mmCreatePipelineRunOn.CreatePipelineRunOnMock.mutex.Unlock() + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.mutex.Lock() + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.callArgs = append(mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.callArgs, &mm_params) + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.mutex.Unlock() - for _, e := range mmCreatePipelineRunOn.CreatePipelineRunOnMock.expectations { + for _, e := range mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.Counter, 1) - mm_want := mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.params - mm_want_ptrs := mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.paramPtrs + if mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.params + mm_want_ptrs := mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCreatePipelineRunOnParams{ctx, pp1} + mm_got := RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreatePipelineRunOn.t.Errorf("RepositoryMock.CreatePipelineRunOn got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.pp1 != nil && !minimock.Equal(*mm_want_ptrs.pp1, mm_got.pp1) { - mmCreatePipelineRunOn.t.Errorf("RepositoryMock.CreatePipelineRunOn got unexpected parameter pp1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.originPp1, *mm_want_ptrs.pp1, mm_got.pp1, minimock.Diff(*mm_want_ptrs.pp1, mm_got.pp1)) + if mm_want_ptrs.nsUID != nil && !minimock.Equal(*mm_want_ptrs.nsUID, mm_got.nsUID) { + mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameter nsUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originNsUID, *mm_want_ptrs.nsUID, mm_got.nsUID, minimock.Diff(*mm_want_ptrs.nsUID, mm_got.nsUID)) + } + + if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { + mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreatePipelineRunOn.t.Errorf("RepositoryMock.CreatePipelineRunOn got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCreatePipelineRunOn.CreatePipelineRunOnMock.defaultExpectation.results + mm_results := mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.results if mm_results == nil { - mmCreatePipelineRunOn.t.Fatal("No results are set for the RepositoryMock.CreatePipelineRunOn") + mmDeleteNamespaceConnectionByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespaceConnectionByID") } return (*mm_results).err } - if mmCreatePipelineRunOn.funcCreatePipelineRunOn != nil { - return mmCreatePipelineRunOn.funcCreatePipelineRunOn(ctx, pp1) + if mmDeleteNamespaceConnectionByID.funcDeleteNamespaceConnectionByID != nil { + return mmDeleteNamespaceConnectionByID.funcDeleteNamespaceConnectionByID(ctx, nsUID, id) } - mmCreatePipelineRunOn.t.Fatalf("Unexpected call to RepositoryMock.CreatePipelineRunOn. %v %v", ctx, pp1) + mmDeleteNamespaceConnectionByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespaceConnectionByID. %v %v %v", ctx, nsUID, id) return } -// CreatePipelineRunOnAfterCounter returns a count of finished RepositoryMock.CreatePipelineRunOn invocations -func (mmCreatePipelineRunOn *RepositoryMock) CreatePipelineRunOnAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreatePipelineRunOn.afterCreatePipelineRunOnCounter) +// DeleteNamespaceConnectionByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespaceConnectionByID invocations +func (mmDeleteNamespaceConnectionByID *RepositoryMock) DeleteNamespaceConnectionByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.afterDeleteNamespaceConnectionByIDCounter) } -// CreatePipelineRunOnBeforeCounter returns a count of RepositoryMock.CreatePipelineRunOn invocations -func (mmCreatePipelineRunOn *RepositoryMock) CreatePipelineRunOnBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreatePipelineRunOn.beforeCreatePipelineRunOnCounter) +// DeleteNamespaceConnectionByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespaceConnectionByID invocations +func (mmDeleteNamespaceConnectionByID *RepositoryMock) DeleteNamespaceConnectionByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.beforeDeleteNamespaceConnectionByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CreatePipelineRunOn. +// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespaceConnectionByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCreatePipelineRunOn *mRepositoryMockCreatePipelineRunOn) Calls() []*RepositoryMockCreatePipelineRunOnParams { - mmCreatePipelineRunOn.mutex.RLock() +func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Calls() []*RepositoryMockDeleteNamespaceConnectionByIDParams { + mmDeleteNamespaceConnectionByID.mutex.RLock() - argCopy := make([]*RepositoryMockCreatePipelineRunOnParams, len(mmCreatePipelineRunOn.callArgs)) - copy(argCopy, mmCreatePipelineRunOn.callArgs) + argCopy := make([]*RepositoryMockDeleteNamespaceConnectionByIDParams, len(mmDeleteNamespaceConnectionByID.callArgs)) + copy(argCopy, mmDeleteNamespaceConnectionByID.callArgs) - mmCreatePipelineRunOn.mutex.RUnlock() + mmDeleteNamespaceConnectionByID.mutex.RUnlock() return argCopy } -// MinimockCreatePipelineRunOnDone returns true if the count of the CreatePipelineRunOn invocations corresponds +// MinimockDeleteNamespaceConnectionByIDDone returns true if the count of the DeleteNamespaceConnectionByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCreatePipelineRunOnDone() bool { - if m.CreatePipelineRunOnMock.optional { +func (m *RepositoryMock) MinimockDeleteNamespaceConnectionByIDDone() bool { + if m.DeleteNamespaceConnectionByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CreatePipelineRunOnMock.expectations { + for _, e := range m.DeleteNamespaceConnectionByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CreatePipelineRunOnMock.invocationsDone() + return m.DeleteNamespaceConnectionByIDMock.invocationsDone() } -// MinimockCreatePipelineRunOnInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCreatePipelineRunOnInspect() { - for _, e := range m.CreatePipelineRunOnMock.expectations { +// MinimockDeleteNamespaceConnectionByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockDeleteNamespaceConnectionByIDInspect() { + for _, e := range m.DeleteNamespaceConnectionByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCreatePipelineRunOnCounter := mm_atomic.LoadUint64(&m.afterCreatePipelineRunOnCounter) + afterDeleteNamespaceConnectionByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespaceConnectionByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.CreatePipelineRunOnMock.defaultExpectation != nil && afterCreatePipelineRunOnCounter < 1 { - if m.CreatePipelineRunOnMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s", m.CreatePipelineRunOnMock.defaultExpectation.returnOrigin) + if m.DeleteNamespaceConnectionByIDMock.defaultExpectation != nil && afterDeleteNamespaceConnectionByIDCounter < 1 { + if m.DeleteNamespaceConnectionByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s", m.DeleteNamespaceConnectionByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s with params: %#v", m.CreatePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *m.CreatePipelineRunOnMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s with params: %#v", m.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespaceConnectionByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCreatePipelineRunOn != nil && afterCreatePipelineRunOnCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineRunOn at\n%s", m.funcCreatePipelineRunOnOrigin) + if m.funcDeleteNamespaceConnectionByID != nil && afterDeleteNamespaceConnectionByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s", m.funcDeleteNamespaceConnectionByIDOrigin) } - if !m.CreatePipelineRunOnMock.invocationsDone() && afterCreatePipelineRunOnCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CreatePipelineRunOn at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CreatePipelineRunOnMock.expectedInvocations), m.CreatePipelineRunOnMock.expectedInvocationsOrigin, afterCreatePipelineRunOnCounter) + if !m.DeleteNamespaceConnectionByIDMock.invocationsDone() && afterDeleteNamespaceConnectionByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespaceConnectionByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteNamespaceConnectionByIDMock.expectedInvocations), m.DeleteNamespaceConnectionByIDMock.expectedInvocationsOrigin, afterDeleteNamespaceConnectionByIDCounter) } } -type mRepositoryMockCreatePipelineTags struct { +type mRepositoryMockDeleteNamespacePipelineByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockCreatePipelineTagsExpectation - expectations []*RepositoryMockCreatePipelineTagsExpectation + defaultExpectation *RepositoryMockDeleteNamespacePipelineByIDExpectation + expectations []*RepositoryMockDeleteNamespacePipelineByIDExpectation - callArgs []*RepositoryMockCreatePipelineTagsParams + callArgs []*RepositoryMockDeleteNamespacePipelineByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockCreatePipelineTagsExpectation specifies expectation struct of the Repository.CreatePipelineTags -type RepositoryMockCreatePipelineTagsExpectation struct { +// RepositoryMockDeleteNamespacePipelineByIDExpectation specifies expectation struct of the Repository.DeleteNamespacePipelineByID +type RepositoryMockDeleteNamespacePipelineByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockCreatePipelineTagsParams - paramPtrs *RepositoryMockCreatePipelineTagsParamPtrs - expectationOrigins RepositoryMockCreatePipelineTagsExpectationOrigins - results *RepositoryMockCreatePipelineTagsResults + params *RepositoryMockDeleteNamespacePipelineByIDParams + paramPtrs *RepositoryMockDeleteNamespacePipelineByIDParamPtrs + expectationOrigins RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins + results *RepositoryMockDeleteNamespacePipelineByIDResults returnOrigin string Counter uint64 } -// RepositoryMockCreatePipelineTagsParams contains parameters of the Repository.CreatePipelineTags -type RepositoryMockCreatePipelineTagsParams struct { - ctx context.Context - pipelineUID uuid.UUID - tagNames []string +// RepositoryMockDeleteNamespacePipelineByIDParams contains parameters of the Repository.DeleteNamespacePipelineByID +type RepositoryMockDeleteNamespacePipelineByIDParams struct { + ctx context.Context + ownerPermalink string + id string } -// RepositoryMockCreatePipelineTagsParamPtrs contains pointers to parameters of the Repository.CreatePipelineTags -type RepositoryMockCreatePipelineTagsParamPtrs struct { - ctx *context.Context - pipelineUID *uuid.UUID - tagNames *[]string +// RepositoryMockDeleteNamespacePipelineByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespacePipelineByID +type RepositoryMockDeleteNamespacePipelineByIDParamPtrs struct { + ctx *context.Context + ownerPermalink *string + id *string } -// RepositoryMockCreatePipelineTagsResults contains results of the Repository.CreatePipelineTags -type RepositoryMockCreatePipelineTagsResults struct { +// RepositoryMockDeleteNamespacePipelineByIDResults contains results of the Repository.DeleteNamespacePipelineByID +type RepositoryMockDeleteNamespacePipelineByIDResults struct { err error } -// RepositoryMockCreatePipelineTagsOrigins contains origins of expectations of the Repository.CreatePipelineTags -type RepositoryMockCreatePipelineTagsExpectationOrigins struct { - origin string - originCtx string - originPipelineUID string - originTagNames string +// RepositoryMockDeleteNamespacePipelineByIDOrigins contains origins of expectations of the Repository.DeleteNamespacePipelineByID +type RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins struct { + origin string + originCtx string + originOwnerPermalink string + originId string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -3506,372 +3568,375 @@ type RepositoryMockCreatePipelineTagsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Optional() *mRepositoryMockCreatePipelineTags { - mmCreatePipelineTags.optional = true - return mmCreatePipelineTags +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Optional() *mRepositoryMockDeleteNamespacePipelineByID { + mmDeleteNamespacePipelineByID.optional = true + return mmDeleteNamespacePipelineByID } -// Expect sets up expected params for Repository.CreatePipelineTags -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Expect(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *mRepositoryMockCreatePipelineTags { - if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") +// Expect sets up expected params for Repository.DeleteNamespacePipelineByID +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Expect(ctx context.Context, ownerPermalink string, id string) *mRepositoryMockDeleteNamespacePipelineByID { + if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") } - if mmCreatePipelineTags.defaultExpectation == nil { - mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} + if mmDeleteNamespacePipelineByID.defaultExpectation == nil { + mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} } - if mmCreatePipelineTags.defaultExpectation.paramPtrs != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by ExpectParams functions") + if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by ExpectParams functions") } - mmCreatePipelineTags.defaultExpectation.params = &RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames} - mmCreatePipelineTags.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmCreatePipelineTags.expectations { - if minimock.Equal(e.params, mmCreatePipelineTags.defaultExpectation.params) { - mmCreatePipelineTags.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreatePipelineTags.defaultExpectation.params) + mmDeleteNamespacePipelineByID.defaultExpectation.params = &RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id} + mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteNamespacePipelineByID.expectations { + if minimock.Equal(e.params, mmDeleteNamespacePipelineByID.defaultExpectation.params) { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespacePipelineByID.defaultExpectation.params) } } - return mmCreatePipelineTags + return mmDeleteNamespacePipelineByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.CreatePipelineTags -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) ExpectCtxParam1(ctx context.Context) *mRepositoryMockCreatePipelineTags { - if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespacePipelineByID +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespacePipelineByID { + if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") } - if mmCreatePipelineTags.defaultExpectation == nil { - mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} + if mmDeleteNamespacePipelineByID.defaultExpectation == nil { + mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} } - if mmCreatePipelineTags.defaultExpectation.params != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Expect") + if mmDeleteNamespacePipelineByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Expect") } - if mmCreatePipelineTags.defaultExpectation.paramPtrs == nil { - mmCreatePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineTagsParamPtrs{} + if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineByIDParamPtrs{} } - mmCreatePipelineTags.defaultExpectation.paramPtrs.ctx = &ctx - mmCreatePipelineTags.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmCreatePipelineTags + return mmDeleteNamespacePipelineByID } -// ExpectPipelineUIDParam2 sets up expected param pipelineUID for Repository.CreatePipelineTags -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) ExpectPipelineUIDParam2(pipelineUID uuid.UUID) *mRepositoryMockCreatePipelineTags { - if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.DeleteNamespacePipelineByID +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockDeleteNamespacePipelineByID { + if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") } - if mmCreatePipelineTags.defaultExpectation == nil { - mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} + if mmDeleteNamespacePipelineByID.defaultExpectation == nil { + mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} } - if mmCreatePipelineTags.defaultExpectation.params != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Expect") + if mmDeleteNamespacePipelineByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Expect") } - if mmCreatePipelineTags.defaultExpectation.paramPtrs == nil { - mmCreatePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineTagsParamPtrs{} + if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineByIDParamPtrs{} } - mmCreatePipelineTags.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmCreatePipelineTags.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) + mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmCreatePipelineTags + return mmDeleteNamespacePipelineByID } -// ExpectTagNamesParam3 sets up expected param tagNames for Repository.CreatePipelineTags -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) ExpectTagNamesParam3(tagNames []string) *mRepositoryMockCreatePipelineTags { - if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") +// ExpectIdParam3 sets up expected param id for Repository.DeleteNamespacePipelineByID +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) ExpectIdParam3(id string) *mRepositoryMockDeleteNamespacePipelineByID { + if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") } - if mmCreatePipelineTags.defaultExpectation == nil { - mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{} + if mmDeleteNamespacePipelineByID.defaultExpectation == nil { + mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} } - if mmCreatePipelineTags.defaultExpectation.params != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Expect") + if mmDeleteNamespacePipelineByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Expect") } - if mmCreatePipelineTags.defaultExpectation.paramPtrs == nil { - mmCreatePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockCreatePipelineTagsParamPtrs{} + if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineByIDParamPtrs{} } - mmCreatePipelineTags.defaultExpectation.paramPtrs.tagNames = &tagNames - mmCreatePipelineTags.defaultExpectation.expectationOrigins.originTagNames = minimock.CallerInfo(1) + mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs.id = &id + mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) - return mmCreatePipelineTags + return mmDeleteNamespacePipelineByID } -// Inspect accepts an inspector function that has same arguments as the Repository.CreatePipelineTags -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Inspect(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string)) *mRepositoryMockCreatePipelineTags { - if mmCreatePipelineTags.mock.inspectFuncCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("Inspect function is already set for RepositoryMock.CreatePipelineTags") +// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespacePipelineByID +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string)) *mRepositoryMockDeleteNamespacePipelineByID { + if mmDeleteNamespacePipelineByID.mock.inspectFuncDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespacePipelineByID") } - mmCreatePipelineTags.mock.inspectFuncCreatePipelineTags = f + mmDeleteNamespacePipelineByID.mock.inspectFuncDeleteNamespacePipelineByID = f - return mmCreatePipelineTags + return mmDeleteNamespacePipelineByID } -// Return sets up results that will be returned by Repository.CreatePipelineTags -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Return(err error) *RepositoryMock { - if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") +// Return sets up results that will be returned by Repository.DeleteNamespacePipelineByID +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Return(err error) *RepositoryMock { + if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") } - if mmCreatePipelineTags.defaultExpectation == nil { - mmCreatePipelineTags.defaultExpectation = &RepositoryMockCreatePipelineTagsExpectation{mock: mmCreatePipelineTags.mock} + if mmDeleteNamespacePipelineByID.defaultExpectation == nil { + mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{mock: mmDeleteNamespacePipelineByID.mock} } - mmCreatePipelineTags.defaultExpectation.results = &RepositoryMockCreatePipelineTagsResults{err} - mmCreatePipelineTags.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmCreatePipelineTags.mock + mmDeleteNamespacePipelineByID.defaultExpectation.results = &RepositoryMockDeleteNamespacePipelineByIDResults{err} + mmDeleteNamespacePipelineByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteNamespacePipelineByID.mock } -// Set uses given function f to mock the Repository.CreatePipelineTags method -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Set(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error)) *RepositoryMock { - if mmCreatePipelineTags.defaultExpectation != nil { - mmCreatePipelineTags.mock.t.Fatalf("Default expectation is already set for the Repository.CreatePipelineTags method") +// Set uses given function f to mock the Repository.DeleteNamespacePipelineByID method +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Set(f func(ctx context.Context, ownerPermalink string, id string) (err error)) *RepositoryMock { + if mmDeleteNamespacePipelineByID.defaultExpectation != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespacePipelineByID method") } - if len(mmCreatePipelineTags.expectations) > 0 { - mmCreatePipelineTags.mock.t.Fatalf("Some expectations are already set for the Repository.CreatePipelineTags method") + if len(mmDeleteNamespacePipelineByID.expectations) > 0 { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespacePipelineByID method") } - mmCreatePipelineTags.mock.funcCreatePipelineTags = f - mmCreatePipelineTags.mock.funcCreatePipelineTagsOrigin = minimock.CallerInfo(1) - return mmCreatePipelineTags.mock + mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID = f + mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByIDOrigin = minimock.CallerInfo(1) + return mmDeleteNamespacePipelineByID.mock } -// When sets expectation for the Repository.CreatePipelineTags which will trigger the result defined by the following +// When sets expectation for the Repository.DeleteNamespacePipelineByID which will trigger the result defined by the following // Then helper -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) When(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *RepositoryMockCreatePipelineTagsExpectation { - if mmCreatePipelineTags.mock.funcCreatePipelineTags != nil { - mmCreatePipelineTags.mock.t.Fatalf("RepositoryMock.CreatePipelineTags mock is already set by Set") +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) When(ctx context.Context, ownerPermalink string, id string) *RepositoryMockDeleteNamespacePipelineByIDExpectation { + if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") } - expectation := &RepositoryMockCreatePipelineTagsExpectation{ - mock: mmCreatePipelineTags.mock, - params: &RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames}, - expectationOrigins: RepositoryMockCreatePipelineTagsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockDeleteNamespacePipelineByIDExpectation{ + mock: mmDeleteNamespacePipelineByID.mock, + params: &RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id}, + expectationOrigins: RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmCreatePipelineTags.expectations = append(mmCreatePipelineTags.expectations, expectation) + mmDeleteNamespacePipelineByID.expectations = append(mmDeleteNamespacePipelineByID.expectations, expectation) return expectation } -// Then sets up Repository.CreatePipelineTags return parameters for the expectation previously defined by the When method -func (e *RepositoryMockCreatePipelineTagsExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockCreatePipelineTagsResults{err} +// Then sets up Repository.DeleteNamespacePipelineByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockDeleteNamespacePipelineByIDExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockDeleteNamespacePipelineByIDResults{err} return e.mock } -// Times sets number of times Repository.CreatePipelineTags should be invoked -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Times(n uint64) *mRepositoryMockCreatePipelineTags { +// Times sets number of times Repository.DeleteNamespacePipelineByID should be invoked +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Times(n uint64) *mRepositoryMockDeleteNamespacePipelineByID { if n == 0 { - mmCreatePipelineTags.mock.t.Fatalf("Times of RepositoryMock.CreatePipelineTags mock can not be zero") + mmDeleteNamespacePipelineByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespacePipelineByID mock can not be zero") } - mm_atomic.StoreUint64(&mmCreatePipelineTags.expectedInvocations, n) - mmCreatePipelineTags.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmCreatePipelineTags + mm_atomic.StoreUint64(&mmDeleteNamespacePipelineByID.expectedInvocations, n) + mmDeleteNamespacePipelineByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteNamespacePipelineByID } -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) invocationsDone() bool { - if len(mmCreatePipelineTags.expectations) == 0 && mmCreatePipelineTags.defaultExpectation == nil && mmCreatePipelineTags.mock.funcCreatePipelineTags == nil { +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) invocationsDone() bool { + if len(mmDeleteNamespacePipelineByID.expectations) == 0 && mmDeleteNamespacePipelineByID.defaultExpectation == nil && mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmCreatePipelineTags.mock.afterCreatePipelineTagsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmCreatePipelineTags.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.mock.afterDeleteNamespacePipelineByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// CreatePipelineTags implements mm_repository.Repository -func (mmCreatePipelineTags *RepositoryMock) CreatePipelineTags(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error) { - mm_atomic.AddUint64(&mmCreatePipelineTags.beforeCreatePipelineTagsCounter, 1) - defer mm_atomic.AddUint64(&mmCreatePipelineTags.afterCreatePipelineTagsCounter, 1) +// DeleteNamespacePipelineByID implements mm_repository.Repository +func (mmDeleteNamespacePipelineByID *RepositoryMock) DeleteNamespacePipelineByID(ctx context.Context, ownerPermalink string, id string) (err error) { + mm_atomic.AddUint64(&mmDeleteNamespacePipelineByID.beforeDeleteNamespacePipelineByIDCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteNamespacePipelineByID.afterDeleteNamespacePipelineByIDCounter, 1) - mmCreatePipelineTags.t.Helper() + mmDeleteNamespacePipelineByID.t.Helper() - if mmCreatePipelineTags.inspectFuncCreatePipelineTags != nil { - mmCreatePipelineTags.inspectFuncCreatePipelineTags(ctx, pipelineUID, tagNames) + if mmDeleteNamespacePipelineByID.inspectFuncDeleteNamespacePipelineByID != nil { + mmDeleteNamespacePipelineByID.inspectFuncDeleteNamespacePipelineByID(ctx, ownerPermalink, id) } - mm_params := RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames} + mm_params := RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id} // Record call args - mmCreatePipelineTags.CreatePipelineTagsMock.mutex.Lock() - mmCreatePipelineTags.CreatePipelineTagsMock.callArgs = append(mmCreatePipelineTags.CreatePipelineTagsMock.callArgs, &mm_params) - mmCreatePipelineTags.CreatePipelineTagsMock.mutex.Unlock() - - for _, e := range mmCreatePipelineTags.CreatePipelineTagsMock.expectations { + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.mutex.Lock() + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.callArgs = append(mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.callArgs, &mm_params) + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.mutex.Unlock() + + for _, e := range mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.Counter, 1) - mm_want := mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.params - mm_want_ptrs := mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.paramPtrs + if mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.params + mm_want_ptrs := mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockCreatePipelineTagsParams{ctx, pipelineUID, tagNames} + mm_got := RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { + mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) } - if mm_want_ptrs.tagNames != nil && !minimock.Equal(*mm_want_ptrs.tagNames, mm_got.tagNames) { - mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameter tagNames, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.originTagNames, *mm_want_ptrs.tagNames, mm_got.tagNames, minimock.Diff(*mm_want_ptrs.tagNames, mm_got.tagNames)) + if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { + mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreatePipelineTags.t.Errorf("RepositoryMock.CreatePipelineTags got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmCreatePipelineTags.CreatePipelineTagsMock.defaultExpectation.results + mm_results := mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.results if mm_results == nil { - mmCreatePipelineTags.t.Fatal("No results are set for the RepositoryMock.CreatePipelineTags") + mmDeleteNamespacePipelineByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespacePipelineByID") } return (*mm_results).err } - if mmCreatePipelineTags.funcCreatePipelineTags != nil { - return mmCreatePipelineTags.funcCreatePipelineTags(ctx, pipelineUID, tagNames) + if mmDeleteNamespacePipelineByID.funcDeleteNamespacePipelineByID != nil { + return mmDeleteNamespacePipelineByID.funcDeleteNamespacePipelineByID(ctx, ownerPermalink, id) } - mmCreatePipelineTags.t.Fatalf("Unexpected call to RepositoryMock.CreatePipelineTags. %v %v %v", ctx, pipelineUID, tagNames) + mmDeleteNamespacePipelineByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespacePipelineByID. %v %v %v", ctx, ownerPermalink, id) return } -// CreatePipelineTagsAfterCounter returns a count of finished RepositoryMock.CreatePipelineTags invocations -func (mmCreatePipelineTags *RepositoryMock) CreatePipelineTagsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreatePipelineTags.afterCreatePipelineTagsCounter) +// DeleteNamespacePipelineByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespacePipelineByID invocations +func (mmDeleteNamespacePipelineByID *RepositoryMock) DeleteNamespacePipelineByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.afterDeleteNamespacePipelineByIDCounter) } -// CreatePipelineTagsBeforeCounter returns a count of RepositoryMock.CreatePipelineTags invocations -func (mmCreatePipelineTags *RepositoryMock) CreatePipelineTagsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmCreatePipelineTags.beforeCreatePipelineTagsCounter) +// DeleteNamespacePipelineByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespacePipelineByID invocations +func (mmDeleteNamespacePipelineByID *RepositoryMock) DeleteNamespacePipelineByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.beforeDeleteNamespacePipelineByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.CreatePipelineTags. +// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespacePipelineByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmCreatePipelineTags *mRepositoryMockCreatePipelineTags) Calls() []*RepositoryMockCreatePipelineTagsParams { - mmCreatePipelineTags.mutex.RLock() +func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Calls() []*RepositoryMockDeleteNamespacePipelineByIDParams { + mmDeleteNamespacePipelineByID.mutex.RLock() - argCopy := make([]*RepositoryMockCreatePipelineTagsParams, len(mmCreatePipelineTags.callArgs)) - copy(argCopy, mmCreatePipelineTags.callArgs) + argCopy := make([]*RepositoryMockDeleteNamespacePipelineByIDParams, len(mmDeleteNamespacePipelineByID.callArgs)) + copy(argCopy, mmDeleteNamespacePipelineByID.callArgs) - mmCreatePipelineTags.mutex.RUnlock() + mmDeleteNamespacePipelineByID.mutex.RUnlock() return argCopy } -// MinimockCreatePipelineTagsDone returns true if the count of the CreatePipelineTags invocations corresponds +// MinimockDeleteNamespacePipelineByIDDone returns true if the count of the DeleteNamespacePipelineByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockCreatePipelineTagsDone() bool { - if m.CreatePipelineTagsMock.optional { +func (m *RepositoryMock) MinimockDeleteNamespacePipelineByIDDone() bool { + if m.DeleteNamespacePipelineByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.CreatePipelineTagsMock.expectations { + for _, e := range m.DeleteNamespacePipelineByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.CreatePipelineTagsMock.invocationsDone() + return m.DeleteNamespacePipelineByIDMock.invocationsDone() } -// MinimockCreatePipelineTagsInspect logs each unmet expectation -func (m *RepositoryMock) MinimockCreatePipelineTagsInspect() { - for _, e := range m.CreatePipelineTagsMock.expectations { +// MinimockDeleteNamespacePipelineByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockDeleteNamespacePipelineByIDInspect() { + for _, e := range m.DeleteNamespacePipelineByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterCreatePipelineTagsCounter := mm_atomic.LoadUint64(&m.afterCreatePipelineTagsCounter) + afterDeleteNamespacePipelineByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespacePipelineByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.CreatePipelineTagsMock.defaultExpectation != nil && afterCreatePipelineTagsCounter < 1 { - if m.CreatePipelineTagsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s", m.CreatePipelineTagsMock.defaultExpectation.returnOrigin) + if m.DeleteNamespacePipelineByIDMock.defaultExpectation != nil && afterDeleteNamespacePipelineByIDCounter < 1 { + if m.DeleteNamespacePipelineByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s", m.DeleteNamespacePipelineByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s with params: %#v", m.CreatePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *m.CreatePipelineTagsMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s with params: %#v", m.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespacePipelineByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcCreatePipelineTags != nil && afterCreatePipelineTagsCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.CreatePipelineTags at\n%s", m.funcCreatePipelineTagsOrigin) + if m.funcDeleteNamespacePipelineByID != nil && afterDeleteNamespacePipelineByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s", m.funcDeleteNamespacePipelineByIDOrigin) } - if !m.CreatePipelineTagsMock.invocationsDone() && afterCreatePipelineTagsCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.CreatePipelineTags at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.CreatePipelineTagsMock.expectedInvocations), m.CreatePipelineTagsMock.expectedInvocationsOrigin, afterCreatePipelineTagsCounter) + if !m.DeleteNamespacePipelineByIDMock.invocationsDone() && afterDeleteNamespacePipelineByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespacePipelineByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteNamespacePipelineByIDMock.expectedInvocations), m.DeleteNamespacePipelineByIDMock.expectedInvocationsOrigin, afterDeleteNamespacePipelineByIDCounter) } } -type mRepositoryMockDeleteNamespaceConnectionByID struct { +type mRepositoryMockDeleteNamespacePipelineReleaseByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockDeleteNamespaceConnectionByIDExpectation - expectations []*RepositoryMockDeleteNamespaceConnectionByIDExpectation + defaultExpectation *RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation + expectations []*RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation - callArgs []*RepositoryMockDeleteNamespaceConnectionByIDParams + callArgs []*RepositoryMockDeleteNamespacePipelineReleaseByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockDeleteNamespaceConnectionByIDExpectation specifies expectation struct of the Repository.DeleteNamespaceConnectionByID -type RepositoryMockDeleteNamespaceConnectionByIDExpectation struct { +// RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation specifies expectation struct of the Repository.DeleteNamespacePipelineReleaseByID +type RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockDeleteNamespaceConnectionByIDParams - paramPtrs *RepositoryMockDeleteNamespaceConnectionByIDParamPtrs - expectationOrigins RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins - results *RepositoryMockDeleteNamespaceConnectionByIDResults + params *RepositoryMockDeleteNamespacePipelineReleaseByIDParams + paramPtrs *RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs + expectationOrigins RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins + results *RepositoryMockDeleteNamespacePipelineReleaseByIDResults returnOrigin string Counter uint64 } -// RepositoryMockDeleteNamespaceConnectionByIDParams contains parameters of the Repository.DeleteNamespaceConnectionByID -type RepositoryMockDeleteNamespaceConnectionByIDParams struct { - ctx context.Context - nsUID uuid.UUID - id string +// RepositoryMockDeleteNamespacePipelineReleaseByIDParams contains parameters of the Repository.DeleteNamespacePipelineReleaseByID +type RepositoryMockDeleteNamespacePipelineReleaseByIDParams struct { + ctx context.Context + ownerPermalink string + pipelineUID uuid.UUID + id string } -// RepositoryMockDeleteNamespaceConnectionByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespaceConnectionByID -type RepositoryMockDeleteNamespaceConnectionByIDParamPtrs struct { - ctx *context.Context - nsUID *uuid.UUID - id *string +// RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespacePipelineReleaseByID +type RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs struct { + ctx *context.Context + ownerPermalink *string + pipelineUID *uuid.UUID + id *string } -// RepositoryMockDeleteNamespaceConnectionByIDResults contains results of the Repository.DeleteNamespaceConnectionByID -type RepositoryMockDeleteNamespaceConnectionByIDResults struct { +// RepositoryMockDeleteNamespacePipelineReleaseByIDResults contains results of the Repository.DeleteNamespacePipelineReleaseByID +type RepositoryMockDeleteNamespacePipelineReleaseByIDResults struct { err error } -// RepositoryMockDeleteNamespaceConnectionByIDOrigins contains origins of expectations of the Repository.DeleteNamespaceConnectionByID -type RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins struct { - origin string - originCtx string - originNsUID string - originId string +// RepositoryMockDeleteNamespacePipelineReleaseByIDOrigins contains origins of expectations of the Repository.DeleteNamespacePipelineReleaseByID +type RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins struct { + origin string + originCtx string + originOwnerPermalink string + originPipelineUID string + originId string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -3879,368 +3944,396 @@ type RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Optional() *mRepositoryMockDeleteNamespaceConnectionByID { - mmDeleteNamespaceConnectionByID.optional = true - return mmDeleteNamespaceConnectionByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Optional() *mRepositoryMockDeleteNamespacePipelineReleaseByID { + mmDeleteNamespacePipelineReleaseByID.optional = true + return mmDeleteNamespacePipelineReleaseByID } -// Expect sets up expected params for Repository.DeleteNamespaceConnectionByID -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Expect(ctx context.Context, nsUID uuid.UUID, id string) *mRepositoryMockDeleteNamespaceConnectionByID { - if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") +// Expect sets up expected params for Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) *mRepositoryMockDeleteNamespacePipelineReleaseByID { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} } - if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by ExpectParams functions") + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by ExpectParams functions") } - mmDeleteNamespaceConnectionByID.defaultExpectation.params = &RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id} - mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmDeleteNamespaceConnectionByID.expectations { - if minimock.Equal(e.params, mmDeleteNamespaceConnectionByID.defaultExpectation.params) { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespaceConnectionByID.defaultExpectation.params) + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params = &RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id} + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteNamespacePipelineReleaseByID.expectations { + if minimock.Equal(e.params, mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params) { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params) } } - return mmDeleteNamespaceConnectionByID + return mmDeleteNamespacePipelineReleaseByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespaceConnectionByID -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespaceConnectionByID { - if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespacePipelineReleaseByID { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} } - if mmDeleteNamespaceConnectionByID.defaultExpectation.params != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Expect") + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") } - if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceConnectionByIDParamPtrs{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} } - mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs.ctx = &ctx - mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmDeleteNamespaceConnectionByID + return mmDeleteNamespacePipelineReleaseByID } -// ExpectNsUIDParam2 sets up expected param nsUID for Repository.DeleteNamespaceConnectionByID -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) ExpectNsUIDParam2(nsUID uuid.UUID) *mRepositoryMockDeleteNamespaceConnectionByID { - if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockDeleteNamespacePipelineReleaseByID { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} } - if mmDeleteNamespaceConnectionByID.defaultExpectation.params != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Expect") + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") } - if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceConnectionByIDParamPtrs{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} } - mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs.nsUID = &nsUID - mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.originNsUID = minimock.CallerInfo(1) + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmDeleteNamespaceConnectionByID + return mmDeleteNamespacePipelineReleaseByID } -// ExpectIdParam3 sets up expected param id for Repository.DeleteNamespaceConnectionByID -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) ExpectIdParam3(id string) *mRepositoryMockDeleteNamespaceConnectionByID { - if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") +// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockDeleteNamespacePipelineReleaseByID { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} } - if mmDeleteNamespaceConnectionByID.defaultExpectation.params != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Expect") + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") } - if mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceConnectionByIDParamPtrs{} + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} } - mmDeleteNamespaceConnectionByID.defaultExpectation.paramPtrs.id = &id - mmDeleteNamespaceConnectionByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - return mmDeleteNamespaceConnectionByID + return mmDeleteNamespacePipelineReleaseByID } -// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespaceConnectionByID -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Inspect(f func(ctx context.Context, nsUID uuid.UUID, id string)) *mRepositoryMockDeleteNamespaceConnectionByID { - if mmDeleteNamespaceConnectionByID.mock.inspectFuncDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespaceConnectionByID") +// ExpectIdParam4 sets up expected param id for Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectIdParam4(id string) *mRepositoryMockDeleteNamespacePipelineReleaseByID { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - mmDeleteNamespaceConnectionByID.mock.inspectFuncDeleteNamespaceConnectionByID = f + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} + } - return mmDeleteNamespaceConnectionByID + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") + } + + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} + } + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.id = &id + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + + return mmDeleteNamespacePipelineReleaseByID } -// Return sets up results that will be returned by Repository.DeleteNamespaceConnectionByID -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Return(err error) *RepositoryMock { - if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string)) *mRepositoryMockDeleteNamespacePipelineReleaseByID { + if mmDeleteNamespacePipelineReleaseByID.mock.inspectFuncDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespacePipelineReleaseByID") } - if mmDeleteNamespaceConnectionByID.defaultExpectation == nil { - mmDeleteNamespaceConnectionByID.defaultExpectation = &RepositoryMockDeleteNamespaceConnectionByIDExpectation{mock: mmDeleteNamespaceConnectionByID.mock} + mmDeleteNamespacePipelineReleaseByID.mock.inspectFuncDeleteNamespacePipelineReleaseByID = f + + return mmDeleteNamespacePipelineReleaseByID +} + +// Return sets up results that will be returned by Repository.DeleteNamespacePipelineReleaseByID +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Return(err error) *RepositoryMock { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - mmDeleteNamespaceConnectionByID.defaultExpectation.results = &RepositoryMockDeleteNamespaceConnectionByIDResults{err} - mmDeleteNamespaceConnectionByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmDeleteNamespaceConnectionByID.mock + + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { + mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{mock: mmDeleteNamespacePipelineReleaseByID.mock} + } + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.results = &RepositoryMockDeleteNamespacePipelineReleaseByIDResults{err} + mmDeleteNamespacePipelineReleaseByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteNamespacePipelineReleaseByID.mock } -// Set uses given function f to mock the Repository.DeleteNamespaceConnectionByID method -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Set(f func(ctx context.Context, nsUID uuid.UUID, id string) (err error)) *RepositoryMock { - if mmDeleteNamespaceConnectionByID.defaultExpectation != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespaceConnectionByID method") +// Set uses given function f to mock the Repository.DeleteNamespacePipelineReleaseByID method +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) (err error)) *RepositoryMock { + if mmDeleteNamespacePipelineReleaseByID.defaultExpectation != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespacePipelineReleaseByID method") } - if len(mmDeleteNamespaceConnectionByID.expectations) > 0 { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespaceConnectionByID method") + if len(mmDeleteNamespacePipelineReleaseByID.expectations) > 0 { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespacePipelineReleaseByID method") } - mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID = f - mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByIDOrigin = minimock.CallerInfo(1) - return mmDeleteNamespaceConnectionByID.mock + mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID = f + mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByIDOrigin = minimock.CallerInfo(1) + return mmDeleteNamespacePipelineReleaseByID.mock } -// When sets expectation for the Repository.DeleteNamespaceConnectionByID which will trigger the result defined by the following +// When sets expectation for the Repository.DeleteNamespacePipelineReleaseByID which will trigger the result defined by the following // Then helper -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) When(ctx context.Context, nsUID uuid.UUID, id string) *RepositoryMockDeleteNamespaceConnectionByIDExpectation { - if mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceConnectionByID mock is already set by Set") +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) *RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation { + if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") } - expectation := &RepositoryMockDeleteNamespaceConnectionByIDExpectation{ - mock: mmDeleteNamespaceConnectionByID.mock, - params: &RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id}, - expectationOrigins: RepositoryMockDeleteNamespaceConnectionByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{ + mock: mmDeleteNamespacePipelineReleaseByID.mock, + params: &RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id}, + expectationOrigins: RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmDeleteNamespaceConnectionByID.expectations = append(mmDeleteNamespaceConnectionByID.expectations, expectation) + mmDeleteNamespacePipelineReleaseByID.expectations = append(mmDeleteNamespacePipelineReleaseByID.expectations, expectation) return expectation } -// Then sets up Repository.DeleteNamespaceConnectionByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockDeleteNamespaceConnectionByIDExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockDeleteNamespaceConnectionByIDResults{err} +// Then sets up Repository.DeleteNamespacePipelineReleaseByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockDeleteNamespacePipelineReleaseByIDResults{err} return e.mock } -// Times sets number of times Repository.DeleteNamespaceConnectionByID should be invoked -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Times(n uint64) *mRepositoryMockDeleteNamespaceConnectionByID { +// Times sets number of times Repository.DeleteNamespacePipelineReleaseByID should be invoked +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Times(n uint64) *mRepositoryMockDeleteNamespacePipelineReleaseByID { if n == 0 { - mmDeleteNamespaceConnectionByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespaceConnectionByID mock can not be zero") + mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespacePipelineReleaseByID mock can not be zero") } - mm_atomic.StoreUint64(&mmDeleteNamespaceConnectionByID.expectedInvocations, n) - mmDeleteNamespaceConnectionByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmDeleteNamespaceConnectionByID + mm_atomic.StoreUint64(&mmDeleteNamespacePipelineReleaseByID.expectedInvocations, n) + mmDeleteNamespacePipelineReleaseByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteNamespacePipelineReleaseByID } -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) invocationsDone() bool { - if len(mmDeleteNamespaceConnectionByID.expectations) == 0 && mmDeleteNamespaceConnectionByID.defaultExpectation == nil && mmDeleteNamespaceConnectionByID.mock.funcDeleteNamespaceConnectionByID == nil { +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) invocationsDone() bool { + if len(mmDeleteNamespacePipelineReleaseByID.expectations) == 0 && mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil && mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.mock.afterDeleteNamespaceConnectionByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.mock.afterDeleteNamespacePipelineReleaseByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// DeleteNamespaceConnectionByID implements mm_repository.Repository -func (mmDeleteNamespaceConnectionByID *RepositoryMock) DeleteNamespaceConnectionByID(ctx context.Context, nsUID uuid.UUID, id string) (err error) { - mm_atomic.AddUint64(&mmDeleteNamespaceConnectionByID.beforeDeleteNamespaceConnectionByIDCounter, 1) - defer mm_atomic.AddUint64(&mmDeleteNamespaceConnectionByID.afterDeleteNamespaceConnectionByIDCounter, 1) +// DeleteNamespacePipelineReleaseByID implements mm_repository.Repository +func (mmDeleteNamespacePipelineReleaseByID *RepositoryMock) DeleteNamespacePipelineReleaseByID(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) (err error) { + mm_atomic.AddUint64(&mmDeleteNamespacePipelineReleaseByID.beforeDeleteNamespacePipelineReleaseByIDCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteNamespacePipelineReleaseByID.afterDeleteNamespacePipelineReleaseByIDCounter, 1) - mmDeleteNamespaceConnectionByID.t.Helper() + mmDeleteNamespacePipelineReleaseByID.t.Helper() - if mmDeleteNamespaceConnectionByID.inspectFuncDeleteNamespaceConnectionByID != nil { - mmDeleteNamespaceConnectionByID.inspectFuncDeleteNamespaceConnectionByID(ctx, nsUID, id) + if mmDeleteNamespacePipelineReleaseByID.inspectFuncDeleteNamespacePipelineReleaseByID != nil { + mmDeleteNamespacePipelineReleaseByID.inspectFuncDeleteNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id) } - mm_params := RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id} + mm_params := RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id} // Record call args - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.mutex.Lock() - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.callArgs = append(mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.callArgs, &mm_params) - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.mutex.Unlock() + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.mutex.Lock() + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.callArgs = append(mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.callArgs, &mm_params) + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.mutex.Unlock() - for _, e := range mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.expectations { + for _, e := range mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.Counter, 1) - mm_want := mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.params - mm_want_ptrs := mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.paramPtrs + if mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.params + mm_want_ptrs := mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockDeleteNamespaceConnectionByIDParams{ctx, nsUID, id} + mm_got := RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.nsUID != nil && !minimock.Equal(*mm_want_ptrs.nsUID, mm_got.nsUID) { - mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameter nsUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originNsUID, *mm_want_ptrs.nsUID, mm_got.nsUID, minimock.Diff(*mm_want_ptrs.nsUID, mm_got.nsUID)) + if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { + mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + } + + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) } if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteNamespaceConnectionByID.t.Errorf("RepositoryMock.DeleteNamespaceConnectionByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmDeleteNamespaceConnectionByID.DeleteNamespaceConnectionByIDMock.defaultExpectation.results + mm_results := mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.results if mm_results == nil { - mmDeleteNamespaceConnectionByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespaceConnectionByID") + mmDeleteNamespacePipelineReleaseByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespacePipelineReleaseByID") } return (*mm_results).err } - if mmDeleteNamespaceConnectionByID.funcDeleteNamespaceConnectionByID != nil { - return mmDeleteNamespaceConnectionByID.funcDeleteNamespaceConnectionByID(ctx, nsUID, id) + if mmDeleteNamespacePipelineReleaseByID.funcDeleteNamespacePipelineReleaseByID != nil { + return mmDeleteNamespacePipelineReleaseByID.funcDeleteNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id) } - mmDeleteNamespaceConnectionByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespaceConnectionByID. %v %v %v", ctx, nsUID, id) + mmDeleteNamespacePipelineReleaseByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespacePipelineReleaseByID. %v %v %v %v", ctx, ownerPermalink, pipelineUID, id) return } -// DeleteNamespaceConnectionByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespaceConnectionByID invocations -func (mmDeleteNamespaceConnectionByID *RepositoryMock) DeleteNamespaceConnectionByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.afterDeleteNamespaceConnectionByIDCounter) +// DeleteNamespacePipelineReleaseByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespacePipelineReleaseByID invocations +func (mmDeleteNamespacePipelineReleaseByID *RepositoryMock) DeleteNamespacePipelineReleaseByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.afterDeleteNamespacePipelineReleaseByIDCounter) } -// DeleteNamespaceConnectionByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespaceConnectionByID invocations -func (mmDeleteNamespaceConnectionByID *RepositoryMock) DeleteNamespaceConnectionByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespaceConnectionByID.beforeDeleteNamespaceConnectionByIDCounter) +// DeleteNamespacePipelineReleaseByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespacePipelineReleaseByID invocations +func (mmDeleteNamespacePipelineReleaseByID *RepositoryMock) DeleteNamespacePipelineReleaseByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.beforeDeleteNamespacePipelineReleaseByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespaceConnectionByID. +// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespacePipelineReleaseByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmDeleteNamespaceConnectionByID *mRepositoryMockDeleteNamespaceConnectionByID) Calls() []*RepositoryMockDeleteNamespaceConnectionByIDParams { - mmDeleteNamespaceConnectionByID.mutex.RLock() +func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Calls() []*RepositoryMockDeleteNamespacePipelineReleaseByIDParams { + mmDeleteNamespacePipelineReleaseByID.mutex.RLock() - argCopy := make([]*RepositoryMockDeleteNamespaceConnectionByIDParams, len(mmDeleteNamespaceConnectionByID.callArgs)) - copy(argCopy, mmDeleteNamespaceConnectionByID.callArgs) + argCopy := make([]*RepositoryMockDeleteNamespacePipelineReleaseByIDParams, len(mmDeleteNamespacePipelineReleaseByID.callArgs)) + copy(argCopy, mmDeleteNamespacePipelineReleaseByID.callArgs) - mmDeleteNamespaceConnectionByID.mutex.RUnlock() + mmDeleteNamespacePipelineReleaseByID.mutex.RUnlock() return argCopy } -// MinimockDeleteNamespaceConnectionByIDDone returns true if the count of the DeleteNamespaceConnectionByID invocations corresponds +// MinimockDeleteNamespacePipelineReleaseByIDDone returns true if the count of the DeleteNamespacePipelineReleaseByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockDeleteNamespaceConnectionByIDDone() bool { - if m.DeleteNamespaceConnectionByIDMock.optional { +func (m *RepositoryMock) MinimockDeleteNamespacePipelineReleaseByIDDone() bool { + if m.DeleteNamespacePipelineReleaseByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.DeleteNamespaceConnectionByIDMock.expectations { + for _, e := range m.DeleteNamespacePipelineReleaseByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.DeleteNamespaceConnectionByIDMock.invocationsDone() + return m.DeleteNamespacePipelineReleaseByIDMock.invocationsDone() } -// MinimockDeleteNamespaceConnectionByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockDeleteNamespaceConnectionByIDInspect() { - for _, e := range m.DeleteNamespaceConnectionByIDMock.expectations { +// MinimockDeleteNamespacePipelineReleaseByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockDeleteNamespacePipelineReleaseByIDInspect() { + for _, e := range m.DeleteNamespacePipelineReleaseByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterDeleteNamespaceConnectionByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespaceConnectionByIDCounter) + afterDeleteNamespacePipelineReleaseByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespacePipelineReleaseByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.DeleteNamespaceConnectionByIDMock.defaultExpectation != nil && afterDeleteNamespaceConnectionByIDCounter < 1 { - if m.DeleteNamespaceConnectionByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s", m.DeleteNamespaceConnectionByIDMock.defaultExpectation.returnOrigin) + if m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation != nil && afterDeleteNamespacePipelineReleaseByIDCounter < 1 { + if m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s", m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s with params: %#v", m.DeleteNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespaceConnectionByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s with params: %#v", m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcDeleteNamespaceConnectionByID != nil && afterDeleteNamespaceConnectionByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceConnectionByID at\n%s", m.funcDeleteNamespaceConnectionByIDOrigin) + if m.funcDeleteNamespacePipelineReleaseByID != nil && afterDeleteNamespacePipelineReleaseByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s", m.funcDeleteNamespacePipelineReleaseByIDOrigin) } - if !m.DeleteNamespaceConnectionByIDMock.invocationsDone() && afterDeleteNamespaceConnectionByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespaceConnectionByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.DeleteNamespaceConnectionByIDMock.expectedInvocations), m.DeleteNamespaceConnectionByIDMock.expectedInvocationsOrigin, afterDeleteNamespaceConnectionByIDCounter) + if !m.DeleteNamespacePipelineReleaseByIDMock.invocationsDone() && afterDeleteNamespacePipelineReleaseByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteNamespacePipelineReleaseByIDMock.expectedInvocations), m.DeleteNamespacePipelineReleaseByIDMock.expectedInvocationsOrigin, afterDeleteNamespacePipelineReleaseByIDCounter) } } -type mRepositoryMockDeleteNamespacePipelineByID struct { +type mRepositoryMockDeleteNamespaceSecretByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockDeleteNamespacePipelineByIDExpectation - expectations []*RepositoryMockDeleteNamespacePipelineByIDExpectation + defaultExpectation *RepositoryMockDeleteNamespaceSecretByIDExpectation + expectations []*RepositoryMockDeleteNamespaceSecretByIDExpectation - callArgs []*RepositoryMockDeleteNamespacePipelineByIDParams + callArgs []*RepositoryMockDeleteNamespaceSecretByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockDeleteNamespacePipelineByIDExpectation specifies expectation struct of the Repository.DeleteNamespacePipelineByID -type RepositoryMockDeleteNamespacePipelineByIDExpectation struct { +// RepositoryMockDeleteNamespaceSecretByIDExpectation specifies expectation struct of the Repository.DeleteNamespaceSecretByID +type RepositoryMockDeleteNamespaceSecretByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockDeleteNamespacePipelineByIDParams - paramPtrs *RepositoryMockDeleteNamespacePipelineByIDParamPtrs - expectationOrigins RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins - results *RepositoryMockDeleteNamespacePipelineByIDResults + params *RepositoryMockDeleteNamespaceSecretByIDParams + paramPtrs *RepositoryMockDeleteNamespaceSecretByIDParamPtrs + expectationOrigins RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins + results *RepositoryMockDeleteNamespaceSecretByIDResults returnOrigin string Counter uint64 } -// RepositoryMockDeleteNamespacePipelineByIDParams contains parameters of the Repository.DeleteNamespacePipelineByID -type RepositoryMockDeleteNamespacePipelineByIDParams struct { +// RepositoryMockDeleteNamespaceSecretByIDParams contains parameters of the Repository.DeleteNamespaceSecretByID +type RepositoryMockDeleteNamespaceSecretByIDParams struct { ctx context.Context ownerPermalink string id string } -// RepositoryMockDeleteNamespacePipelineByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespacePipelineByID -type RepositoryMockDeleteNamespacePipelineByIDParamPtrs struct { +// RepositoryMockDeleteNamespaceSecretByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespaceSecretByID +type RepositoryMockDeleteNamespaceSecretByIDParamPtrs struct { ctx *context.Context ownerPermalink *string id *string } -// RepositoryMockDeleteNamespacePipelineByIDResults contains results of the Repository.DeleteNamespacePipelineByID -type RepositoryMockDeleteNamespacePipelineByIDResults struct { +// RepositoryMockDeleteNamespaceSecretByIDResults contains results of the Repository.DeleteNamespaceSecretByID +type RepositoryMockDeleteNamespaceSecretByIDResults struct { err error } -// RepositoryMockDeleteNamespacePipelineByIDOrigins contains origins of expectations of the Repository.DeleteNamespacePipelineByID -type RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins struct { +// RepositoryMockDeleteNamespaceSecretByIDOrigins contains origins of expectations of the Repository.DeleteNamespaceSecretByID +type RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins struct { origin string originCtx string originOwnerPermalink string @@ -4252,375 +4345,369 @@ type RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Optional() *mRepositoryMockDeleteNamespacePipelineByID { - mmDeleteNamespacePipelineByID.optional = true - return mmDeleteNamespacePipelineByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Optional() *mRepositoryMockDeleteNamespaceSecretByID { + mmDeleteNamespaceSecretByID.optional = true + return mmDeleteNamespaceSecretByID } -// Expect sets up expected params for Repository.DeleteNamespacePipelineByID -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Expect(ctx context.Context, ownerPermalink string, id string) *mRepositoryMockDeleteNamespacePipelineByID { - if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") +// Expect sets up expected params for Repository.DeleteNamespaceSecretByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Expect(ctx context.Context, ownerPermalink string, id string) *mRepositoryMockDeleteNamespaceSecretByID { + if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") } - if mmDeleteNamespacePipelineByID.defaultExpectation == nil { - mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} + if mmDeleteNamespaceSecretByID.defaultExpectation == nil { + mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} } - if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by ExpectParams functions") + if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by ExpectParams functions") } - mmDeleteNamespacePipelineByID.defaultExpectation.params = &RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id} - mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmDeleteNamespacePipelineByID.expectations { - if minimock.Equal(e.params, mmDeleteNamespacePipelineByID.defaultExpectation.params) { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespacePipelineByID.defaultExpectation.params) + mmDeleteNamespaceSecretByID.defaultExpectation.params = &RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id} + mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteNamespaceSecretByID.expectations { + if minimock.Equal(e.params, mmDeleteNamespaceSecretByID.defaultExpectation.params) { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespaceSecretByID.defaultExpectation.params) } } - return mmDeleteNamespacePipelineByID + return mmDeleteNamespaceSecretByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespacePipelineByID -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespacePipelineByID { - if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespaceSecretByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespaceSecretByID { + if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") } - if mmDeleteNamespacePipelineByID.defaultExpectation == nil { - mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} + if mmDeleteNamespaceSecretByID.defaultExpectation == nil { + mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} } - if mmDeleteNamespacePipelineByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Expect") + if mmDeleteNamespaceSecretByID.defaultExpectation.params != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Expect") } - if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineByIDParamPtrs{} + if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceSecretByIDParamPtrs{} } - mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs.ctx = &ctx - mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineByID + return mmDeleteNamespaceSecretByID } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.DeleteNamespacePipelineByID -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockDeleteNamespacePipelineByID { - if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.DeleteNamespaceSecretByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockDeleteNamespaceSecretByID { + if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") } - if mmDeleteNamespacePipelineByID.defaultExpectation == nil { - mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} + if mmDeleteNamespaceSecretByID.defaultExpectation == nil { + mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} } - if mmDeleteNamespacePipelineByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Expect") + if mmDeleteNamespaceSecretByID.defaultExpectation.params != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Expect") } - if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineByIDParamPtrs{} + if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceSecretByIDParamPtrs{} } - mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineByID + return mmDeleteNamespaceSecretByID } -// ExpectIdParam3 sets up expected param id for Repository.DeleteNamespacePipelineByID -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) ExpectIdParam3(id string) *mRepositoryMockDeleteNamespacePipelineByID { - if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") +// ExpectIdParam3 sets up expected param id for Repository.DeleteNamespaceSecretByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) ExpectIdParam3(id string) *mRepositoryMockDeleteNamespaceSecretByID { + if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") } - if mmDeleteNamespacePipelineByID.defaultExpectation == nil { - mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{} + if mmDeleteNamespaceSecretByID.defaultExpectation == nil { + mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} } - if mmDeleteNamespacePipelineByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Expect") + if mmDeleteNamespaceSecretByID.defaultExpectation.params != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Expect") } - if mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineByIDParamPtrs{} + if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs == nil { + mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceSecretByIDParamPtrs{} } - mmDeleteNamespacePipelineByID.defaultExpectation.paramPtrs.id = &id - mmDeleteNamespacePipelineByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs.id = &id + mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineByID + return mmDeleteNamespaceSecretByID } -// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespacePipelineByID -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string)) *mRepositoryMockDeleteNamespacePipelineByID { - if mmDeleteNamespacePipelineByID.mock.inspectFuncDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespacePipelineByID") +// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespaceSecretByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string)) *mRepositoryMockDeleteNamespaceSecretByID { + if mmDeleteNamespaceSecretByID.mock.inspectFuncDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespaceSecretByID") } - mmDeleteNamespacePipelineByID.mock.inspectFuncDeleteNamespacePipelineByID = f + mmDeleteNamespaceSecretByID.mock.inspectFuncDeleteNamespaceSecretByID = f - return mmDeleteNamespacePipelineByID + return mmDeleteNamespaceSecretByID } -// Return sets up results that will be returned by Repository.DeleteNamespacePipelineByID -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Return(err error) *RepositoryMock { - if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") +// Return sets up results that will be returned by Repository.DeleteNamespaceSecretByID +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Return(err error) *RepositoryMock { + if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") } - if mmDeleteNamespacePipelineByID.defaultExpectation == nil { - mmDeleteNamespacePipelineByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineByIDExpectation{mock: mmDeleteNamespacePipelineByID.mock} + if mmDeleteNamespaceSecretByID.defaultExpectation == nil { + mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{mock: mmDeleteNamespaceSecretByID.mock} } - mmDeleteNamespacePipelineByID.defaultExpectation.results = &RepositoryMockDeleteNamespacePipelineByIDResults{err} - mmDeleteNamespacePipelineByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineByID.mock + mmDeleteNamespaceSecretByID.defaultExpectation.results = &RepositoryMockDeleteNamespaceSecretByIDResults{err} + mmDeleteNamespaceSecretByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteNamespaceSecretByID.mock } -// Set uses given function f to mock the Repository.DeleteNamespacePipelineByID method -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Set(f func(ctx context.Context, ownerPermalink string, id string) (err error)) *RepositoryMock { - if mmDeleteNamespacePipelineByID.defaultExpectation != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespacePipelineByID method") +// Set uses given function f to mock the Repository.DeleteNamespaceSecretByID method +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Set(f func(ctx context.Context, ownerPermalink string, id string) (err error)) *RepositoryMock { + if mmDeleteNamespaceSecretByID.defaultExpectation != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespaceSecretByID method") } - if len(mmDeleteNamespacePipelineByID.expectations) > 0 { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespacePipelineByID method") + if len(mmDeleteNamespaceSecretByID.expectations) > 0 { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespaceSecretByID method") } - mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID = f - mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByIDOrigin = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineByID.mock + mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID = f + mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByIDOrigin = minimock.CallerInfo(1) + return mmDeleteNamespaceSecretByID.mock } -// When sets expectation for the Repository.DeleteNamespacePipelineByID which will trigger the result defined by the following +// When sets expectation for the Repository.DeleteNamespaceSecretByID which will trigger the result defined by the following // Then helper -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) When(ctx context.Context, ownerPermalink string, id string) *RepositoryMockDeleteNamespacePipelineByIDExpectation { - if mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineByID mock is already set by Set") +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) When(ctx context.Context, ownerPermalink string, id string) *RepositoryMockDeleteNamespaceSecretByIDExpectation { + if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") } - expectation := &RepositoryMockDeleteNamespacePipelineByIDExpectation{ - mock: mmDeleteNamespacePipelineByID.mock, - params: &RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id}, - expectationOrigins: RepositoryMockDeleteNamespacePipelineByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockDeleteNamespaceSecretByIDExpectation{ + mock: mmDeleteNamespaceSecretByID.mock, + params: &RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id}, + expectationOrigins: RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmDeleteNamespacePipelineByID.expectations = append(mmDeleteNamespacePipelineByID.expectations, expectation) + mmDeleteNamespaceSecretByID.expectations = append(mmDeleteNamespaceSecretByID.expectations, expectation) return expectation } -// Then sets up Repository.DeleteNamespacePipelineByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockDeleteNamespacePipelineByIDExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockDeleteNamespacePipelineByIDResults{err} +// Then sets up Repository.DeleteNamespaceSecretByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockDeleteNamespaceSecretByIDExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockDeleteNamespaceSecretByIDResults{err} return e.mock } -// Times sets number of times Repository.DeleteNamespacePipelineByID should be invoked -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Times(n uint64) *mRepositoryMockDeleteNamespacePipelineByID { +// Times sets number of times Repository.DeleteNamespaceSecretByID should be invoked +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Times(n uint64) *mRepositoryMockDeleteNamespaceSecretByID { if n == 0 { - mmDeleteNamespacePipelineByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespacePipelineByID mock can not be zero") + mmDeleteNamespaceSecretByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespaceSecretByID mock can not be zero") } - mm_atomic.StoreUint64(&mmDeleteNamespacePipelineByID.expectedInvocations, n) - mmDeleteNamespacePipelineByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineByID + mm_atomic.StoreUint64(&mmDeleteNamespaceSecretByID.expectedInvocations, n) + mmDeleteNamespaceSecretByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteNamespaceSecretByID } -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) invocationsDone() bool { - if len(mmDeleteNamespacePipelineByID.expectations) == 0 && mmDeleteNamespacePipelineByID.defaultExpectation == nil && mmDeleteNamespacePipelineByID.mock.funcDeleteNamespacePipelineByID == nil { +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) invocationsDone() bool { + if len(mmDeleteNamespaceSecretByID.expectations) == 0 && mmDeleteNamespaceSecretByID.defaultExpectation == nil && mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.mock.afterDeleteNamespacePipelineByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.mock.afterDeleteNamespaceSecretByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// DeleteNamespacePipelineByID implements mm_repository.Repository -func (mmDeleteNamespacePipelineByID *RepositoryMock) DeleteNamespacePipelineByID(ctx context.Context, ownerPermalink string, id string) (err error) { - mm_atomic.AddUint64(&mmDeleteNamespacePipelineByID.beforeDeleteNamespacePipelineByIDCounter, 1) - defer mm_atomic.AddUint64(&mmDeleteNamespacePipelineByID.afterDeleteNamespacePipelineByIDCounter, 1) - - mmDeleteNamespacePipelineByID.t.Helper() +// DeleteNamespaceSecretByID implements mm_repository.Repository +func (mmDeleteNamespaceSecretByID *RepositoryMock) DeleteNamespaceSecretByID(ctx context.Context, ownerPermalink string, id string) (err error) { + mm_atomic.AddUint64(&mmDeleteNamespaceSecretByID.beforeDeleteNamespaceSecretByIDCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteNamespaceSecretByID.afterDeleteNamespaceSecretByIDCounter, 1) - if mmDeleteNamespacePipelineByID.inspectFuncDeleteNamespacePipelineByID != nil { - mmDeleteNamespacePipelineByID.inspectFuncDeleteNamespacePipelineByID(ctx, ownerPermalink, id) + mmDeleteNamespaceSecretByID.t.Helper() + + if mmDeleteNamespaceSecretByID.inspectFuncDeleteNamespaceSecretByID != nil { + mmDeleteNamespaceSecretByID.inspectFuncDeleteNamespaceSecretByID(ctx, ownerPermalink, id) } - mm_params := RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id} + mm_params := RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id} // Record call args - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.mutex.Lock() - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.callArgs = append(mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.callArgs, &mm_params) - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.mutex.Unlock() + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.mutex.Lock() + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.callArgs = append(mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.callArgs, &mm_params) + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.mutex.Unlock() - for _, e := range mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.expectations { + for _, e := range mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.Counter, 1) - mm_want := mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.params - mm_want_ptrs := mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.paramPtrs + if mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.params + mm_want_ptrs := mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockDeleteNamespacePipelineByIDParams{ctx, ownerPermalink, id} + mm_got := RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) } if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteNamespacePipelineByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmDeleteNamespacePipelineByID.DeleteNamespacePipelineByIDMock.defaultExpectation.results + mm_results := mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.results if mm_results == nil { - mmDeleteNamespacePipelineByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespacePipelineByID") + mmDeleteNamespaceSecretByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespaceSecretByID") } return (*mm_results).err } - if mmDeleteNamespacePipelineByID.funcDeleteNamespacePipelineByID != nil { - return mmDeleteNamespacePipelineByID.funcDeleteNamespacePipelineByID(ctx, ownerPermalink, id) + if mmDeleteNamespaceSecretByID.funcDeleteNamespaceSecretByID != nil { + return mmDeleteNamespaceSecretByID.funcDeleteNamespaceSecretByID(ctx, ownerPermalink, id) } - mmDeleteNamespacePipelineByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespacePipelineByID. %v %v %v", ctx, ownerPermalink, id) + mmDeleteNamespaceSecretByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespaceSecretByID. %v %v %v", ctx, ownerPermalink, id) return } -// DeleteNamespacePipelineByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespacePipelineByID invocations -func (mmDeleteNamespacePipelineByID *RepositoryMock) DeleteNamespacePipelineByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.afterDeleteNamespacePipelineByIDCounter) +// DeleteNamespaceSecretByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespaceSecretByID invocations +func (mmDeleteNamespaceSecretByID *RepositoryMock) DeleteNamespaceSecretByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.afterDeleteNamespaceSecretByIDCounter) } -// DeleteNamespacePipelineByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespacePipelineByID invocations -func (mmDeleteNamespacePipelineByID *RepositoryMock) DeleteNamespacePipelineByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineByID.beforeDeleteNamespacePipelineByIDCounter) +// DeleteNamespaceSecretByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespaceSecretByID invocations +func (mmDeleteNamespaceSecretByID *RepositoryMock) DeleteNamespaceSecretByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.beforeDeleteNamespaceSecretByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespacePipelineByID. +// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespaceSecretByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmDeleteNamespacePipelineByID *mRepositoryMockDeleteNamespacePipelineByID) Calls() []*RepositoryMockDeleteNamespacePipelineByIDParams { - mmDeleteNamespacePipelineByID.mutex.RLock() +func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Calls() []*RepositoryMockDeleteNamespaceSecretByIDParams { + mmDeleteNamespaceSecretByID.mutex.RLock() - argCopy := make([]*RepositoryMockDeleteNamespacePipelineByIDParams, len(mmDeleteNamespacePipelineByID.callArgs)) - copy(argCopy, mmDeleteNamespacePipelineByID.callArgs) + argCopy := make([]*RepositoryMockDeleteNamespaceSecretByIDParams, len(mmDeleteNamespaceSecretByID.callArgs)) + copy(argCopy, mmDeleteNamespaceSecretByID.callArgs) - mmDeleteNamespacePipelineByID.mutex.RUnlock() + mmDeleteNamespaceSecretByID.mutex.RUnlock() return argCopy } -// MinimockDeleteNamespacePipelineByIDDone returns true if the count of the DeleteNamespacePipelineByID invocations corresponds +// MinimockDeleteNamespaceSecretByIDDone returns true if the count of the DeleteNamespaceSecretByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockDeleteNamespacePipelineByIDDone() bool { - if m.DeleteNamespacePipelineByIDMock.optional { +func (m *RepositoryMock) MinimockDeleteNamespaceSecretByIDDone() bool { + if m.DeleteNamespaceSecretByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.DeleteNamespacePipelineByIDMock.expectations { + for _, e := range m.DeleteNamespaceSecretByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.DeleteNamespacePipelineByIDMock.invocationsDone() + return m.DeleteNamespaceSecretByIDMock.invocationsDone() } -// MinimockDeleteNamespacePipelineByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockDeleteNamespacePipelineByIDInspect() { - for _, e := range m.DeleteNamespacePipelineByIDMock.expectations { +// MinimockDeleteNamespaceSecretByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockDeleteNamespaceSecretByIDInspect() { + for _, e := range m.DeleteNamespaceSecretByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterDeleteNamespacePipelineByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespacePipelineByIDCounter) + afterDeleteNamespaceSecretByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespaceSecretByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.DeleteNamespacePipelineByIDMock.defaultExpectation != nil && afterDeleteNamespacePipelineByIDCounter < 1 { - if m.DeleteNamespacePipelineByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s", m.DeleteNamespacePipelineByIDMock.defaultExpectation.returnOrigin) + if m.DeleteNamespaceSecretByIDMock.defaultExpectation != nil && afterDeleteNamespaceSecretByIDCounter < 1 { + if m.DeleteNamespaceSecretByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s", m.DeleteNamespaceSecretByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s with params: %#v", m.DeleteNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespacePipelineByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s with params: %#v", m.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespaceSecretByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcDeleteNamespacePipelineByID != nil && afterDeleteNamespacePipelineByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineByID at\n%s", m.funcDeleteNamespacePipelineByIDOrigin) + if m.funcDeleteNamespaceSecretByID != nil && afterDeleteNamespaceSecretByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s", m.funcDeleteNamespaceSecretByIDOrigin) } - if !m.DeleteNamespacePipelineByIDMock.invocationsDone() && afterDeleteNamespacePipelineByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespacePipelineByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.DeleteNamespacePipelineByIDMock.expectedInvocations), m.DeleteNamespacePipelineByIDMock.expectedInvocationsOrigin, afterDeleteNamespacePipelineByIDCounter) + if !m.DeleteNamespaceSecretByIDMock.invocationsDone() && afterDeleteNamespaceSecretByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespaceSecretByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteNamespaceSecretByIDMock.expectedInvocations), m.DeleteNamespaceSecretByIDMock.expectedInvocationsOrigin, afterDeleteNamespaceSecretByIDCounter) } } -type mRepositoryMockDeleteNamespacePipelineReleaseByID struct { +type mRepositoryMockDeletePipelineRunOn struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation - expectations []*RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation + defaultExpectation *RepositoryMockDeletePipelineRunOnExpectation + expectations []*RepositoryMockDeletePipelineRunOnExpectation - callArgs []*RepositoryMockDeleteNamespacePipelineReleaseByIDParams + callArgs []*RepositoryMockDeletePipelineRunOnParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation specifies expectation struct of the Repository.DeleteNamespacePipelineReleaseByID -type RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation struct { +// RepositoryMockDeletePipelineRunOnExpectation specifies expectation struct of the Repository.DeletePipelineRunOn +type RepositoryMockDeletePipelineRunOnExpectation struct { mock *RepositoryMock - params *RepositoryMockDeleteNamespacePipelineReleaseByIDParams - paramPtrs *RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs - expectationOrigins RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins - results *RepositoryMockDeleteNamespacePipelineReleaseByIDResults + params *RepositoryMockDeletePipelineRunOnParams + paramPtrs *RepositoryMockDeletePipelineRunOnParamPtrs + expectationOrigins RepositoryMockDeletePipelineRunOnExpectationOrigins + results *RepositoryMockDeletePipelineRunOnResults returnOrigin string Counter uint64 } -// RepositoryMockDeleteNamespacePipelineReleaseByIDParams contains parameters of the Repository.DeleteNamespacePipelineReleaseByID -type RepositoryMockDeleteNamespacePipelineReleaseByIDParams struct { - ctx context.Context - ownerPermalink string - pipelineUID uuid.UUID - id string +// RepositoryMockDeletePipelineRunOnParams contains parameters of the Repository.DeletePipelineRunOn +type RepositoryMockDeletePipelineRunOnParams struct { + ctx context.Context + uid uuid.UUID } -// RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespacePipelineReleaseByID -type RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs struct { - ctx *context.Context - ownerPermalink *string - pipelineUID *uuid.UUID - id *string +// RepositoryMockDeletePipelineRunOnParamPtrs contains pointers to parameters of the Repository.DeletePipelineRunOn +type RepositoryMockDeletePipelineRunOnParamPtrs struct { + ctx *context.Context + uid *uuid.UUID } -// RepositoryMockDeleteNamespacePipelineReleaseByIDResults contains results of the Repository.DeleteNamespacePipelineReleaseByID -type RepositoryMockDeleteNamespacePipelineReleaseByIDResults struct { +// RepositoryMockDeletePipelineRunOnResults contains results of the Repository.DeletePipelineRunOn +type RepositoryMockDeletePipelineRunOnResults struct { err error } -// RepositoryMockDeleteNamespacePipelineReleaseByIDOrigins contains origins of expectations of the Repository.DeleteNamespacePipelineReleaseByID -type RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins struct { - origin string - originCtx string - originOwnerPermalink string - originPipelineUID string - originId string +// RepositoryMockDeletePipelineRunOnOrigins contains origins of expectations of the Repository.DeletePipelineRunOn +type RepositoryMockDeletePipelineRunOnExpectationOrigins struct { + origin string + originCtx string + originUid string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -4628,400 +4715,344 @@ type RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Optional() *mRepositoryMockDeleteNamespacePipelineReleaseByID { - mmDeleteNamespacePipelineReleaseByID.optional = true - return mmDeleteNamespacePipelineReleaseByID +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Optional() *mRepositoryMockDeletePipelineRunOn { + mmDeletePipelineRunOn.optional = true + return mmDeletePipelineRunOn } -// Expect sets up expected params for Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) *mRepositoryMockDeleteNamespacePipelineReleaseByID { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") +// Expect sets up expected params for Repository.DeletePipelineRunOn +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Expect(ctx context.Context, uid uuid.UUID) *mRepositoryMockDeletePipelineRunOn { + if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} + if mmDeletePipelineRunOn.defaultExpectation == nil { + mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{} } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by ExpectParams functions") + if mmDeletePipelineRunOn.defaultExpectation.paramPtrs != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by ExpectParams functions") } - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params = &RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id} - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmDeleteNamespacePipelineReleaseByID.expectations { - if minimock.Equal(e.params, mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params) { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params) + mmDeletePipelineRunOn.defaultExpectation.params = &RepositoryMockDeletePipelineRunOnParams{ctx, uid} + mmDeletePipelineRunOn.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeletePipelineRunOn.expectations { + if minimock.Equal(e.params, mmDeletePipelineRunOn.defaultExpectation.params) { + mmDeletePipelineRunOn.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeletePipelineRunOn.defaultExpectation.params) } } - return mmDeleteNamespacePipelineReleaseByID + return mmDeletePipelineRunOn } -// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespacePipelineReleaseByID { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.DeletePipelineRunOn +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeletePipelineRunOn { + if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} + if mmDeletePipelineRunOn.defaultExpectation == nil { + mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{} } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") + if mmDeletePipelineRunOn.defaultExpectation.params != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Expect") } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} + if mmDeletePipelineRunOn.defaultExpectation.paramPtrs == nil { + mmDeletePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineRunOnParamPtrs{} } - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ctx = &ctx - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeletePipelineRunOn.defaultExpectation.paramPtrs.ctx = &ctx + mmDeletePipelineRunOn.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineReleaseByID + return mmDeletePipelineRunOn } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockDeleteNamespacePipelineReleaseByID { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") +// ExpectUidParam2 sets up expected param uid for Repository.DeletePipelineRunOn +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockDeletePipelineRunOn { + if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} + if mmDeletePipelineRunOn.defaultExpectation == nil { + mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{} } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") + if mmDeletePipelineRunOn.defaultExpectation.params != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Expect") } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} + if mmDeletePipelineRunOn.defaultExpectation.paramPtrs == nil { + mmDeletePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineRunOnParamPtrs{} } - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - - return mmDeleteNamespacePipelineReleaseByID -} - -// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockDeleteNamespacePipelineReleaseByID { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") - } - - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} - } - - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") - } - - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} - } - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - - return mmDeleteNamespacePipelineReleaseByID -} - -// ExpectIdParam4 sets up expected param id for Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) ExpectIdParam4(id string) *mRepositoryMockDeleteNamespacePipelineReleaseByID { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") - } - - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{} - } - - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Expect") - } - - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespacePipelineReleaseByIDParamPtrs{} - } - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.id = &id - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmDeletePipelineRunOn.defaultExpectation.paramPtrs.uid = &uid + mmDeletePipelineRunOn.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineReleaseByID + return mmDeletePipelineRunOn } -// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string)) *mRepositoryMockDeleteNamespacePipelineReleaseByID { - if mmDeleteNamespacePipelineReleaseByID.mock.inspectFuncDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespacePipelineReleaseByID") +// Inspect accepts an inspector function that has same arguments as the Repository.DeletePipelineRunOn +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Inspect(f func(ctx context.Context, uid uuid.UUID)) *mRepositoryMockDeletePipelineRunOn { + if mmDeletePipelineRunOn.mock.inspectFuncDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeletePipelineRunOn") } - mmDeleteNamespacePipelineReleaseByID.mock.inspectFuncDeleteNamespacePipelineReleaseByID = f + mmDeletePipelineRunOn.mock.inspectFuncDeletePipelineRunOn = f - return mmDeleteNamespacePipelineReleaseByID + return mmDeletePipelineRunOn } -// Return sets up results that will be returned by Repository.DeleteNamespacePipelineReleaseByID -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Return(err error) *RepositoryMock { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") +// Return sets up results that will be returned by Repository.DeletePipelineRunOn +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Return(err error) *RepositoryMock { + if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") } - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil { - mmDeleteNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{mock: mmDeleteNamespacePipelineReleaseByID.mock} + if mmDeletePipelineRunOn.defaultExpectation == nil { + mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{mock: mmDeletePipelineRunOn.mock} } - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.results = &RepositoryMockDeleteNamespacePipelineReleaseByIDResults{err} - mmDeleteNamespacePipelineReleaseByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineReleaseByID.mock + mmDeletePipelineRunOn.defaultExpectation.results = &RepositoryMockDeletePipelineRunOnResults{err} + mmDeletePipelineRunOn.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeletePipelineRunOn.mock } -// Set uses given function f to mock the Repository.DeleteNamespacePipelineReleaseByID method -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) (err error)) *RepositoryMock { - if mmDeleteNamespacePipelineReleaseByID.defaultExpectation != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespacePipelineReleaseByID method") +// Set uses given function f to mock the Repository.DeletePipelineRunOn method +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Set(f func(ctx context.Context, uid uuid.UUID) (err error)) *RepositoryMock { + if mmDeletePipelineRunOn.defaultExpectation != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("Default expectation is already set for the Repository.DeletePipelineRunOn method") } - if len(mmDeleteNamespacePipelineReleaseByID.expectations) > 0 { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespacePipelineReleaseByID method") + if len(mmDeletePipelineRunOn.expectations) > 0 { + mmDeletePipelineRunOn.mock.t.Fatalf("Some expectations are already set for the Repository.DeletePipelineRunOn method") } - mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID = f - mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByIDOrigin = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineReleaseByID.mock + mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn = f + mmDeletePipelineRunOn.mock.funcDeletePipelineRunOnOrigin = minimock.CallerInfo(1) + return mmDeletePipelineRunOn.mock } -// When sets expectation for the Repository.DeleteNamespacePipelineReleaseByID which will trigger the result defined by the following +// When sets expectation for the Repository.DeletePipelineRunOn which will trigger the result defined by the following // Then helper -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) *RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation { - if mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.DeleteNamespacePipelineReleaseByID mock is already set by Set") +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) When(ctx context.Context, uid uuid.UUID) *RepositoryMockDeletePipelineRunOnExpectation { + if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") } - expectation := &RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation{ - mock: mmDeleteNamespacePipelineReleaseByID.mock, - params: &RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id}, - expectationOrigins: RepositoryMockDeleteNamespacePipelineReleaseByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockDeletePipelineRunOnExpectation{ + mock: mmDeletePipelineRunOn.mock, + params: &RepositoryMockDeletePipelineRunOnParams{ctx, uid}, + expectationOrigins: RepositoryMockDeletePipelineRunOnExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmDeleteNamespacePipelineReleaseByID.expectations = append(mmDeleteNamespacePipelineReleaseByID.expectations, expectation) + mmDeletePipelineRunOn.expectations = append(mmDeletePipelineRunOn.expectations, expectation) return expectation } -// Then sets up Repository.DeleteNamespacePipelineReleaseByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockDeleteNamespacePipelineReleaseByIDExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockDeleteNamespacePipelineReleaseByIDResults{err} +// Then sets up Repository.DeletePipelineRunOn return parameters for the expectation previously defined by the When method +func (e *RepositoryMockDeletePipelineRunOnExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockDeletePipelineRunOnResults{err} return e.mock } -// Times sets number of times Repository.DeleteNamespacePipelineReleaseByID should be invoked -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Times(n uint64) *mRepositoryMockDeleteNamespacePipelineReleaseByID { +// Times sets number of times Repository.DeletePipelineRunOn should be invoked +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Times(n uint64) *mRepositoryMockDeletePipelineRunOn { if n == 0 { - mmDeleteNamespacePipelineReleaseByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespacePipelineReleaseByID mock can not be zero") + mmDeletePipelineRunOn.mock.t.Fatalf("Times of RepositoryMock.DeletePipelineRunOn mock can not be zero") } - mm_atomic.StoreUint64(&mmDeleteNamespacePipelineReleaseByID.expectedInvocations, n) - mmDeleteNamespacePipelineReleaseByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmDeleteNamespacePipelineReleaseByID + mm_atomic.StoreUint64(&mmDeletePipelineRunOn.expectedInvocations, n) + mmDeletePipelineRunOn.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeletePipelineRunOn } -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) invocationsDone() bool { - if len(mmDeleteNamespacePipelineReleaseByID.expectations) == 0 && mmDeleteNamespacePipelineReleaseByID.defaultExpectation == nil && mmDeleteNamespacePipelineReleaseByID.mock.funcDeleteNamespacePipelineReleaseByID == nil { +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) invocationsDone() bool { + if len(mmDeletePipelineRunOn.expectations) == 0 && mmDeletePipelineRunOn.defaultExpectation == nil && mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.mock.afterDeleteNamespacePipelineReleaseByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeletePipelineRunOn.mock.afterDeletePipelineRunOnCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeletePipelineRunOn.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// DeleteNamespacePipelineReleaseByID implements mm_repository.Repository -func (mmDeleteNamespacePipelineReleaseByID *RepositoryMock) DeleteNamespacePipelineReleaseByID(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string) (err error) { - mm_atomic.AddUint64(&mmDeleteNamespacePipelineReleaseByID.beforeDeleteNamespacePipelineReleaseByIDCounter, 1) - defer mm_atomic.AddUint64(&mmDeleteNamespacePipelineReleaseByID.afterDeleteNamespacePipelineReleaseByIDCounter, 1) +// DeletePipelineRunOn implements mm_repository.Repository +func (mmDeletePipelineRunOn *RepositoryMock) DeletePipelineRunOn(ctx context.Context, uid uuid.UUID) (err error) { + mm_atomic.AddUint64(&mmDeletePipelineRunOn.beforeDeletePipelineRunOnCounter, 1) + defer mm_atomic.AddUint64(&mmDeletePipelineRunOn.afterDeletePipelineRunOnCounter, 1) - mmDeleteNamespacePipelineReleaseByID.t.Helper() + mmDeletePipelineRunOn.t.Helper() - if mmDeleteNamespacePipelineReleaseByID.inspectFuncDeleteNamespacePipelineReleaseByID != nil { - mmDeleteNamespacePipelineReleaseByID.inspectFuncDeleteNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id) + if mmDeletePipelineRunOn.inspectFuncDeletePipelineRunOn != nil { + mmDeletePipelineRunOn.inspectFuncDeletePipelineRunOn(ctx, uid) } - mm_params := RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id} + mm_params := RepositoryMockDeletePipelineRunOnParams{ctx, uid} // Record call args - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.mutex.Lock() - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.callArgs = append(mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.callArgs, &mm_params) - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.mutex.Unlock() + mmDeletePipelineRunOn.DeletePipelineRunOnMock.mutex.Lock() + mmDeletePipelineRunOn.DeletePipelineRunOnMock.callArgs = append(mmDeletePipelineRunOn.DeletePipelineRunOnMock.callArgs, &mm_params) + mmDeletePipelineRunOn.DeletePipelineRunOnMock.mutex.Unlock() - for _, e := range mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.expectations { + for _, e := range mmDeletePipelineRunOn.DeletePipelineRunOnMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.Counter, 1) - mm_want := mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.params - mm_want_ptrs := mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.paramPtrs + if mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.Counter, 1) + mm_want := mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.params + mm_want_ptrs := mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockDeleteNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id} + mm_got := RepositoryMockDeletePipelineRunOnParams{ctx, uid} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) - } - - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + mmDeletePipelineRunOn.t.Errorf("RepositoryMock.DeletePipelineRunOn got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { + mmDeletePipelineRunOn.t.Errorf("RepositoryMock.DeletePipelineRunOn got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.DeleteNamespacePipelineReleaseByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeletePipelineRunOn.t.Errorf("RepositoryMock.DeletePipelineRunOn got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmDeleteNamespacePipelineReleaseByID.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.results + mm_results := mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.results if mm_results == nil { - mmDeleteNamespacePipelineReleaseByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespacePipelineReleaseByID") + mmDeletePipelineRunOn.t.Fatal("No results are set for the RepositoryMock.DeletePipelineRunOn") } return (*mm_results).err } - if mmDeleteNamespacePipelineReleaseByID.funcDeleteNamespacePipelineReleaseByID != nil { - return mmDeleteNamespacePipelineReleaseByID.funcDeleteNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id) + if mmDeletePipelineRunOn.funcDeletePipelineRunOn != nil { + return mmDeletePipelineRunOn.funcDeletePipelineRunOn(ctx, uid) } - mmDeleteNamespacePipelineReleaseByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespacePipelineReleaseByID. %v %v %v %v", ctx, ownerPermalink, pipelineUID, id) + mmDeletePipelineRunOn.t.Fatalf("Unexpected call to RepositoryMock.DeletePipelineRunOn. %v %v", ctx, uid) return } -// DeleteNamespacePipelineReleaseByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespacePipelineReleaseByID invocations -func (mmDeleteNamespacePipelineReleaseByID *RepositoryMock) DeleteNamespacePipelineReleaseByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.afterDeleteNamespacePipelineReleaseByIDCounter) +// DeletePipelineRunOnAfterCounter returns a count of finished RepositoryMock.DeletePipelineRunOn invocations +func (mmDeletePipelineRunOn *RepositoryMock) DeletePipelineRunOnAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeletePipelineRunOn.afterDeletePipelineRunOnCounter) } -// DeleteNamespacePipelineReleaseByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespacePipelineReleaseByID invocations -func (mmDeleteNamespacePipelineReleaseByID *RepositoryMock) DeleteNamespacePipelineReleaseByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespacePipelineReleaseByID.beforeDeleteNamespacePipelineReleaseByIDCounter) +// DeletePipelineRunOnBeforeCounter returns a count of RepositoryMock.DeletePipelineRunOn invocations +func (mmDeletePipelineRunOn *RepositoryMock) DeletePipelineRunOnBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeletePipelineRunOn.beforeDeletePipelineRunOnCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespacePipelineReleaseByID. +// Calls returns a list of arguments used in each call to RepositoryMock.DeletePipelineRunOn. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmDeleteNamespacePipelineReleaseByID *mRepositoryMockDeleteNamespacePipelineReleaseByID) Calls() []*RepositoryMockDeleteNamespacePipelineReleaseByIDParams { - mmDeleteNamespacePipelineReleaseByID.mutex.RLock() +func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Calls() []*RepositoryMockDeletePipelineRunOnParams { + mmDeletePipelineRunOn.mutex.RLock() - argCopy := make([]*RepositoryMockDeleteNamespacePipelineReleaseByIDParams, len(mmDeleteNamespacePipelineReleaseByID.callArgs)) - copy(argCopy, mmDeleteNamespacePipelineReleaseByID.callArgs) + argCopy := make([]*RepositoryMockDeletePipelineRunOnParams, len(mmDeletePipelineRunOn.callArgs)) + copy(argCopy, mmDeletePipelineRunOn.callArgs) - mmDeleteNamespacePipelineReleaseByID.mutex.RUnlock() + mmDeletePipelineRunOn.mutex.RUnlock() return argCopy } -// MinimockDeleteNamespacePipelineReleaseByIDDone returns true if the count of the DeleteNamespacePipelineReleaseByID invocations corresponds +// MinimockDeletePipelineRunOnDone returns true if the count of the DeletePipelineRunOn invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockDeleteNamespacePipelineReleaseByIDDone() bool { - if m.DeleteNamespacePipelineReleaseByIDMock.optional { +func (m *RepositoryMock) MinimockDeletePipelineRunOnDone() bool { + if m.DeletePipelineRunOnMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.DeleteNamespacePipelineReleaseByIDMock.expectations { + for _, e := range m.DeletePipelineRunOnMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.DeleteNamespacePipelineReleaseByIDMock.invocationsDone() + return m.DeletePipelineRunOnMock.invocationsDone() } -// MinimockDeleteNamespacePipelineReleaseByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockDeleteNamespacePipelineReleaseByIDInspect() { - for _, e := range m.DeleteNamespacePipelineReleaseByIDMock.expectations { +// MinimockDeletePipelineRunOnInspect logs each unmet expectation +func (m *RepositoryMock) MinimockDeletePipelineRunOnInspect() { + for _, e := range m.DeletePipelineRunOnMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterDeleteNamespacePipelineReleaseByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespacePipelineReleaseByIDCounter) + afterDeletePipelineRunOnCounter := mm_atomic.LoadUint64(&m.afterDeletePipelineRunOnCounter) // if default expectation was set then invocations count should be greater than zero - if m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation != nil && afterDeleteNamespacePipelineReleaseByIDCounter < 1 { - if m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s", m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.returnOrigin) + if m.DeletePipelineRunOnMock.defaultExpectation != nil && afterDeletePipelineRunOnCounter < 1 { + if m.DeletePipelineRunOnMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s", m.DeletePipelineRunOnMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s with params: %#v", m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespacePipelineReleaseByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s with params: %#v", m.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *m.DeletePipelineRunOnMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcDeleteNamespacePipelineReleaseByID != nil && afterDeleteNamespacePipelineReleaseByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s", m.funcDeleteNamespacePipelineReleaseByIDOrigin) + if m.funcDeletePipelineRunOn != nil && afterDeletePipelineRunOnCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s", m.funcDeletePipelineRunOnOrigin) } - if !m.DeleteNamespacePipelineReleaseByIDMock.invocationsDone() && afterDeleteNamespacePipelineReleaseByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespacePipelineReleaseByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.DeleteNamespacePipelineReleaseByIDMock.expectedInvocations), m.DeleteNamespacePipelineReleaseByIDMock.expectedInvocationsOrigin, afterDeleteNamespacePipelineReleaseByIDCounter) + if !m.DeletePipelineRunOnMock.invocationsDone() && afterDeletePipelineRunOnCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.DeletePipelineRunOn at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeletePipelineRunOnMock.expectedInvocations), m.DeletePipelineRunOnMock.expectedInvocationsOrigin, afterDeletePipelineRunOnCounter) } } -type mRepositoryMockDeleteNamespaceSecretByID struct { +type mRepositoryMockDeletePipelineTags struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockDeleteNamespaceSecretByIDExpectation - expectations []*RepositoryMockDeleteNamespaceSecretByIDExpectation + defaultExpectation *RepositoryMockDeletePipelineTagsExpectation + expectations []*RepositoryMockDeletePipelineTagsExpectation - callArgs []*RepositoryMockDeleteNamespaceSecretByIDParams + callArgs []*RepositoryMockDeletePipelineTagsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockDeleteNamespaceSecretByIDExpectation specifies expectation struct of the Repository.DeleteNamespaceSecretByID -type RepositoryMockDeleteNamespaceSecretByIDExpectation struct { +// RepositoryMockDeletePipelineTagsExpectation specifies expectation struct of the Repository.DeletePipelineTags +type RepositoryMockDeletePipelineTagsExpectation struct { mock *RepositoryMock - params *RepositoryMockDeleteNamespaceSecretByIDParams - paramPtrs *RepositoryMockDeleteNamespaceSecretByIDParamPtrs - expectationOrigins RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins - results *RepositoryMockDeleteNamespaceSecretByIDResults + params *RepositoryMockDeletePipelineTagsParams + paramPtrs *RepositoryMockDeletePipelineTagsParamPtrs + expectationOrigins RepositoryMockDeletePipelineTagsExpectationOrigins + results *RepositoryMockDeletePipelineTagsResults returnOrigin string Counter uint64 } -// RepositoryMockDeleteNamespaceSecretByIDParams contains parameters of the Repository.DeleteNamespaceSecretByID -type RepositoryMockDeleteNamespaceSecretByIDParams struct { - ctx context.Context - ownerPermalink string - id string +// RepositoryMockDeletePipelineTagsParams contains parameters of the Repository.DeletePipelineTags +type RepositoryMockDeletePipelineTagsParams struct { + ctx context.Context + pipelineUID uuid.UUID + tagNames []string } -// RepositoryMockDeleteNamespaceSecretByIDParamPtrs contains pointers to parameters of the Repository.DeleteNamespaceSecretByID -type RepositoryMockDeleteNamespaceSecretByIDParamPtrs struct { - ctx *context.Context - ownerPermalink *string - id *string +// RepositoryMockDeletePipelineTagsParamPtrs contains pointers to parameters of the Repository.DeletePipelineTags +type RepositoryMockDeletePipelineTagsParamPtrs struct { + ctx *context.Context + pipelineUID *uuid.UUID + tagNames *[]string } -// RepositoryMockDeleteNamespaceSecretByIDResults contains results of the Repository.DeleteNamespaceSecretByID -type RepositoryMockDeleteNamespaceSecretByIDResults struct { +// RepositoryMockDeletePipelineTagsResults contains results of the Repository.DeletePipelineTags +type RepositoryMockDeletePipelineTagsResults struct { err error } -// RepositoryMockDeleteNamespaceSecretByIDOrigins contains origins of expectations of the Repository.DeleteNamespaceSecretByID -type RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins struct { - origin string - originCtx string - originOwnerPermalink string - originId string +// RepositoryMockDeletePipelineTagsOrigins contains origins of expectations of the Repository.DeletePipelineTags +type RepositoryMockDeletePipelineTagsExpectationOrigins struct { + origin string + originCtx string + originPipelineUID string + originTagNames string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -5029,369 +5060,370 @@ type RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Optional() *mRepositoryMockDeleteNamespaceSecretByID { - mmDeleteNamespaceSecretByID.optional = true - return mmDeleteNamespaceSecretByID +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Optional() *mRepositoryMockDeletePipelineTags { + mmDeletePipelineTags.optional = true + return mmDeletePipelineTags } -// Expect sets up expected params for Repository.DeleteNamespaceSecretByID -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Expect(ctx context.Context, ownerPermalink string, id string) *mRepositoryMockDeleteNamespaceSecretByID { - if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") +// Expect sets up expected params for Repository.DeletePipelineTags +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Expect(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *mRepositoryMockDeletePipelineTags { + if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") } - if mmDeleteNamespaceSecretByID.defaultExpectation == nil { - mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} + if mmDeletePipelineTags.defaultExpectation == nil { + mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} } - if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by ExpectParams functions") + if mmDeletePipelineTags.defaultExpectation.paramPtrs != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by ExpectParams functions") } - mmDeleteNamespaceSecretByID.defaultExpectation.params = &RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id} - mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmDeleteNamespaceSecretByID.expectations { - if minimock.Equal(e.params, mmDeleteNamespaceSecretByID.defaultExpectation.params) { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteNamespaceSecretByID.defaultExpectation.params) + mmDeletePipelineTags.defaultExpectation.params = &RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames} + mmDeletePipelineTags.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeletePipelineTags.expectations { + if minimock.Equal(e.params, mmDeletePipelineTags.defaultExpectation.params) { + mmDeletePipelineTags.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeletePipelineTags.defaultExpectation.params) } } - return mmDeleteNamespaceSecretByID + return mmDeletePipelineTags } -// ExpectCtxParam1 sets up expected param ctx for Repository.DeleteNamespaceSecretByID -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeleteNamespaceSecretByID { - if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.DeletePipelineTags +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeletePipelineTags { + if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") } - if mmDeleteNamespaceSecretByID.defaultExpectation == nil { - mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} + if mmDeletePipelineTags.defaultExpectation == nil { + mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} } - if mmDeleteNamespaceSecretByID.defaultExpectation.params != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Expect") + if mmDeletePipelineTags.defaultExpectation.params != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Expect") } - if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceSecretByIDParamPtrs{} + if mmDeletePipelineTags.defaultExpectation.paramPtrs == nil { + mmDeletePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineTagsParamPtrs{} } - mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs.ctx = &ctx - mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmDeletePipelineTags.defaultExpectation.paramPtrs.ctx = &ctx + mmDeletePipelineTags.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmDeleteNamespaceSecretByID + return mmDeletePipelineTags } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.DeleteNamespaceSecretByID -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockDeleteNamespaceSecretByID { - if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") +// ExpectPipelineUIDParam2 sets up expected param pipelineUID for Repository.DeletePipelineTags +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) ExpectPipelineUIDParam2(pipelineUID uuid.UUID) *mRepositoryMockDeletePipelineTags { + if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") } - if mmDeleteNamespaceSecretByID.defaultExpectation == nil { - mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} + if mmDeletePipelineTags.defaultExpectation == nil { + mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} } - if mmDeleteNamespaceSecretByID.defaultExpectation.params != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Expect") + if mmDeletePipelineTags.defaultExpectation.params != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Expect") } - if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceSecretByIDParamPtrs{} + if mmDeletePipelineTags.defaultExpectation.paramPtrs == nil { + mmDeletePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineTagsParamPtrs{} } - mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmDeletePipelineTags.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmDeletePipelineTags.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - return mmDeleteNamespaceSecretByID + return mmDeletePipelineTags } -// ExpectIdParam3 sets up expected param id for Repository.DeleteNamespaceSecretByID -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) ExpectIdParam3(id string) *mRepositoryMockDeleteNamespaceSecretByID { - if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") +// ExpectTagNamesParam3 sets up expected param tagNames for Repository.DeletePipelineTags +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) ExpectTagNamesParam3(tagNames []string) *mRepositoryMockDeletePipelineTags { + if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") } - if mmDeleteNamespaceSecretByID.defaultExpectation == nil { - mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{} + if mmDeletePipelineTags.defaultExpectation == nil { + mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} } - if mmDeleteNamespaceSecretByID.defaultExpectation.params != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Expect") + if mmDeletePipelineTags.defaultExpectation.params != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Expect") } - if mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs == nil { - mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockDeleteNamespaceSecretByIDParamPtrs{} + if mmDeletePipelineTags.defaultExpectation.paramPtrs == nil { + mmDeletePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineTagsParamPtrs{} } - mmDeleteNamespaceSecretByID.defaultExpectation.paramPtrs.id = &id - mmDeleteNamespaceSecretByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmDeletePipelineTags.defaultExpectation.paramPtrs.tagNames = &tagNames + mmDeletePipelineTags.defaultExpectation.expectationOrigins.originTagNames = minimock.CallerInfo(1) - return mmDeleteNamespaceSecretByID + return mmDeletePipelineTags } -// Inspect accepts an inspector function that has same arguments as the Repository.DeleteNamespaceSecretByID -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string)) *mRepositoryMockDeleteNamespaceSecretByID { - if mmDeleteNamespaceSecretByID.mock.inspectFuncDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeleteNamespaceSecretByID") +// Inspect accepts an inspector function that has same arguments as the Repository.DeletePipelineTags +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Inspect(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string)) *mRepositoryMockDeletePipelineTags { + if mmDeletePipelineTags.mock.inspectFuncDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeletePipelineTags") } - mmDeleteNamespaceSecretByID.mock.inspectFuncDeleteNamespaceSecretByID = f + mmDeletePipelineTags.mock.inspectFuncDeletePipelineTags = f - return mmDeleteNamespaceSecretByID + return mmDeletePipelineTags } -// Return sets up results that will be returned by Repository.DeleteNamespaceSecretByID -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Return(err error) *RepositoryMock { - if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") +// Return sets up results that will be returned by Repository.DeletePipelineTags +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Return(err error) *RepositoryMock { + if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") } - if mmDeleteNamespaceSecretByID.defaultExpectation == nil { - mmDeleteNamespaceSecretByID.defaultExpectation = &RepositoryMockDeleteNamespaceSecretByIDExpectation{mock: mmDeleteNamespaceSecretByID.mock} + if mmDeletePipelineTags.defaultExpectation == nil { + mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{mock: mmDeletePipelineTags.mock} } - mmDeleteNamespaceSecretByID.defaultExpectation.results = &RepositoryMockDeleteNamespaceSecretByIDResults{err} - mmDeleteNamespaceSecretByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmDeleteNamespaceSecretByID.mock + mmDeletePipelineTags.defaultExpectation.results = &RepositoryMockDeletePipelineTagsResults{err} + mmDeletePipelineTags.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeletePipelineTags.mock } -// Set uses given function f to mock the Repository.DeleteNamespaceSecretByID method -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Set(f func(ctx context.Context, ownerPermalink string, id string) (err error)) *RepositoryMock { - if mmDeleteNamespaceSecretByID.defaultExpectation != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("Default expectation is already set for the Repository.DeleteNamespaceSecretByID method") +// Set uses given function f to mock the Repository.DeletePipelineTags method +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Set(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error)) *RepositoryMock { + if mmDeletePipelineTags.defaultExpectation != nil { + mmDeletePipelineTags.mock.t.Fatalf("Default expectation is already set for the Repository.DeletePipelineTags method") } - if len(mmDeleteNamespaceSecretByID.expectations) > 0 { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("Some expectations are already set for the Repository.DeleteNamespaceSecretByID method") + if len(mmDeletePipelineTags.expectations) > 0 { + mmDeletePipelineTags.mock.t.Fatalf("Some expectations are already set for the Repository.DeletePipelineTags method") } - mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID = f - mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByIDOrigin = minimock.CallerInfo(1) - return mmDeleteNamespaceSecretByID.mock + mmDeletePipelineTags.mock.funcDeletePipelineTags = f + mmDeletePipelineTags.mock.funcDeletePipelineTagsOrigin = minimock.CallerInfo(1) + return mmDeletePipelineTags.mock } -// When sets expectation for the Repository.DeleteNamespaceSecretByID which will trigger the result defined by the following +// When sets expectation for the Repository.DeletePipelineTags which will trigger the result defined by the following // Then helper -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) When(ctx context.Context, ownerPermalink string, id string) *RepositoryMockDeleteNamespaceSecretByIDExpectation { - if mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.DeleteNamespaceSecretByID mock is already set by Set") +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) When(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *RepositoryMockDeletePipelineTagsExpectation { + if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { + mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") } - expectation := &RepositoryMockDeleteNamespaceSecretByIDExpectation{ - mock: mmDeleteNamespaceSecretByID.mock, - params: &RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id}, - expectationOrigins: RepositoryMockDeleteNamespaceSecretByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockDeletePipelineTagsExpectation{ + mock: mmDeletePipelineTags.mock, + params: &RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames}, + expectationOrigins: RepositoryMockDeletePipelineTagsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmDeleteNamespaceSecretByID.expectations = append(mmDeleteNamespaceSecretByID.expectations, expectation) + mmDeletePipelineTags.expectations = append(mmDeletePipelineTags.expectations, expectation) return expectation } -// Then sets up Repository.DeleteNamespaceSecretByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockDeleteNamespaceSecretByIDExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockDeleteNamespaceSecretByIDResults{err} +// Then sets up Repository.DeletePipelineTags return parameters for the expectation previously defined by the When method +func (e *RepositoryMockDeletePipelineTagsExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockDeletePipelineTagsResults{err} return e.mock } -// Times sets number of times Repository.DeleteNamespaceSecretByID should be invoked -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Times(n uint64) *mRepositoryMockDeleteNamespaceSecretByID { +// Times sets number of times Repository.DeletePipelineTags should be invoked +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Times(n uint64) *mRepositoryMockDeletePipelineTags { if n == 0 { - mmDeleteNamespaceSecretByID.mock.t.Fatalf("Times of RepositoryMock.DeleteNamespaceSecretByID mock can not be zero") + mmDeletePipelineTags.mock.t.Fatalf("Times of RepositoryMock.DeletePipelineTags mock can not be zero") } - mm_atomic.StoreUint64(&mmDeleteNamespaceSecretByID.expectedInvocations, n) - mmDeleteNamespaceSecretByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmDeleteNamespaceSecretByID + mm_atomic.StoreUint64(&mmDeletePipelineTags.expectedInvocations, n) + mmDeletePipelineTags.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeletePipelineTags } -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) invocationsDone() bool { - if len(mmDeleteNamespaceSecretByID.expectations) == 0 && mmDeleteNamespaceSecretByID.defaultExpectation == nil && mmDeleteNamespaceSecretByID.mock.funcDeleteNamespaceSecretByID == nil { +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) invocationsDone() bool { + if len(mmDeletePipelineTags.expectations) == 0 && mmDeletePipelineTags.defaultExpectation == nil && mmDeletePipelineTags.mock.funcDeletePipelineTags == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.mock.afterDeleteNamespaceSecretByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmDeletePipelineTags.mock.afterDeletePipelineTagsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeletePipelineTags.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// DeleteNamespaceSecretByID implements mm_repository.Repository -func (mmDeleteNamespaceSecretByID *RepositoryMock) DeleteNamespaceSecretByID(ctx context.Context, ownerPermalink string, id string) (err error) { - mm_atomic.AddUint64(&mmDeleteNamespaceSecretByID.beforeDeleteNamespaceSecretByIDCounter, 1) - defer mm_atomic.AddUint64(&mmDeleteNamespaceSecretByID.afterDeleteNamespaceSecretByIDCounter, 1) +// DeletePipelineTags implements mm_repository.Repository +func (mmDeletePipelineTags *RepositoryMock) DeletePipelineTags(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error) { + mm_atomic.AddUint64(&mmDeletePipelineTags.beforeDeletePipelineTagsCounter, 1) + defer mm_atomic.AddUint64(&mmDeletePipelineTags.afterDeletePipelineTagsCounter, 1) - mmDeleteNamespaceSecretByID.t.Helper() + mmDeletePipelineTags.t.Helper() - if mmDeleteNamespaceSecretByID.inspectFuncDeleteNamespaceSecretByID != nil { - mmDeleteNamespaceSecretByID.inspectFuncDeleteNamespaceSecretByID(ctx, ownerPermalink, id) + if mmDeletePipelineTags.inspectFuncDeletePipelineTags != nil { + mmDeletePipelineTags.inspectFuncDeletePipelineTags(ctx, pipelineUID, tagNames) } - mm_params := RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id} + mm_params := RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames} // Record call args - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.mutex.Lock() - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.callArgs = append(mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.callArgs, &mm_params) - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.mutex.Unlock() + mmDeletePipelineTags.DeletePipelineTagsMock.mutex.Lock() + mmDeletePipelineTags.DeletePipelineTagsMock.callArgs = append(mmDeletePipelineTags.DeletePipelineTagsMock.callArgs, &mm_params) + mmDeletePipelineTags.DeletePipelineTagsMock.mutex.Unlock() - for _, e := range mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.expectations { + for _, e := range mmDeletePipelineTags.DeletePipelineTagsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.err } } - if mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.Counter, 1) - mm_want := mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.params - mm_want_ptrs := mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.paramPtrs + if mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.Counter, 1) + mm_want := mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.params + mm_want_ptrs := mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockDeleteNamespaceSecretByIDParams{ctx, ownerPermalink, id} + mm_got := RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) } - if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + if mm_want_ptrs.tagNames != nil && !minimock.Equal(*mm_want_ptrs.tagNames, mm_got.tagNames) { + mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameter tagNames, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.originTagNames, *mm_want_ptrs.tagNames, mm_got.tagNames, minimock.Diff(*mm_want_ptrs.tagNames, mm_got.tagNames)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteNamespaceSecretByID.t.Errorf("RepositoryMock.DeleteNamespaceSecretByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmDeleteNamespaceSecretByID.DeleteNamespaceSecretByIDMock.defaultExpectation.results + mm_results := mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.results if mm_results == nil { - mmDeleteNamespaceSecretByID.t.Fatal("No results are set for the RepositoryMock.DeleteNamespaceSecretByID") + mmDeletePipelineTags.t.Fatal("No results are set for the RepositoryMock.DeletePipelineTags") } return (*mm_results).err } - if mmDeleteNamespaceSecretByID.funcDeleteNamespaceSecretByID != nil { - return mmDeleteNamespaceSecretByID.funcDeleteNamespaceSecretByID(ctx, ownerPermalink, id) + if mmDeletePipelineTags.funcDeletePipelineTags != nil { + return mmDeletePipelineTags.funcDeletePipelineTags(ctx, pipelineUID, tagNames) } - mmDeleteNamespaceSecretByID.t.Fatalf("Unexpected call to RepositoryMock.DeleteNamespaceSecretByID. %v %v %v", ctx, ownerPermalink, id) + mmDeletePipelineTags.t.Fatalf("Unexpected call to RepositoryMock.DeletePipelineTags. %v %v %v", ctx, pipelineUID, tagNames) return } -// DeleteNamespaceSecretByIDAfterCounter returns a count of finished RepositoryMock.DeleteNamespaceSecretByID invocations -func (mmDeleteNamespaceSecretByID *RepositoryMock) DeleteNamespaceSecretByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.afterDeleteNamespaceSecretByIDCounter) +// DeletePipelineTagsAfterCounter returns a count of finished RepositoryMock.DeletePipelineTags invocations +func (mmDeletePipelineTags *RepositoryMock) DeletePipelineTagsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeletePipelineTags.afterDeletePipelineTagsCounter) } -// DeleteNamespaceSecretByIDBeforeCounter returns a count of RepositoryMock.DeleteNamespaceSecretByID invocations -func (mmDeleteNamespaceSecretByID *RepositoryMock) DeleteNamespaceSecretByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeleteNamespaceSecretByID.beforeDeleteNamespaceSecretByIDCounter) +// DeletePipelineTagsBeforeCounter returns a count of RepositoryMock.DeletePipelineTags invocations +func (mmDeletePipelineTags *RepositoryMock) DeletePipelineTagsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeletePipelineTags.beforeDeletePipelineTagsCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.DeleteNamespaceSecretByID. +// Calls returns a list of arguments used in each call to RepositoryMock.DeletePipelineTags. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmDeleteNamespaceSecretByID *mRepositoryMockDeleteNamespaceSecretByID) Calls() []*RepositoryMockDeleteNamespaceSecretByIDParams { - mmDeleteNamespaceSecretByID.mutex.RLock() +func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Calls() []*RepositoryMockDeletePipelineTagsParams { + mmDeletePipelineTags.mutex.RLock() - argCopy := make([]*RepositoryMockDeleteNamespaceSecretByIDParams, len(mmDeleteNamespaceSecretByID.callArgs)) - copy(argCopy, mmDeleteNamespaceSecretByID.callArgs) + argCopy := make([]*RepositoryMockDeletePipelineTagsParams, len(mmDeletePipelineTags.callArgs)) + copy(argCopy, mmDeletePipelineTags.callArgs) - mmDeleteNamespaceSecretByID.mutex.RUnlock() + mmDeletePipelineTags.mutex.RUnlock() return argCopy } -// MinimockDeleteNamespaceSecretByIDDone returns true if the count of the DeleteNamespaceSecretByID invocations corresponds +// MinimockDeletePipelineTagsDone returns true if the count of the DeletePipelineTags invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockDeleteNamespaceSecretByIDDone() bool { - if m.DeleteNamespaceSecretByIDMock.optional { +func (m *RepositoryMock) MinimockDeletePipelineTagsDone() bool { + if m.DeletePipelineTagsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.DeleteNamespaceSecretByIDMock.expectations { + for _, e := range m.DeletePipelineTagsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.DeleteNamespaceSecretByIDMock.invocationsDone() + return m.DeletePipelineTagsMock.invocationsDone() } -// MinimockDeleteNamespaceSecretByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockDeleteNamespaceSecretByIDInspect() { - for _, e := range m.DeleteNamespaceSecretByIDMock.expectations { +// MinimockDeletePipelineTagsInspect logs each unmet expectation +func (m *RepositoryMock) MinimockDeletePipelineTagsInspect() { + for _, e := range m.DeletePipelineTagsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterDeleteNamespaceSecretByIDCounter := mm_atomic.LoadUint64(&m.afterDeleteNamespaceSecretByIDCounter) + afterDeletePipelineTagsCounter := mm_atomic.LoadUint64(&m.afterDeletePipelineTagsCounter) // if default expectation was set then invocations count should be greater than zero - if m.DeleteNamespaceSecretByIDMock.defaultExpectation != nil && afterDeleteNamespaceSecretByIDCounter < 1 { - if m.DeleteNamespaceSecretByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s", m.DeleteNamespaceSecretByIDMock.defaultExpectation.returnOrigin) + if m.DeletePipelineTagsMock.defaultExpectation != nil && afterDeletePipelineTagsCounter < 1 { + if m.DeletePipelineTagsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s", m.DeletePipelineTagsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s with params: %#v", m.DeleteNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *m.DeleteNamespaceSecretByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s with params: %#v", m.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *m.DeletePipelineTagsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcDeleteNamespaceSecretByID != nil && afterDeleteNamespaceSecretByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeleteNamespaceSecretByID at\n%s", m.funcDeleteNamespaceSecretByIDOrigin) + if m.funcDeletePipelineTags != nil && afterDeletePipelineTagsCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s", m.funcDeletePipelineTagsOrigin) } - if !m.DeleteNamespaceSecretByIDMock.invocationsDone() && afterDeleteNamespaceSecretByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.DeleteNamespaceSecretByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.DeleteNamespaceSecretByIDMock.expectedInvocations), m.DeleteNamespaceSecretByIDMock.expectedInvocationsOrigin, afterDeleteNamespaceSecretByIDCounter) + if !m.DeletePipelineTagsMock.invocationsDone() && afterDeletePipelineTagsCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.DeletePipelineTags at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeletePipelineTagsMock.expectedInvocations), m.DeletePipelineTagsMock.expectedInvocationsOrigin, afterDeletePipelineTagsCounter) } } -type mRepositoryMockDeletePipelineRunOn struct { +type mRepositoryMockGetConnectionByUID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockDeletePipelineRunOnExpectation - expectations []*RepositoryMockDeletePipelineRunOnExpectation + defaultExpectation *RepositoryMockGetConnectionByUIDExpectation + expectations []*RepositoryMockGetConnectionByUIDExpectation - callArgs []*RepositoryMockDeletePipelineRunOnParams + callArgs []*RepositoryMockGetConnectionByUIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockDeletePipelineRunOnExpectation specifies expectation struct of the Repository.DeletePipelineRunOn -type RepositoryMockDeletePipelineRunOnExpectation struct { +// RepositoryMockGetConnectionByUIDExpectation specifies expectation struct of the Repository.GetConnectionByUID +type RepositoryMockGetConnectionByUIDExpectation struct { mock *RepositoryMock - params *RepositoryMockDeletePipelineRunOnParams - paramPtrs *RepositoryMockDeletePipelineRunOnParamPtrs - expectationOrigins RepositoryMockDeletePipelineRunOnExpectationOrigins - results *RepositoryMockDeletePipelineRunOnResults + params *RepositoryMockGetConnectionByUIDParams + paramPtrs *RepositoryMockGetConnectionByUIDParamPtrs + expectationOrigins RepositoryMockGetConnectionByUIDExpectationOrigins + results *RepositoryMockGetConnectionByUIDResults returnOrigin string Counter uint64 } -// RepositoryMockDeletePipelineRunOnParams contains parameters of the Repository.DeletePipelineRunOn -type RepositoryMockDeletePipelineRunOnParams struct { +// RepositoryMockGetConnectionByUIDParams contains parameters of the Repository.GetConnectionByUID +type RepositoryMockGetConnectionByUIDParams struct { ctx context.Context - uid uuid.UUID + u1 uuid.UUID } -// RepositoryMockDeletePipelineRunOnParamPtrs contains pointers to parameters of the Repository.DeletePipelineRunOn -type RepositoryMockDeletePipelineRunOnParamPtrs struct { +// RepositoryMockGetConnectionByUIDParamPtrs contains pointers to parameters of the Repository.GetConnectionByUID +type RepositoryMockGetConnectionByUIDParamPtrs struct { ctx *context.Context - uid *uuid.UUID + u1 *uuid.UUID } -// RepositoryMockDeletePipelineRunOnResults contains results of the Repository.DeletePipelineRunOn -type RepositoryMockDeletePipelineRunOnResults struct { +// RepositoryMockGetConnectionByUIDResults contains results of the Repository.GetConnectionByUID +type RepositoryMockGetConnectionByUIDResults struct { + cp1 *datamodel.Connection err error } -// RepositoryMockDeletePipelineRunOnOrigins contains origins of expectations of the Repository.DeletePipelineRunOn -type RepositoryMockDeletePipelineRunOnExpectationOrigins struct { +// RepositoryMockGetConnectionByUIDOrigins contains origins of expectations of the Repository.GetConnectionByUID +type RepositoryMockGetConnectionByUIDExpectationOrigins struct { origin string originCtx string - originUid string + originU1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -5399,344 +5431,342 @@ type RepositoryMockDeletePipelineRunOnExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Optional() *mRepositoryMockDeletePipelineRunOn { - mmDeletePipelineRunOn.optional = true - return mmDeletePipelineRunOn +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Optional() *mRepositoryMockGetConnectionByUID { + mmGetConnectionByUID.optional = true + return mmGetConnectionByUID } -// Expect sets up expected params for Repository.DeletePipelineRunOn -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Expect(ctx context.Context, uid uuid.UUID) *mRepositoryMockDeletePipelineRunOn { - if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") +// Expect sets up expected params for Repository.GetConnectionByUID +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Expect(ctx context.Context, u1 uuid.UUID) *mRepositoryMockGetConnectionByUID { + if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") } - if mmDeletePipelineRunOn.defaultExpectation == nil { - mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{} + if mmGetConnectionByUID.defaultExpectation == nil { + mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{} } - if mmDeletePipelineRunOn.defaultExpectation.paramPtrs != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by ExpectParams functions") + if mmGetConnectionByUID.defaultExpectation.paramPtrs != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by ExpectParams functions") } - mmDeletePipelineRunOn.defaultExpectation.params = &RepositoryMockDeletePipelineRunOnParams{ctx, uid} - mmDeletePipelineRunOn.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmDeletePipelineRunOn.expectations { - if minimock.Equal(e.params, mmDeletePipelineRunOn.defaultExpectation.params) { - mmDeletePipelineRunOn.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeletePipelineRunOn.defaultExpectation.params) + mmGetConnectionByUID.defaultExpectation.params = &RepositoryMockGetConnectionByUIDParams{ctx, u1} + mmGetConnectionByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetConnectionByUID.expectations { + if minimock.Equal(e.params, mmGetConnectionByUID.defaultExpectation.params) { + mmGetConnectionByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetConnectionByUID.defaultExpectation.params) } } - return mmDeletePipelineRunOn + return mmGetConnectionByUID } -// ExpectCtxParam1 sets up expected param ctx for Repository.DeletePipelineRunOn -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeletePipelineRunOn { - if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetConnectionByUID +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetConnectionByUID { + if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") } - if mmDeletePipelineRunOn.defaultExpectation == nil { - mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{} + if mmGetConnectionByUID.defaultExpectation == nil { + mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{} } - if mmDeletePipelineRunOn.defaultExpectation.params != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Expect") + if mmGetConnectionByUID.defaultExpectation.params != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Expect") } - if mmDeletePipelineRunOn.defaultExpectation.paramPtrs == nil { - mmDeletePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineRunOnParamPtrs{} + if mmGetConnectionByUID.defaultExpectation.paramPtrs == nil { + mmGetConnectionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetConnectionByUIDParamPtrs{} } - mmDeletePipelineRunOn.defaultExpectation.paramPtrs.ctx = &ctx - mmDeletePipelineRunOn.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetConnectionByUID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetConnectionByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmDeletePipelineRunOn + return mmGetConnectionByUID } -// ExpectUidParam2 sets up expected param uid for Repository.DeletePipelineRunOn -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockDeletePipelineRunOn { - if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") - } - - if mmDeletePipelineRunOn.defaultExpectation == nil { - mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{} +// ExpectU1Param2 sets up expected param u1 for Repository.GetConnectionByUID +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) ExpectU1Param2(u1 uuid.UUID) *mRepositoryMockGetConnectionByUID { + if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") } - if mmDeletePipelineRunOn.defaultExpectation.params != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Expect") + if mmGetConnectionByUID.defaultExpectation == nil { + mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{} } - if mmDeletePipelineRunOn.defaultExpectation.paramPtrs == nil { - mmDeletePipelineRunOn.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineRunOnParamPtrs{} + if mmGetConnectionByUID.defaultExpectation.params != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Expect") } - mmDeletePipelineRunOn.defaultExpectation.paramPtrs.uid = &uid - mmDeletePipelineRunOn.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - return mmDeletePipelineRunOn + if mmGetConnectionByUID.defaultExpectation.paramPtrs == nil { + mmGetConnectionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetConnectionByUIDParamPtrs{} + } + mmGetConnectionByUID.defaultExpectation.paramPtrs.u1 = &u1 + mmGetConnectionByUID.defaultExpectation.expectationOrigins.originU1 = minimock.CallerInfo(1) + + return mmGetConnectionByUID } -// Inspect accepts an inspector function that has same arguments as the Repository.DeletePipelineRunOn -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Inspect(f func(ctx context.Context, uid uuid.UUID)) *mRepositoryMockDeletePipelineRunOn { - if mmDeletePipelineRunOn.mock.inspectFuncDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeletePipelineRunOn") +// Inspect accepts an inspector function that has same arguments as the Repository.GetConnectionByUID +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Inspect(f func(ctx context.Context, u1 uuid.UUID)) *mRepositoryMockGetConnectionByUID { + if mmGetConnectionByUID.mock.inspectFuncGetConnectionByUID != nil { + mmGetConnectionByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetConnectionByUID") } - mmDeletePipelineRunOn.mock.inspectFuncDeletePipelineRunOn = f + mmGetConnectionByUID.mock.inspectFuncGetConnectionByUID = f - return mmDeletePipelineRunOn + return mmGetConnectionByUID } -// Return sets up results that will be returned by Repository.DeletePipelineRunOn -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Return(err error) *RepositoryMock { - if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") +// Return sets up results that will be returned by Repository.GetConnectionByUID +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Return(cp1 *datamodel.Connection, err error) *RepositoryMock { + if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") } - if mmDeletePipelineRunOn.defaultExpectation == nil { - mmDeletePipelineRunOn.defaultExpectation = &RepositoryMockDeletePipelineRunOnExpectation{mock: mmDeletePipelineRunOn.mock} + if mmGetConnectionByUID.defaultExpectation == nil { + mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{mock: mmGetConnectionByUID.mock} } - mmDeletePipelineRunOn.defaultExpectation.results = &RepositoryMockDeletePipelineRunOnResults{err} - mmDeletePipelineRunOn.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmDeletePipelineRunOn.mock + mmGetConnectionByUID.defaultExpectation.results = &RepositoryMockGetConnectionByUIDResults{cp1, err} + mmGetConnectionByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetConnectionByUID.mock } -// Set uses given function f to mock the Repository.DeletePipelineRunOn method -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Set(f func(ctx context.Context, uid uuid.UUID) (err error)) *RepositoryMock { - if mmDeletePipelineRunOn.defaultExpectation != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("Default expectation is already set for the Repository.DeletePipelineRunOn method") +// Set uses given function f to mock the Repository.GetConnectionByUID method +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Set(f func(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.Connection, err error)) *RepositoryMock { + if mmGetConnectionByUID.defaultExpectation != nil { + mmGetConnectionByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetConnectionByUID method") } - if len(mmDeletePipelineRunOn.expectations) > 0 { - mmDeletePipelineRunOn.mock.t.Fatalf("Some expectations are already set for the Repository.DeletePipelineRunOn method") + if len(mmGetConnectionByUID.expectations) > 0 { + mmGetConnectionByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetConnectionByUID method") } - mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn = f - mmDeletePipelineRunOn.mock.funcDeletePipelineRunOnOrigin = minimock.CallerInfo(1) - return mmDeletePipelineRunOn.mock + mmGetConnectionByUID.mock.funcGetConnectionByUID = f + mmGetConnectionByUID.mock.funcGetConnectionByUIDOrigin = minimock.CallerInfo(1) + return mmGetConnectionByUID.mock } -// When sets expectation for the Repository.DeletePipelineRunOn which will trigger the result defined by the following +// When sets expectation for the Repository.GetConnectionByUID which will trigger the result defined by the following // Then helper -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) When(ctx context.Context, uid uuid.UUID) *RepositoryMockDeletePipelineRunOnExpectation { - if mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.mock.t.Fatalf("RepositoryMock.DeletePipelineRunOn mock is already set by Set") +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) When(ctx context.Context, u1 uuid.UUID) *RepositoryMockGetConnectionByUIDExpectation { + if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { + mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") } - expectation := &RepositoryMockDeletePipelineRunOnExpectation{ - mock: mmDeletePipelineRunOn.mock, - params: &RepositoryMockDeletePipelineRunOnParams{ctx, uid}, - expectationOrigins: RepositoryMockDeletePipelineRunOnExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetConnectionByUIDExpectation{ + mock: mmGetConnectionByUID.mock, + params: &RepositoryMockGetConnectionByUIDParams{ctx, u1}, + expectationOrigins: RepositoryMockGetConnectionByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmDeletePipelineRunOn.expectations = append(mmDeletePipelineRunOn.expectations, expectation) + mmGetConnectionByUID.expectations = append(mmGetConnectionByUID.expectations, expectation) return expectation } -// Then sets up Repository.DeletePipelineRunOn return parameters for the expectation previously defined by the When method -func (e *RepositoryMockDeletePipelineRunOnExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockDeletePipelineRunOnResults{err} +// Then sets up Repository.GetConnectionByUID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetConnectionByUIDExpectation) Then(cp1 *datamodel.Connection, err error) *RepositoryMock { + e.results = &RepositoryMockGetConnectionByUIDResults{cp1, err} return e.mock } -// Times sets number of times Repository.DeletePipelineRunOn should be invoked -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Times(n uint64) *mRepositoryMockDeletePipelineRunOn { +// Times sets number of times Repository.GetConnectionByUID should be invoked +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Times(n uint64) *mRepositoryMockGetConnectionByUID { if n == 0 { - mmDeletePipelineRunOn.mock.t.Fatalf("Times of RepositoryMock.DeletePipelineRunOn mock can not be zero") + mmGetConnectionByUID.mock.t.Fatalf("Times of RepositoryMock.GetConnectionByUID mock can not be zero") } - mm_atomic.StoreUint64(&mmDeletePipelineRunOn.expectedInvocations, n) - mmDeletePipelineRunOn.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmDeletePipelineRunOn + mm_atomic.StoreUint64(&mmGetConnectionByUID.expectedInvocations, n) + mmGetConnectionByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetConnectionByUID } -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) invocationsDone() bool { - if len(mmDeletePipelineRunOn.expectations) == 0 && mmDeletePipelineRunOn.defaultExpectation == nil && mmDeletePipelineRunOn.mock.funcDeletePipelineRunOn == nil { +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) invocationsDone() bool { + if len(mmGetConnectionByUID.expectations) == 0 && mmGetConnectionByUID.defaultExpectation == nil && mmGetConnectionByUID.mock.funcGetConnectionByUID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmDeletePipelineRunOn.mock.afterDeletePipelineRunOnCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmDeletePipelineRunOn.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetConnectionByUID.mock.afterGetConnectionByUIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetConnectionByUID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// DeletePipelineRunOn implements mm_repository.Repository -func (mmDeletePipelineRunOn *RepositoryMock) DeletePipelineRunOn(ctx context.Context, uid uuid.UUID) (err error) { - mm_atomic.AddUint64(&mmDeletePipelineRunOn.beforeDeletePipelineRunOnCounter, 1) - defer mm_atomic.AddUint64(&mmDeletePipelineRunOn.afterDeletePipelineRunOnCounter, 1) +// GetConnectionByUID implements mm_repository.Repository +func (mmGetConnectionByUID *RepositoryMock) GetConnectionByUID(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.Connection, err error) { + mm_atomic.AddUint64(&mmGetConnectionByUID.beforeGetConnectionByUIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetConnectionByUID.afterGetConnectionByUIDCounter, 1) - mmDeletePipelineRunOn.t.Helper() + mmGetConnectionByUID.t.Helper() - if mmDeletePipelineRunOn.inspectFuncDeletePipelineRunOn != nil { - mmDeletePipelineRunOn.inspectFuncDeletePipelineRunOn(ctx, uid) + if mmGetConnectionByUID.inspectFuncGetConnectionByUID != nil { + mmGetConnectionByUID.inspectFuncGetConnectionByUID(ctx, u1) } - mm_params := RepositoryMockDeletePipelineRunOnParams{ctx, uid} + mm_params := RepositoryMockGetConnectionByUIDParams{ctx, u1} // Record call args - mmDeletePipelineRunOn.DeletePipelineRunOnMock.mutex.Lock() - mmDeletePipelineRunOn.DeletePipelineRunOnMock.callArgs = append(mmDeletePipelineRunOn.DeletePipelineRunOnMock.callArgs, &mm_params) - mmDeletePipelineRunOn.DeletePipelineRunOnMock.mutex.Unlock() + mmGetConnectionByUID.GetConnectionByUIDMock.mutex.Lock() + mmGetConnectionByUID.GetConnectionByUIDMock.callArgs = append(mmGetConnectionByUID.GetConnectionByUIDMock.callArgs, &mm_params) + mmGetConnectionByUID.GetConnectionByUIDMock.mutex.Unlock() - for _, e := range mmDeletePipelineRunOn.DeletePipelineRunOnMock.expectations { + for _, e := range mmGetConnectionByUID.GetConnectionByUIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.err + return e.results.cp1, e.results.err } } - if mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.Counter, 1) - mm_want := mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.params - mm_want_ptrs := mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.paramPtrs + if mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.params + mm_want_ptrs := mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockDeletePipelineRunOnParams{ctx, uid} + mm_got := RepositoryMockGetConnectionByUIDParams{ctx, u1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeletePipelineRunOn.t.Errorf("RepositoryMock.DeletePipelineRunOn got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetConnectionByUID.t.Errorf("RepositoryMock.GetConnectionByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { - mmDeletePipelineRunOn.t.Errorf("RepositoryMock.DeletePipelineRunOn got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) + if mm_want_ptrs.u1 != nil && !minimock.Equal(*mm_want_ptrs.u1, mm_got.u1) { + mmGetConnectionByUID.t.Errorf("RepositoryMock.GetConnectionByUID got unexpected parameter u1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.originU1, *mm_want_ptrs.u1, mm_got.u1, minimock.Diff(*mm_want_ptrs.u1, mm_got.u1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeletePipelineRunOn.t.Errorf("RepositoryMock.DeletePipelineRunOn got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetConnectionByUID.t.Errorf("RepositoryMock.GetConnectionByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmDeletePipelineRunOn.DeletePipelineRunOnMock.defaultExpectation.results + mm_results := mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.results if mm_results == nil { - mmDeletePipelineRunOn.t.Fatal("No results are set for the RepositoryMock.DeletePipelineRunOn") + mmGetConnectionByUID.t.Fatal("No results are set for the RepositoryMock.GetConnectionByUID") } - return (*mm_results).err + return (*mm_results).cp1, (*mm_results).err } - if mmDeletePipelineRunOn.funcDeletePipelineRunOn != nil { - return mmDeletePipelineRunOn.funcDeletePipelineRunOn(ctx, uid) + if mmGetConnectionByUID.funcGetConnectionByUID != nil { + return mmGetConnectionByUID.funcGetConnectionByUID(ctx, u1) } - mmDeletePipelineRunOn.t.Fatalf("Unexpected call to RepositoryMock.DeletePipelineRunOn. %v %v", ctx, uid) + mmGetConnectionByUID.t.Fatalf("Unexpected call to RepositoryMock.GetConnectionByUID. %v %v", ctx, u1) return } -// DeletePipelineRunOnAfterCounter returns a count of finished RepositoryMock.DeletePipelineRunOn invocations -func (mmDeletePipelineRunOn *RepositoryMock) DeletePipelineRunOnAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeletePipelineRunOn.afterDeletePipelineRunOnCounter) +// GetConnectionByUIDAfterCounter returns a count of finished RepositoryMock.GetConnectionByUID invocations +func (mmGetConnectionByUID *RepositoryMock) GetConnectionByUIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetConnectionByUID.afterGetConnectionByUIDCounter) } -// DeletePipelineRunOnBeforeCounter returns a count of RepositoryMock.DeletePipelineRunOn invocations -func (mmDeletePipelineRunOn *RepositoryMock) DeletePipelineRunOnBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeletePipelineRunOn.beforeDeletePipelineRunOnCounter) +// GetConnectionByUIDBeforeCounter returns a count of RepositoryMock.GetConnectionByUID invocations +func (mmGetConnectionByUID *RepositoryMock) GetConnectionByUIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetConnectionByUID.beforeGetConnectionByUIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.DeletePipelineRunOn. +// Calls returns a list of arguments used in each call to RepositoryMock.GetConnectionByUID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmDeletePipelineRunOn *mRepositoryMockDeletePipelineRunOn) Calls() []*RepositoryMockDeletePipelineRunOnParams { - mmDeletePipelineRunOn.mutex.RLock() +func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Calls() []*RepositoryMockGetConnectionByUIDParams { + mmGetConnectionByUID.mutex.RLock() - argCopy := make([]*RepositoryMockDeletePipelineRunOnParams, len(mmDeletePipelineRunOn.callArgs)) - copy(argCopy, mmDeletePipelineRunOn.callArgs) + argCopy := make([]*RepositoryMockGetConnectionByUIDParams, len(mmGetConnectionByUID.callArgs)) + copy(argCopy, mmGetConnectionByUID.callArgs) - mmDeletePipelineRunOn.mutex.RUnlock() + mmGetConnectionByUID.mutex.RUnlock() return argCopy } -// MinimockDeletePipelineRunOnDone returns true if the count of the DeletePipelineRunOn invocations corresponds +// MinimockGetConnectionByUIDDone returns true if the count of the GetConnectionByUID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockDeletePipelineRunOnDone() bool { - if m.DeletePipelineRunOnMock.optional { +func (m *RepositoryMock) MinimockGetConnectionByUIDDone() bool { + if m.GetConnectionByUIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.DeletePipelineRunOnMock.expectations { + for _, e := range m.GetConnectionByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.DeletePipelineRunOnMock.invocationsDone() + return m.GetConnectionByUIDMock.invocationsDone() } -// MinimockDeletePipelineRunOnInspect logs each unmet expectation -func (m *RepositoryMock) MinimockDeletePipelineRunOnInspect() { - for _, e := range m.DeletePipelineRunOnMock.expectations { +// MinimockGetConnectionByUIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetConnectionByUIDInspect() { + for _, e := range m.GetConnectionByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterDeletePipelineRunOnCounter := mm_atomic.LoadUint64(&m.afterDeletePipelineRunOnCounter) + afterGetConnectionByUIDCounter := mm_atomic.LoadUint64(&m.afterGetConnectionByUIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.DeletePipelineRunOnMock.defaultExpectation != nil && afterDeletePipelineRunOnCounter < 1 { - if m.DeletePipelineRunOnMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s", m.DeletePipelineRunOnMock.defaultExpectation.returnOrigin) + if m.GetConnectionByUIDMock.defaultExpectation != nil && afterGetConnectionByUIDCounter < 1 { + if m.GetConnectionByUIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s", m.GetConnectionByUIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s with params: %#v", m.DeletePipelineRunOnMock.defaultExpectation.expectationOrigins.origin, *m.DeletePipelineRunOnMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s with params: %#v", m.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetConnectionByUIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcDeletePipelineRunOn != nil && afterDeletePipelineRunOnCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineRunOn at\n%s", m.funcDeletePipelineRunOnOrigin) + if m.funcGetConnectionByUID != nil && afterGetConnectionByUIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s", m.funcGetConnectionByUIDOrigin) } - if !m.DeletePipelineRunOnMock.invocationsDone() && afterDeletePipelineRunOnCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.DeletePipelineRunOn at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.DeletePipelineRunOnMock.expectedInvocations), m.DeletePipelineRunOnMock.expectedInvocationsOrigin, afterDeletePipelineRunOnCounter) + if !m.GetConnectionByUIDMock.invocationsDone() && afterGetConnectionByUIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetConnectionByUID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetConnectionByUIDMock.expectedInvocations), m.GetConnectionByUIDMock.expectedInvocationsOrigin, afterGetConnectionByUIDCounter) } } -type mRepositoryMockDeletePipelineTags struct { +type mRepositoryMockGetDefinitionByUID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockDeletePipelineTagsExpectation - expectations []*RepositoryMockDeletePipelineTagsExpectation + defaultExpectation *RepositoryMockGetDefinitionByUIDExpectation + expectations []*RepositoryMockGetDefinitionByUIDExpectation - callArgs []*RepositoryMockDeletePipelineTagsParams + callArgs []*RepositoryMockGetDefinitionByUIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockDeletePipelineTagsExpectation specifies expectation struct of the Repository.DeletePipelineTags -type RepositoryMockDeletePipelineTagsExpectation struct { +// RepositoryMockGetDefinitionByUIDExpectation specifies expectation struct of the Repository.GetDefinitionByUID +type RepositoryMockGetDefinitionByUIDExpectation struct { mock *RepositoryMock - params *RepositoryMockDeletePipelineTagsParams - paramPtrs *RepositoryMockDeletePipelineTagsParamPtrs - expectationOrigins RepositoryMockDeletePipelineTagsExpectationOrigins - results *RepositoryMockDeletePipelineTagsResults - returnOrigin string + params *RepositoryMockGetDefinitionByUIDParams + paramPtrs *RepositoryMockGetDefinitionByUIDParamPtrs + expectationOrigins RepositoryMockGetDefinitionByUIDExpectationOrigins + results *RepositoryMockGetDefinitionByUIDResults + returnOrigin string Counter uint64 } -// RepositoryMockDeletePipelineTagsParams contains parameters of the Repository.DeletePipelineTags -type RepositoryMockDeletePipelineTagsParams struct { - ctx context.Context - pipelineUID uuid.UUID - tagNames []string +// RepositoryMockGetDefinitionByUIDParams contains parameters of the Repository.GetDefinitionByUID +type RepositoryMockGetDefinitionByUIDParams struct { + ctx context.Context + u1 uuid.UUID } -// RepositoryMockDeletePipelineTagsParamPtrs contains pointers to parameters of the Repository.DeletePipelineTags -type RepositoryMockDeletePipelineTagsParamPtrs struct { - ctx *context.Context - pipelineUID *uuid.UUID - tagNames *[]string +// RepositoryMockGetDefinitionByUIDParamPtrs contains pointers to parameters of the Repository.GetDefinitionByUID +type RepositoryMockGetDefinitionByUIDParamPtrs struct { + ctx *context.Context + u1 *uuid.UUID } -// RepositoryMockDeletePipelineTagsResults contains results of the Repository.DeletePipelineTags -type RepositoryMockDeletePipelineTagsResults struct { +// RepositoryMockGetDefinitionByUIDResults contains results of the Repository.GetDefinitionByUID +type RepositoryMockGetDefinitionByUIDResults struct { + cp1 *datamodel.ComponentDefinition err error } -// RepositoryMockDeletePipelineTagsOrigins contains origins of expectations of the Repository.DeletePipelineTags -type RepositoryMockDeletePipelineTagsExpectationOrigins struct { - origin string - originCtx string - originPipelineUID string - originTagNames string +// RepositoryMockGetDefinitionByUIDOrigins contains origins of expectations of the Repository.GetDefinitionByUID +type RepositoryMockGetDefinitionByUIDExpectationOrigins struct { + origin string + originCtx string + originU1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -5744,370 +5774,339 @@ type RepositoryMockDeletePipelineTagsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Optional() *mRepositoryMockDeletePipelineTags { - mmDeletePipelineTags.optional = true - return mmDeletePipelineTags +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Optional() *mRepositoryMockGetDefinitionByUID { + mmGetDefinitionByUID.optional = true + return mmGetDefinitionByUID } -// Expect sets up expected params for Repository.DeletePipelineTags -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Expect(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *mRepositoryMockDeletePipelineTags { - if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") +// Expect sets up expected params for Repository.GetDefinitionByUID +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Expect(ctx context.Context, u1 uuid.UUID) *mRepositoryMockGetDefinitionByUID { + if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") } - if mmDeletePipelineTags.defaultExpectation == nil { - mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} + if mmGetDefinitionByUID.defaultExpectation == nil { + mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{} } - if mmDeletePipelineTags.defaultExpectation.paramPtrs != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by ExpectParams functions") + if mmGetDefinitionByUID.defaultExpectation.paramPtrs != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by ExpectParams functions") } - mmDeletePipelineTags.defaultExpectation.params = &RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames} - mmDeletePipelineTags.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmDeletePipelineTags.expectations { - if minimock.Equal(e.params, mmDeletePipelineTags.defaultExpectation.params) { - mmDeletePipelineTags.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeletePipelineTags.defaultExpectation.params) + mmGetDefinitionByUID.defaultExpectation.params = &RepositoryMockGetDefinitionByUIDParams{ctx, u1} + mmGetDefinitionByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetDefinitionByUID.expectations { + if minimock.Equal(e.params, mmGetDefinitionByUID.defaultExpectation.params) { + mmGetDefinitionByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetDefinitionByUID.defaultExpectation.params) } } - return mmDeletePipelineTags -} - -// ExpectCtxParam1 sets up expected param ctx for Repository.DeletePipelineTags -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) ExpectCtxParam1(ctx context.Context) *mRepositoryMockDeletePipelineTags { - if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") - } - - if mmDeletePipelineTags.defaultExpectation == nil { - mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} - } - - if mmDeletePipelineTags.defaultExpectation.params != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Expect") - } - - if mmDeletePipelineTags.defaultExpectation.paramPtrs == nil { - mmDeletePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineTagsParamPtrs{} - } - mmDeletePipelineTags.defaultExpectation.paramPtrs.ctx = &ctx - mmDeletePipelineTags.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmDeletePipelineTags + return mmGetDefinitionByUID } -// ExpectPipelineUIDParam2 sets up expected param pipelineUID for Repository.DeletePipelineTags -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) ExpectPipelineUIDParam2(pipelineUID uuid.UUID) *mRepositoryMockDeletePipelineTags { - if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetDefinitionByUID +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetDefinitionByUID { + if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") } - if mmDeletePipelineTags.defaultExpectation == nil { - mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} + if mmGetDefinitionByUID.defaultExpectation == nil { + mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{} } - if mmDeletePipelineTags.defaultExpectation.params != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Expect") + if mmGetDefinitionByUID.defaultExpectation.params != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Expect") } - if mmDeletePipelineTags.defaultExpectation.paramPtrs == nil { - mmDeletePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineTagsParamPtrs{} + if mmGetDefinitionByUID.defaultExpectation.paramPtrs == nil { + mmGetDefinitionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetDefinitionByUIDParamPtrs{} } - mmDeletePipelineTags.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmDeletePipelineTags.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) + mmGetDefinitionByUID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetDefinitionByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmDeletePipelineTags + return mmGetDefinitionByUID } -// ExpectTagNamesParam3 sets up expected param tagNames for Repository.DeletePipelineTags -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) ExpectTagNamesParam3(tagNames []string) *mRepositoryMockDeletePipelineTags { - if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") +// ExpectU1Param2 sets up expected param u1 for Repository.GetDefinitionByUID +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) ExpectU1Param2(u1 uuid.UUID) *mRepositoryMockGetDefinitionByUID { + if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") } - if mmDeletePipelineTags.defaultExpectation == nil { - mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{} + if mmGetDefinitionByUID.defaultExpectation == nil { + mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{} } - if mmDeletePipelineTags.defaultExpectation.params != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Expect") + if mmGetDefinitionByUID.defaultExpectation.params != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Expect") } - if mmDeletePipelineTags.defaultExpectation.paramPtrs == nil { - mmDeletePipelineTags.defaultExpectation.paramPtrs = &RepositoryMockDeletePipelineTagsParamPtrs{} + if mmGetDefinitionByUID.defaultExpectation.paramPtrs == nil { + mmGetDefinitionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetDefinitionByUIDParamPtrs{} } - mmDeletePipelineTags.defaultExpectation.paramPtrs.tagNames = &tagNames - mmDeletePipelineTags.defaultExpectation.expectationOrigins.originTagNames = minimock.CallerInfo(1) + mmGetDefinitionByUID.defaultExpectation.paramPtrs.u1 = &u1 + mmGetDefinitionByUID.defaultExpectation.expectationOrigins.originU1 = minimock.CallerInfo(1) - return mmDeletePipelineTags + return mmGetDefinitionByUID } -// Inspect accepts an inspector function that has same arguments as the Repository.DeletePipelineTags -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Inspect(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string)) *mRepositoryMockDeletePipelineTags { - if mmDeletePipelineTags.mock.inspectFuncDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("Inspect function is already set for RepositoryMock.DeletePipelineTags") +// Inspect accepts an inspector function that has same arguments as the Repository.GetDefinitionByUID +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Inspect(f func(ctx context.Context, u1 uuid.UUID)) *mRepositoryMockGetDefinitionByUID { + if mmGetDefinitionByUID.mock.inspectFuncGetDefinitionByUID != nil { + mmGetDefinitionByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetDefinitionByUID") } - mmDeletePipelineTags.mock.inspectFuncDeletePipelineTags = f + mmGetDefinitionByUID.mock.inspectFuncGetDefinitionByUID = f - return mmDeletePipelineTags + return mmGetDefinitionByUID } -// Return sets up results that will be returned by Repository.DeletePipelineTags -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Return(err error) *RepositoryMock { - if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") +// Return sets up results that will be returned by Repository.GetDefinitionByUID +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Return(cp1 *datamodel.ComponentDefinition, err error) *RepositoryMock { + if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") } - if mmDeletePipelineTags.defaultExpectation == nil { - mmDeletePipelineTags.defaultExpectation = &RepositoryMockDeletePipelineTagsExpectation{mock: mmDeletePipelineTags.mock} + if mmGetDefinitionByUID.defaultExpectation == nil { + mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{mock: mmGetDefinitionByUID.mock} } - mmDeletePipelineTags.defaultExpectation.results = &RepositoryMockDeletePipelineTagsResults{err} - mmDeletePipelineTags.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmDeletePipelineTags.mock + mmGetDefinitionByUID.defaultExpectation.results = &RepositoryMockGetDefinitionByUIDResults{cp1, err} + mmGetDefinitionByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetDefinitionByUID.mock } -// Set uses given function f to mock the Repository.DeletePipelineTags method -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Set(f func(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error)) *RepositoryMock { - if mmDeletePipelineTags.defaultExpectation != nil { - mmDeletePipelineTags.mock.t.Fatalf("Default expectation is already set for the Repository.DeletePipelineTags method") +// Set uses given function f to mock the Repository.GetDefinitionByUID method +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Set(f func(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.ComponentDefinition, err error)) *RepositoryMock { + if mmGetDefinitionByUID.defaultExpectation != nil { + mmGetDefinitionByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetDefinitionByUID method") } - if len(mmDeletePipelineTags.expectations) > 0 { - mmDeletePipelineTags.mock.t.Fatalf("Some expectations are already set for the Repository.DeletePipelineTags method") + if len(mmGetDefinitionByUID.expectations) > 0 { + mmGetDefinitionByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetDefinitionByUID method") } - mmDeletePipelineTags.mock.funcDeletePipelineTags = f - mmDeletePipelineTags.mock.funcDeletePipelineTagsOrigin = minimock.CallerInfo(1) - return mmDeletePipelineTags.mock + mmGetDefinitionByUID.mock.funcGetDefinitionByUID = f + mmGetDefinitionByUID.mock.funcGetDefinitionByUIDOrigin = minimock.CallerInfo(1) + return mmGetDefinitionByUID.mock } -// When sets expectation for the Repository.DeletePipelineTags which will trigger the result defined by the following +// When sets expectation for the Repository.GetDefinitionByUID which will trigger the result defined by the following // Then helper -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) When(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) *RepositoryMockDeletePipelineTagsExpectation { - if mmDeletePipelineTags.mock.funcDeletePipelineTags != nil { - mmDeletePipelineTags.mock.t.Fatalf("RepositoryMock.DeletePipelineTags mock is already set by Set") +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) When(ctx context.Context, u1 uuid.UUID) *RepositoryMockGetDefinitionByUIDExpectation { + if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { + mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") } - expectation := &RepositoryMockDeletePipelineTagsExpectation{ - mock: mmDeletePipelineTags.mock, - params: &RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames}, - expectationOrigins: RepositoryMockDeletePipelineTagsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetDefinitionByUIDExpectation{ + mock: mmGetDefinitionByUID.mock, + params: &RepositoryMockGetDefinitionByUIDParams{ctx, u1}, + expectationOrigins: RepositoryMockGetDefinitionByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmDeletePipelineTags.expectations = append(mmDeletePipelineTags.expectations, expectation) + mmGetDefinitionByUID.expectations = append(mmGetDefinitionByUID.expectations, expectation) return expectation } -// Then sets up Repository.DeletePipelineTags return parameters for the expectation previously defined by the When method -func (e *RepositoryMockDeletePipelineTagsExpectation) Then(err error) *RepositoryMock { - e.results = &RepositoryMockDeletePipelineTagsResults{err} +// Then sets up Repository.GetDefinitionByUID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetDefinitionByUIDExpectation) Then(cp1 *datamodel.ComponentDefinition, err error) *RepositoryMock { + e.results = &RepositoryMockGetDefinitionByUIDResults{cp1, err} return e.mock } -// Times sets number of times Repository.DeletePipelineTags should be invoked -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Times(n uint64) *mRepositoryMockDeletePipelineTags { +// Times sets number of times Repository.GetDefinitionByUID should be invoked +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Times(n uint64) *mRepositoryMockGetDefinitionByUID { if n == 0 { - mmDeletePipelineTags.mock.t.Fatalf("Times of RepositoryMock.DeletePipelineTags mock can not be zero") + mmGetDefinitionByUID.mock.t.Fatalf("Times of RepositoryMock.GetDefinitionByUID mock can not be zero") } - mm_atomic.StoreUint64(&mmDeletePipelineTags.expectedInvocations, n) - mmDeletePipelineTags.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmDeletePipelineTags + mm_atomic.StoreUint64(&mmGetDefinitionByUID.expectedInvocations, n) + mmGetDefinitionByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetDefinitionByUID } -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) invocationsDone() bool { - if len(mmDeletePipelineTags.expectations) == 0 && mmDeletePipelineTags.defaultExpectation == nil && mmDeletePipelineTags.mock.funcDeletePipelineTags == nil { +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) invocationsDone() bool { + if len(mmGetDefinitionByUID.expectations) == 0 && mmGetDefinitionByUID.defaultExpectation == nil && mmGetDefinitionByUID.mock.funcGetDefinitionByUID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmDeletePipelineTags.mock.afterDeletePipelineTagsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmDeletePipelineTags.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetDefinitionByUID.mock.afterGetDefinitionByUIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetDefinitionByUID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// DeletePipelineTags implements mm_repository.Repository -func (mmDeletePipelineTags *RepositoryMock) DeletePipelineTags(ctx context.Context, pipelineUID uuid.UUID, tagNames []string) (err error) { - mm_atomic.AddUint64(&mmDeletePipelineTags.beforeDeletePipelineTagsCounter, 1) - defer mm_atomic.AddUint64(&mmDeletePipelineTags.afterDeletePipelineTagsCounter, 1) +// GetDefinitionByUID implements mm_repository.Repository +func (mmGetDefinitionByUID *RepositoryMock) GetDefinitionByUID(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.ComponentDefinition, err error) { + mm_atomic.AddUint64(&mmGetDefinitionByUID.beforeGetDefinitionByUIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetDefinitionByUID.afterGetDefinitionByUIDCounter, 1) - mmDeletePipelineTags.t.Helper() + mmGetDefinitionByUID.t.Helper() - if mmDeletePipelineTags.inspectFuncDeletePipelineTags != nil { - mmDeletePipelineTags.inspectFuncDeletePipelineTags(ctx, pipelineUID, tagNames) + if mmGetDefinitionByUID.inspectFuncGetDefinitionByUID != nil { + mmGetDefinitionByUID.inspectFuncGetDefinitionByUID(ctx, u1) } - mm_params := RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames} + mm_params := RepositoryMockGetDefinitionByUIDParams{ctx, u1} // Record call args - mmDeletePipelineTags.DeletePipelineTagsMock.mutex.Lock() - mmDeletePipelineTags.DeletePipelineTagsMock.callArgs = append(mmDeletePipelineTags.DeletePipelineTagsMock.callArgs, &mm_params) - mmDeletePipelineTags.DeletePipelineTagsMock.mutex.Unlock() + mmGetDefinitionByUID.GetDefinitionByUIDMock.mutex.Lock() + mmGetDefinitionByUID.GetDefinitionByUIDMock.callArgs = append(mmGetDefinitionByUID.GetDefinitionByUIDMock.callArgs, &mm_params) + mmGetDefinitionByUID.GetDefinitionByUIDMock.mutex.Unlock() - for _, e := range mmDeletePipelineTags.DeletePipelineTagsMock.expectations { + for _, e := range mmGetDefinitionByUID.GetDefinitionByUIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.err + return e.results.cp1, e.results.err } } - if mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.Counter, 1) - mm_want := mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.params - mm_want_ptrs := mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.paramPtrs + if mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.params + mm_want_ptrs := mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockDeletePipelineTagsParams{ctx, pipelineUID, tagNames} + mm_got := RepositoryMockGetDefinitionByUIDParams{ctx, u1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + mmGetDefinitionByUID.t.Errorf("RepositoryMock.GetDefinitionByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.tagNames != nil && !minimock.Equal(*mm_want_ptrs.tagNames, mm_got.tagNames) { - mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameter tagNames, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.originTagNames, *mm_want_ptrs.tagNames, mm_got.tagNames, minimock.Diff(*mm_want_ptrs.tagNames, mm_got.tagNames)) + if mm_want_ptrs.u1 != nil && !minimock.Equal(*mm_want_ptrs.u1, mm_got.u1) { + mmGetDefinitionByUID.t.Errorf("RepositoryMock.GetDefinitionByUID got unexpected parameter u1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.originU1, *mm_want_ptrs.u1, mm_got.u1, minimock.Diff(*mm_want_ptrs.u1, mm_got.u1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeletePipelineTags.t.Errorf("RepositoryMock.DeletePipelineTags got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetDefinitionByUID.t.Errorf("RepositoryMock.GetDefinitionByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmDeletePipelineTags.DeletePipelineTagsMock.defaultExpectation.results + mm_results := mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.results if mm_results == nil { - mmDeletePipelineTags.t.Fatal("No results are set for the RepositoryMock.DeletePipelineTags") + mmGetDefinitionByUID.t.Fatal("No results are set for the RepositoryMock.GetDefinitionByUID") } - return (*mm_results).err + return (*mm_results).cp1, (*mm_results).err } - if mmDeletePipelineTags.funcDeletePipelineTags != nil { - return mmDeletePipelineTags.funcDeletePipelineTags(ctx, pipelineUID, tagNames) + if mmGetDefinitionByUID.funcGetDefinitionByUID != nil { + return mmGetDefinitionByUID.funcGetDefinitionByUID(ctx, u1) } - mmDeletePipelineTags.t.Fatalf("Unexpected call to RepositoryMock.DeletePipelineTags. %v %v %v", ctx, pipelineUID, tagNames) + mmGetDefinitionByUID.t.Fatalf("Unexpected call to RepositoryMock.GetDefinitionByUID. %v %v", ctx, u1) return } -// DeletePipelineTagsAfterCounter returns a count of finished RepositoryMock.DeletePipelineTags invocations -func (mmDeletePipelineTags *RepositoryMock) DeletePipelineTagsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeletePipelineTags.afterDeletePipelineTagsCounter) +// GetDefinitionByUIDAfterCounter returns a count of finished RepositoryMock.GetDefinitionByUID invocations +func (mmGetDefinitionByUID *RepositoryMock) GetDefinitionByUIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetDefinitionByUID.afterGetDefinitionByUIDCounter) } -// DeletePipelineTagsBeforeCounter returns a count of RepositoryMock.DeletePipelineTags invocations -func (mmDeletePipelineTags *RepositoryMock) DeletePipelineTagsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmDeletePipelineTags.beforeDeletePipelineTagsCounter) +// GetDefinitionByUIDBeforeCounter returns a count of RepositoryMock.GetDefinitionByUID invocations +func (mmGetDefinitionByUID *RepositoryMock) GetDefinitionByUIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetDefinitionByUID.beforeGetDefinitionByUIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.DeletePipelineTags. +// Calls returns a list of arguments used in each call to RepositoryMock.GetDefinitionByUID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmDeletePipelineTags *mRepositoryMockDeletePipelineTags) Calls() []*RepositoryMockDeletePipelineTagsParams { - mmDeletePipelineTags.mutex.RLock() +func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Calls() []*RepositoryMockGetDefinitionByUIDParams { + mmGetDefinitionByUID.mutex.RLock() - argCopy := make([]*RepositoryMockDeletePipelineTagsParams, len(mmDeletePipelineTags.callArgs)) - copy(argCopy, mmDeletePipelineTags.callArgs) + argCopy := make([]*RepositoryMockGetDefinitionByUIDParams, len(mmGetDefinitionByUID.callArgs)) + copy(argCopy, mmGetDefinitionByUID.callArgs) - mmDeletePipelineTags.mutex.RUnlock() + mmGetDefinitionByUID.mutex.RUnlock() return argCopy } -// MinimockDeletePipelineTagsDone returns true if the count of the DeletePipelineTags invocations corresponds +// MinimockGetDefinitionByUIDDone returns true if the count of the GetDefinitionByUID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockDeletePipelineTagsDone() bool { - if m.DeletePipelineTagsMock.optional { +func (m *RepositoryMock) MinimockGetDefinitionByUIDDone() bool { + if m.GetDefinitionByUIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.DeletePipelineTagsMock.expectations { + for _, e := range m.GetDefinitionByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.DeletePipelineTagsMock.invocationsDone() + return m.GetDefinitionByUIDMock.invocationsDone() } -// MinimockDeletePipelineTagsInspect logs each unmet expectation -func (m *RepositoryMock) MinimockDeletePipelineTagsInspect() { - for _, e := range m.DeletePipelineTagsMock.expectations { +// MinimockGetDefinitionByUIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetDefinitionByUIDInspect() { + for _, e := range m.GetDefinitionByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterDeletePipelineTagsCounter := mm_atomic.LoadUint64(&m.afterDeletePipelineTagsCounter) + afterGetDefinitionByUIDCounter := mm_atomic.LoadUint64(&m.afterGetDefinitionByUIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.DeletePipelineTagsMock.defaultExpectation != nil && afterDeletePipelineTagsCounter < 1 { - if m.DeletePipelineTagsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s", m.DeletePipelineTagsMock.defaultExpectation.returnOrigin) + if m.GetDefinitionByUIDMock.defaultExpectation != nil && afterGetDefinitionByUIDCounter < 1 { + if m.GetDefinitionByUIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s", m.GetDefinitionByUIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s with params: %#v", m.DeletePipelineTagsMock.defaultExpectation.expectationOrigins.origin, *m.DeletePipelineTagsMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s with params: %#v", m.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetDefinitionByUIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcDeletePipelineTags != nil && afterDeletePipelineTagsCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.DeletePipelineTags at\n%s", m.funcDeletePipelineTagsOrigin) + if m.funcGetDefinitionByUID != nil && afterGetDefinitionByUIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s", m.funcGetDefinitionByUIDOrigin) } - if !m.DeletePipelineTagsMock.invocationsDone() && afterDeletePipelineTagsCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.DeletePipelineTags at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.DeletePipelineTagsMock.expectedInvocations), m.DeletePipelineTagsMock.expectedInvocationsOrigin, afterDeletePipelineTagsCounter) + if !m.GetDefinitionByUIDMock.invocationsDone() && afterGetDefinitionByUIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetDefinitionByUID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetDefinitionByUIDMock.expectedInvocations), m.GetDefinitionByUIDMock.expectedInvocationsOrigin, afterGetDefinitionByUIDCounter) } } -type mRepositoryMockGetConnectionByUID struct { +type mRepositoryMockGetHubStats struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetConnectionByUIDExpectation - expectations []*RepositoryMockGetConnectionByUIDExpectation + defaultExpectation *RepositoryMockGetHubStatsExpectation + expectations []*RepositoryMockGetHubStatsExpectation - callArgs []*RepositoryMockGetConnectionByUIDParams + callArgs []*RepositoryMockGetHubStatsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetConnectionByUIDExpectation specifies expectation struct of the Repository.GetConnectionByUID -type RepositoryMockGetConnectionByUIDExpectation struct { +// RepositoryMockGetHubStatsExpectation specifies expectation struct of the Repository.GetHubStats +type RepositoryMockGetHubStatsExpectation struct { mock *RepositoryMock - params *RepositoryMockGetConnectionByUIDParams - paramPtrs *RepositoryMockGetConnectionByUIDParamPtrs - expectationOrigins RepositoryMockGetConnectionByUIDExpectationOrigins - results *RepositoryMockGetConnectionByUIDResults + params *RepositoryMockGetHubStatsParams + paramPtrs *RepositoryMockGetHubStatsParamPtrs + expectationOrigins RepositoryMockGetHubStatsExpectationOrigins + results *RepositoryMockGetHubStatsResults returnOrigin string Counter uint64 } -// RepositoryMockGetConnectionByUIDParams contains parameters of the Repository.GetConnectionByUID -type RepositoryMockGetConnectionByUIDParams struct { - ctx context.Context - u1 uuid.UUID +// RepositoryMockGetHubStatsParams contains parameters of the Repository.GetHubStats +type RepositoryMockGetHubStatsParams struct { + uidAllowList []uuid.UUID } -// RepositoryMockGetConnectionByUIDParamPtrs contains pointers to parameters of the Repository.GetConnectionByUID -type RepositoryMockGetConnectionByUIDParamPtrs struct { - ctx *context.Context - u1 *uuid.UUID +// RepositoryMockGetHubStatsParamPtrs contains pointers to parameters of the Repository.GetHubStats +type RepositoryMockGetHubStatsParamPtrs struct { + uidAllowList *[]uuid.UUID } -// RepositoryMockGetConnectionByUIDResults contains results of the Repository.GetConnectionByUID -type RepositoryMockGetConnectionByUIDResults struct { - cp1 *datamodel.Connection +// RepositoryMockGetHubStatsResults contains results of the Repository.GetHubStats +type RepositoryMockGetHubStatsResults struct { + hp1 *datamodel.HubStats err error } -// RepositoryMockGetConnectionByUIDOrigins contains origins of expectations of the Repository.GetConnectionByUID -type RepositoryMockGetConnectionByUIDExpectationOrigins struct { - origin string - originCtx string - originU1 string +// RepositoryMockGetHubStatsOrigins contains origins of expectations of the Repository.GetHubStats +type RepositoryMockGetHubStatsExpectationOrigins struct { + origin string + originUidAllowList string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -6115,342 +6114,320 @@ type RepositoryMockGetConnectionByUIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Optional() *mRepositoryMockGetConnectionByUID { - mmGetConnectionByUID.optional = true - return mmGetConnectionByUID +func (mmGetHubStats *mRepositoryMockGetHubStats) Optional() *mRepositoryMockGetHubStats { + mmGetHubStats.optional = true + return mmGetHubStats } -// Expect sets up expected params for Repository.GetConnectionByUID -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Expect(ctx context.Context, u1 uuid.UUID) *mRepositoryMockGetConnectionByUID { - if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") +// Expect sets up expected params for Repository.GetHubStats +func (mmGetHubStats *mRepositoryMockGetHubStats) Expect(uidAllowList []uuid.UUID) *mRepositoryMockGetHubStats { + if mmGetHubStats.mock.funcGetHubStats != nil { + mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") } - if mmGetConnectionByUID.defaultExpectation == nil { - mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{} + if mmGetHubStats.defaultExpectation == nil { + mmGetHubStats.defaultExpectation = &RepositoryMockGetHubStatsExpectation{} } - if mmGetConnectionByUID.defaultExpectation.paramPtrs != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by ExpectParams functions") + if mmGetHubStats.defaultExpectation.paramPtrs != nil { + mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by ExpectParams functions") } - mmGetConnectionByUID.defaultExpectation.params = &RepositoryMockGetConnectionByUIDParams{ctx, u1} - mmGetConnectionByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetConnectionByUID.expectations { - if minimock.Equal(e.params, mmGetConnectionByUID.defaultExpectation.params) { - mmGetConnectionByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetConnectionByUID.defaultExpectation.params) + mmGetHubStats.defaultExpectation.params = &RepositoryMockGetHubStatsParams{uidAllowList} + mmGetHubStats.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetHubStats.expectations { + if minimock.Equal(e.params, mmGetHubStats.defaultExpectation.params) { + mmGetHubStats.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetHubStats.defaultExpectation.params) } } - return mmGetConnectionByUID + return mmGetHubStats } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetConnectionByUID -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetConnectionByUID { - if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") +// ExpectUidAllowListParam1 sets up expected param uidAllowList for Repository.GetHubStats +func (mmGetHubStats *mRepositoryMockGetHubStats) ExpectUidAllowListParam1(uidAllowList []uuid.UUID) *mRepositoryMockGetHubStats { + if mmGetHubStats.mock.funcGetHubStats != nil { + mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") } - if mmGetConnectionByUID.defaultExpectation == nil { - mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{} + if mmGetHubStats.defaultExpectation == nil { + mmGetHubStats.defaultExpectation = &RepositoryMockGetHubStatsExpectation{} } - if mmGetConnectionByUID.defaultExpectation.params != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Expect") + if mmGetHubStats.defaultExpectation.params != nil { + mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Expect") } - if mmGetConnectionByUID.defaultExpectation.paramPtrs == nil { - mmGetConnectionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetConnectionByUIDParamPtrs{} + if mmGetHubStats.defaultExpectation.paramPtrs == nil { + mmGetHubStats.defaultExpectation.paramPtrs = &RepositoryMockGetHubStatsParamPtrs{} } - mmGetConnectionByUID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetConnectionByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetHubStats.defaultExpectation.paramPtrs.uidAllowList = &uidAllowList + mmGetHubStats.defaultExpectation.expectationOrigins.originUidAllowList = minimock.CallerInfo(1) - return mmGetConnectionByUID + return mmGetHubStats } -// ExpectU1Param2 sets up expected param u1 for Repository.GetConnectionByUID -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) ExpectU1Param2(u1 uuid.UUID) *mRepositoryMockGetConnectionByUID { - if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.GetHubStats +func (mmGetHubStats *mRepositoryMockGetHubStats) Inspect(f func(uidAllowList []uuid.UUID)) *mRepositoryMockGetHubStats { + if mmGetHubStats.mock.inspectFuncGetHubStats != nil { + mmGetHubStats.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetHubStats") } - if mmGetConnectionByUID.defaultExpectation == nil { - mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{} - } + mmGetHubStats.mock.inspectFuncGetHubStats = f - if mmGetConnectionByUID.defaultExpectation.params != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Expect") - } + return mmGetHubStats +} - if mmGetConnectionByUID.defaultExpectation.paramPtrs == nil { - mmGetConnectionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetConnectionByUIDParamPtrs{} +// Return sets up results that will be returned by Repository.GetHubStats +func (mmGetHubStats *mRepositoryMockGetHubStats) Return(hp1 *datamodel.HubStats, err error) *RepositoryMock { + if mmGetHubStats.mock.funcGetHubStats != nil { + mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") } - mmGetConnectionByUID.defaultExpectation.paramPtrs.u1 = &u1 - mmGetConnectionByUID.defaultExpectation.expectationOrigins.originU1 = minimock.CallerInfo(1) - return mmGetConnectionByUID + if mmGetHubStats.defaultExpectation == nil { + mmGetHubStats.defaultExpectation = &RepositoryMockGetHubStatsExpectation{mock: mmGetHubStats.mock} + } + mmGetHubStats.defaultExpectation.results = &RepositoryMockGetHubStatsResults{hp1, err} + mmGetHubStats.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetHubStats.mock } -// Inspect accepts an inspector function that has same arguments as the Repository.GetConnectionByUID -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Inspect(f func(ctx context.Context, u1 uuid.UUID)) *mRepositoryMockGetConnectionByUID { - if mmGetConnectionByUID.mock.inspectFuncGetConnectionByUID != nil { - mmGetConnectionByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetConnectionByUID") - } - - mmGetConnectionByUID.mock.inspectFuncGetConnectionByUID = f - - return mmGetConnectionByUID -} - -// Return sets up results that will be returned by Repository.GetConnectionByUID -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Return(cp1 *datamodel.Connection, err error) *RepositoryMock { - if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") - } - - if mmGetConnectionByUID.defaultExpectation == nil { - mmGetConnectionByUID.defaultExpectation = &RepositoryMockGetConnectionByUIDExpectation{mock: mmGetConnectionByUID.mock} - } - mmGetConnectionByUID.defaultExpectation.results = &RepositoryMockGetConnectionByUIDResults{cp1, err} - mmGetConnectionByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetConnectionByUID.mock -} - -// Set uses given function f to mock the Repository.GetConnectionByUID method -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Set(f func(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.Connection, err error)) *RepositoryMock { - if mmGetConnectionByUID.defaultExpectation != nil { - mmGetConnectionByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetConnectionByUID method") +// Set uses given function f to mock the Repository.GetHubStats method +func (mmGetHubStats *mRepositoryMockGetHubStats) Set(f func(uidAllowList []uuid.UUID) (hp1 *datamodel.HubStats, err error)) *RepositoryMock { + if mmGetHubStats.defaultExpectation != nil { + mmGetHubStats.mock.t.Fatalf("Default expectation is already set for the Repository.GetHubStats method") } - if len(mmGetConnectionByUID.expectations) > 0 { - mmGetConnectionByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetConnectionByUID method") + if len(mmGetHubStats.expectations) > 0 { + mmGetHubStats.mock.t.Fatalf("Some expectations are already set for the Repository.GetHubStats method") } - mmGetConnectionByUID.mock.funcGetConnectionByUID = f - mmGetConnectionByUID.mock.funcGetConnectionByUIDOrigin = minimock.CallerInfo(1) - return mmGetConnectionByUID.mock + mmGetHubStats.mock.funcGetHubStats = f + mmGetHubStats.mock.funcGetHubStatsOrigin = minimock.CallerInfo(1) + return mmGetHubStats.mock } -// When sets expectation for the Repository.GetConnectionByUID which will trigger the result defined by the following +// When sets expectation for the Repository.GetHubStats which will trigger the result defined by the following // Then helper -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) When(ctx context.Context, u1 uuid.UUID) *RepositoryMockGetConnectionByUIDExpectation { - if mmGetConnectionByUID.mock.funcGetConnectionByUID != nil { - mmGetConnectionByUID.mock.t.Fatalf("RepositoryMock.GetConnectionByUID mock is already set by Set") +func (mmGetHubStats *mRepositoryMockGetHubStats) When(uidAllowList []uuid.UUID) *RepositoryMockGetHubStatsExpectation { + if mmGetHubStats.mock.funcGetHubStats != nil { + mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") } - expectation := &RepositoryMockGetConnectionByUIDExpectation{ - mock: mmGetConnectionByUID.mock, - params: &RepositoryMockGetConnectionByUIDParams{ctx, u1}, - expectationOrigins: RepositoryMockGetConnectionByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetHubStatsExpectation{ + mock: mmGetHubStats.mock, + params: &RepositoryMockGetHubStatsParams{uidAllowList}, + expectationOrigins: RepositoryMockGetHubStatsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetConnectionByUID.expectations = append(mmGetConnectionByUID.expectations, expectation) + mmGetHubStats.expectations = append(mmGetHubStats.expectations, expectation) return expectation } -// Then sets up Repository.GetConnectionByUID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetConnectionByUIDExpectation) Then(cp1 *datamodel.Connection, err error) *RepositoryMock { - e.results = &RepositoryMockGetConnectionByUIDResults{cp1, err} +// Then sets up Repository.GetHubStats return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetHubStatsExpectation) Then(hp1 *datamodel.HubStats, err error) *RepositoryMock { + e.results = &RepositoryMockGetHubStatsResults{hp1, err} return e.mock } -// Times sets number of times Repository.GetConnectionByUID should be invoked -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Times(n uint64) *mRepositoryMockGetConnectionByUID { +// Times sets number of times Repository.GetHubStats should be invoked +func (mmGetHubStats *mRepositoryMockGetHubStats) Times(n uint64) *mRepositoryMockGetHubStats { if n == 0 { - mmGetConnectionByUID.mock.t.Fatalf("Times of RepositoryMock.GetConnectionByUID mock can not be zero") + mmGetHubStats.mock.t.Fatalf("Times of RepositoryMock.GetHubStats mock can not be zero") } - mm_atomic.StoreUint64(&mmGetConnectionByUID.expectedInvocations, n) - mmGetConnectionByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetConnectionByUID + mm_atomic.StoreUint64(&mmGetHubStats.expectedInvocations, n) + mmGetHubStats.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetHubStats } -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) invocationsDone() bool { - if len(mmGetConnectionByUID.expectations) == 0 && mmGetConnectionByUID.defaultExpectation == nil && mmGetConnectionByUID.mock.funcGetConnectionByUID == nil { +func (mmGetHubStats *mRepositoryMockGetHubStats) invocationsDone() bool { + if len(mmGetHubStats.expectations) == 0 && mmGetHubStats.defaultExpectation == nil && mmGetHubStats.mock.funcGetHubStats == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetConnectionByUID.mock.afterGetConnectionByUIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetConnectionByUID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetHubStats.mock.afterGetHubStatsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetHubStats.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetConnectionByUID implements mm_repository.Repository -func (mmGetConnectionByUID *RepositoryMock) GetConnectionByUID(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.Connection, err error) { - mm_atomic.AddUint64(&mmGetConnectionByUID.beforeGetConnectionByUIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetConnectionByUID.afterGetConnectionByUIDCounter, 1) +// GetHubStats implements mm_repository.Repository +func (mmGetHubStats *RepositoryMock) GetHubStats(uidAllowList []uuid.UUID) (hp1 *datamodel.HubStats, err error) { + mm_atomic.AddUint64(&mmGetHubStats.beforeGetHubStatsCounter, 1) + defer mm_atomic.AddUint64(&mmGetHubStats.afterGetHubStatsCounter, 1) - mmGetConnectionByUID.t.Helper() + mmGetHubStats.t.Helper() - if mmGetConnectionByUID.inspectFuncGetConnectionByUID != nil { - mmGetConnectionByUID.inspectFuncGetConnectionByUID(ctx, u1) + if mmGetHubStats.inspectFuncGetHubStats != nil { + mmGetHubStats.inspectFuncGetHubStats(uidAllowList) } - mm_params := RepositoryMockGetConnectionByUIDParams{ctx, u1} + mm_params := RepositoryMockGetHubStatsParams{uidAllowList} // Record call args - mmGetConnectionByUID.GetConnectionByUIDMock.mutex.Lock() - mmGetConnectionByUID.GetConnectionByUIDMock.callArgs = append(mmGetConnectionByUID.GetConnectionByUIDMock.callArgs, &mm_params) - mmGetConnectionByUID.GetConnectionByUIDMock.mutex.Unlock() + mmGetHubStats.GetHubStatsMock.mutex.Lock() + mmGetHubStats.GetHubStatsMock.callArgs = append(mmGetHubStats.GetHubStatsMock.callArgs, &mm_params) + mmGetHubStats.GetHubStatsMock.mutex.Unlock() - for _, e := range mmGetConnectionByUID.GetConnectionByUIDMock.expectations { + for _, e := range mmGetHubStats.GetHubStatsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.cp1, e.results.err + return e.results.hp1, e.results.err } } - if mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.params - mm_want_ptrs := mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.paramPtrs + if mmGetHubStats.GetHubStatsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetHubStats.GetHubStatsMock.defaultExpectation.Counter, 1) + mm_want := mmGetHubStats.GetHubStatsMock.defaultExpectation.params + mm_want_ptrs := mmGetHubStats.GetHubStatsMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetConnectionByUIDParams{ctx, u1} + mm_got := RepositoryMockGetHubStatsParams{uidAllowList} if mm_want_ptrs != nil { - if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetConnectionByUID.t.Errorf("RepositoryMock.GetConnectionByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.u1 != nil && !minimock.Equal(*mm_want_ptrs.u1, mm_got.u1) { - mmGetConnectionByUID.t.Errorf("RepositoryMock.GetConnectionByUID got unexpected parameter u1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.originU1, *mm_want_ptrs.u1, mm_got.u1, minimock.Diff(*mm_want_ptrs.u1, mm_got.u1)) + if mm_want_ptrs.uidAllowList != nil && !minimock.Equal(*mm_want_ptrs.uidAllowList, mm_got.uidAllowList) { + mmGetHubStats.t.Errorf("RepositoryMock.GetHubStats got unexpected parameter uidAllowList, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetHubStats.GetHubStatsMock.defaultExpectation.expectationOrigins.originUidAllowList, *mm_want_ptrs.uidAllowList, mm_got.uidAllowList, minimock.Diff(*mm_want_ptrs.uidAllowList, mm_got.uidAllowList)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetConnectionByUID.t.Errorf("RepositoryMock.GetConnectionByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetHubStats.t.Errorf("RepositoryMock.GetHubStats got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetHubStats.GetHubStatsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetConnectionByUID.GetConnectionByUIDMock.defaultExpectation.results + mm_results := mmGetHubStats.GetHubStatsMock.defaultExpectation.results if mm_results == nil { - mmGetConnectionByUID.t.Fatal("No results are set for the RepositoryMock.GetConnectionByUID") + mmGetHubStats.t.Fatal("No results are set for the RepositoryMock.GetHubStats") } - return (*mm_results).cp1, (*mm_results).err + return (*mm_results).hp1, (*mm_results).err } - if mmGetConnectionByUID.funcGetConnectionByUID != nil { - return mmGetConnectionByUID.funcGetConnectionByUID(ctx, u1) + if mmGetHubStats.funcGetHubStats != nil { + return mmGetHubStats.funcGetHubStats(uidAllowList) } - mmGetConnectionByUID.t.Fatalf("Unexpected call to RepositoryMock.GetConnectionByUID. %v %v", ctx, u1) + mmGetHubStats.t.Fatalf("Unexpected call to RepositoryMock.GetHubStats. %v", uidAllowList) return } -// GetConnectionByUIDAfterCounter returns a count of finished RepositoryMock.GetConnectionByUID invocations -func (mmGetConnectionByUID *RepositoryMock) GetConnectionByUIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetConnectionByUID.afterGetConnectionByUIDCounter) +// GetHubStatsAfterCounter returns a count of finished RepositoryMock.GetHubStats invocations +func (mmGetHubStats *RepositoryMock) GetHubStatsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetHubStats.afterGetHubStatsCounter) } -// GetConnectionByUIDBeforeCounter returns a count of RepositoryMock.GetConnectionByUID invocations -func (mmGetConnectionByUID *RepositoryMock) GetConnectionByUIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetConnectionByUID.beforeGetConnectionByUIDCounter) +// GetHubStatsBeforeCounter returns a count of RepositoryMock.GetHubStats invocations +func (mmGetHubStats *RepositoryMock) GetHubStatsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetHubStats.beforeGetHubStatsCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetConnectionByUID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetHubStats. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetConnectionByUID *mRepositoryMockGetConnectionByUID) Calls() []*RepositoryMockGetConnectionByUIDParams { - mmGetConnectionByUID.mutex.RLock() +func (mmGetHubStats *mRepositoryMockGetHubStats) Calls() []*RepositoryMockGetHubStatsParams { + mmGetHubStats.mutex.RLock() - argCopy := make([]*RepositoryMockGetConnectionByUIDParams, len(mmGetConnectionByUID.callArgs)) - copy(argCopy, mmGetConnectionByUID.callArgs) + argCopy := make([]*RepositoryMockGetHubStatsParams, len(mmGetHubStats.callArgs)) + copy(argCopy, mmGetHubStats.callArgs) - mmGetConnectionByUID.mutex.RUnlock() + mmGetHubStats.mutex.RUnlock() return argCopy } -// MinimockGetConnectionByUIDDone returns true if the count of the GetConnectionByUID invocations corresponds +// MinimockGetHubStatsDone returns true if the count of the GetHubStats invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetConnectionByUIDDone() bool { - if m.GetConnectionByUIDMock.optional { +func (m *RepositoryMock) MinimockGetHubStatsDone() bool { + if m.GetHubStatsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetConnectionByUIDMock.expectations { + for _, e := range m.GetHubStatsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetConnectionByUIDMock.invocationsDone() + return m.GetHubStatsMock.invocationsDone() } -// MinimockGetConnectionByUIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetConnectionByUIDInspect() { - for _, e := range m.GetConnectionByUIDMock.expectations { +// MinimockGetHubStatsInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetHubStatsInspect() { + for _, e := range m.GetHubStatsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetConnectionByUIDCounter := mm_atomic.LoadUint64(&m.afterGetConnectionByUIDCounter) + afterGetHubStatsCounter := mm_atomic.LoadUint64(&m.afterGetHubStatsCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetConnectionByUIDMock.defaultExpectation != nil && afterGetConnectionByUIDCounter < 1 { - if m.GetConnectionByUIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s", m.GetConnectionByUIDMock.defaultExpectation.returnOrigin) + if m.GetHubStatsMock.defaultExpectation != nil && afterGetHubStatsCounter < 1 { + if m.GetHubStatsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s", m.GetHubStatsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s with params: %#v", m.GetConnectionByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetConnectionByUIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s with params: %#v", m.GetHubStatsMock.defaultExpectation.expectationOrigins.origin, *m.GetHubStatsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetConnectionByUID != nil && afterGetConnectionByUIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetConnectionByUID at\n%s", m.funcGetConnectionByUIDOrigin) + if m.funcGetHubStats != nil && afterGetHubStatsCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s", m.funcGetHubStatsOrigin) } - if !m.GetConnectionByUIDMock.invocationsDone() && afterGetConnectionByUIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetConnectionByUID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetConnectionByUIDMock.expectedInvocations), m.GetConnectionByUIDMock.expectedInvocationsOrigin, afterGetConnectionByUIDCounter) + if !m.GetHubStatsMock.invocationsDone() && afterGetHubStatsCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetHubStats at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetHubStatsMock.expectedInvocations), m.GetHubStatsMock.expectedInvocationsOrigin, afterGetHubStatsCounter) } } -type mRepositoryMockGetDefinitionByUID struct { +type mRepositoryMockGetLatestNamespacePipelineRelease struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetDefinitionByUIDExpectation - expectations []*RepositoryMockGetDefinitionByUIDExpectation + defaultExpectation *RepositoryMockGetLatestNamespacePipelineReleaseExpectation + expectations []*RepositoryMockGetLatestNamespacePipelineReleaseExpectation - callArgs []*RepositoryMockGetDefinitionByUIDParams + callArgs []*RepositoryMockGetLatestNamespacePipelineReleaseParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetDefinitionByUIDExpectation specifies expectation struct of the Repository.GetDefinitionByUID -type RepositoryMockGetDefinitionByUIDExpectation struct { +// RepositoryMockGetLatestNamespacePipelineReleaseExpectation specifies expectation struct of the Repository.GetLatestNamespacePipelineRelease +type RepositoryMockGetLatestNamespacePipelineReleaseExpectation struct { mock *RepositoryMock - params *RepositoryMockGetDefinitionByUIDParams - paramPtrs *RepositoryMockGetDefinitionByUIDParamPtrs - expectationOrigins RepositoryMockGetDefinitionByUIDExpectationOrigins - results *RepositoryMockGetDefinitionByUIDResults + params *RepositoryMockGetLatestNamespacePipelineReleaseParams + paramPtrs *RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs + expectationOrigins RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins + results *RepositoryMockGetLatestNamespacePipelineReleaseResults returnOrigin string Counter uint64 } -// RepositoryMockGetDefinitionByUIDParams contains parameters of the Repository.GetDefinitionByUID -type RepositoryMockGetDefinitionByUIDParams struct { - ctx context.Context - u1 uuid.UUID +// RepositoryMockGetLatestNamespacePipelineReleaseParams contains parameters of the Repository.GetLatestNamespacePipelineRelease +type RepositoryMockGetLatestNamespacePipelineReleaseParams struct { + ctx context.Context + ownerPermalink string + pipelineUID uuid.UUID + isBasicView bool } -// RepositoryMockGetDefinitionByUIDParamPtrs contains pointers to parameters of the Repository.GetDefinitionByUID -type RepositoryMockGetDefinitionByUIDParamPtrs struct { - ctx *context.Context - u1 *uuid.UUID +// RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs contains pointers to parameters of the Repository.GetLatestNamespacePipelineRelease +type RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs struct { + ctx *context.Context + ownerPermalink *string + pipelineUID *uuid.UUID + isBasicView *bool } -// RepositoryMockGetDefinitionByUIDResults contains results of the Repository.GetDefinitionByUID -type RepositoryMockGetDefinitionByUIDResults struct { - cp1 *datamodel.ComponentDefinition +// RepositoryMockGetLatestNamespacePipelineReleaseResults contains results of the Repository.GetLatestNamespacePipelineRelease +type RepositoryMockGetLatestNamespacePipelineReleaseResults struct { + pp1 *datamodel.PipelineRelease err error } -// RepositoryMockGetDefinitionByUIDOrigins contains origins of expectations of the Repository.GetDefinitionByUID -type RepositoryMockGetDefinitionByUIDExpectationOrigins struct { - origin string - originCtx string - originU1 string +// RepositoryMockGetLatestNamespacePipelineReleaseOrigins contains origins of expectations of the Repository.GetLatestNamespacePipelineRelease +type RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins struct { + origin string + originCtx string + originOwnerPermalink string + originPipelineUID string + originIsBasicView string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -6458,339 +6435,401 @@ type RepositoryMockGetDefinitionByUIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Optional() *mRepositoryMockGetDefinitionByUID { - mmGetDefinitionByUID.optional = true - return mmGetDefinitionByUID +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Optional() *mRepositoryMockGetLatestNamespacePipelineRelease { + mmGetLatestNamespacePipelineRelease.optional = true + return mmGetLatestNamespacePipelineRelease } -// Expect sets up expected params for Repository.GetDefinitionByUID -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Expect(ctx context.Context, u1 uuid.UUID) *mRepositoryMockGetDefinitionByUID { - if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") +// Expect sets up expected params for Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) *mRepositoryMockGetLatestNamespacePipelineRelease { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - if mmGetDefinitionByUID.defaultExpectation == nil { - mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{} + if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} } - if mmGetDefinitionByUID.defaultExpectation.paramPtrs != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by ExpectParams functions") + if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by ExpectParams functions") } - mmGetDefinitionByUID.defaultExpectation.params = &RepositoryMockGetDefinitionByUIDParams{ctx, u1} - mmGetDefinitionByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetDefinitionByUID.expectations { - if minimock.Equal(e.params, mmGetDefinitionByUID.defaultExpectation.params) { - mmGetDefinitionByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetDefinitionByUID.defaultExpectation.params) + mmGetLatestNamespacePipelineRelease.defaultExpectation.params = &RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView} + mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetLatestNamespacePipelineRelease.expectations { + if minimock.Equal(e.params, mmGetLatestNamespacePipelineRelease.defaultExpectation.params) { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetLatestNamespacePipelineRelease.defaultExpectation.params) } } - return mmGetDefinitionByUID + return mmGetLatestNamespacePipelineRelease } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetDefinitionByUID -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetDefinitionByUID { - if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetLatestNamespacePipelineRelease { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - if mmGetDefinitionByUID.defaultExpectation == nil { - mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{} + if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} } - if mmGetDefinitionByUID.defaultExpectation.params != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Expect") + if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") } - if mmGetDefinitionByUID.defaultExpectation.paramPtrs == nil { - mmGetDefinitionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetDefinitionByUIDParamPtrs{} + if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} } - mmGetDefinitionByUID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetDefinitionByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.ctx = &ctx + mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetDefinitionByUID + return mmGetLatestNamespacePipelineRelease } -// ExpectU1Param2 sets up expected param u1 for Repository.GetDefinitionByUID -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) ExpectU1Param2(u1 uuid.UUID) *mRepositoryMockGetDefinitionByUID { - if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetLatestNamespacePipelineRelease { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - if mmGetDefinitionByUID.defaultExpectation == nil { - mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{} + if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} } - if mmGetDefinitionByUID.defaultExpectation.params != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Expect") + if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") } - if mmGetDefinitionByUID.defaultExpectation.paramPtrs == nil { - mmGetDefinitionByUID.defaultExpectation.paramPtrs = &RepositoryMockGetDefinitionByUIDParamPtrs{} + if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} } - mmGetDefinitionByUID.defaultExpectation.paramPtrs.u1 = &u1 - mmGetDefinitionByUID.defaultExpectation.expectationOrigins.originU1 = minimock.CallerInfo(1) + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmGetDefinitionByUID + return mmGetLatestNamespacePipelineRelease } -// Inspect accepts an inspector function that has same arguments as the Repository.GetDefinitionByUID -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Inspect(f func(ctx context.Context, u1 uuid.UUID)) *mRepositoryMockGetDefinitionByUID { - if mmGetDefinitionByUID.mock.inspectFuncGetDefinitionByUID != nil { - mmGetDefinitionByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetDefinitionByUID") +// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockGetLatestNamespacePipelineRelease { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - mmGetDefinitionByUID.mock.inspectFuncGetDefinitionByUID = f + if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} + } - return mmGetDefinitionByUID + if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") + } + + if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} + } + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) + + return mmGetLatestNamespacePipelineRelease } -// Return sets up results that will be returned by Repository.GetDefinitionByUID -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Return(cp1 *datamodel.ComponentDefinition, err error) *RepositoryMock { - if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") +// ExpectIsBasicViewParam4 sets up expected param isBasicView for Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectIsBasicViewParam4(isBasicView bool) *mRepositoryMockGetLatestNamespacePipelineRelease { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - if mmGetDefinitionByUID.defaultExpectation == nil { - mmGetDefinitionByUID.defaultExpectation = &RepositoryMockGetDefinitionByUIDExpectation{mock: mmGetDefinitionByUID.mock} + if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} } - mmGetDefinitionByUID.defaultExpectation.results = &RepositoryMockGetDefinitionByUIDResults{cp1, err} - mmGetDefinitionByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetDefinitionByUID.mock + + if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") + } + + if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} + } + mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.isBasicView = &isBasicView + mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + + return mmGetLatestNamespacePipelineRelease } -// Set uses given function f to mock the Repository.GetDefinitionByUID method -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Set(f func(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.ComponentDefinition, err error)) *RepositoryMock { - if mmGetDefinitionByUID.defaultExpectation != nil { - mmGetDefinitionByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetDefinitionByUID method") +// Inspect accepts an inspector function that has same arguments as the Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool)) *mRepositoryMockGetLatestNamespacePipelineRelease { + if mmGetLatestNamespacePipelineRelease.mock.inspectFuncGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetLatestNamespacePipelineRelease") } - if len(mmGetDefinitionByUID.expectations) > 0 { - mmGetDefinitionByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetDefinitionByUID method") + mmGetLatestNamespacePipelineRelease.mock.inspectFuncGetLatestNamespacePipelineRelease = f + + return mmGetLatestNamespacePipelineRelease +} + +// Return sets up results that will be returned by Repository.GetLatestNamespacePipelineRelease +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Return(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - mmGetDefinitionByUID.mock.funcGetDefinitionByUID = f - mmGetDefinitionByUID.mock.funcGetDefinitionByUIDOrigin = minimock.CallerInfo(1) - return mmGetDefinitionByUID.mock + if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { + mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{mock: mmGetLatestNamespacePipelineRelease.mock} + } + mmGetLatestNamespacePipelineRelease.defaultExpectation.results = &RepositoryMockGetLatestNamespacePipelineReleaseResults{pp1, err} + mmGetLatestNamespacePipelineRelease.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetLatestNamespacePipelineRelease.mock } -// When sets expectation for the Repository.GetDefinitionByUID which will trigger the result defined by the following +// Set uses given function f to mock the Repository.GetLatestNamespacePipelineRelease method +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error)) *RepositoryMock { + if mmGetLatestNamespacePipelineRelease.defaultExpectation != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Default expectation is already set for the Repository.GetLatestNamespacePipelineRelease method") + } + + if len(mmGetLatestNamespacePipelineRelease.expectations) > 0 { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Some expectations are already set for the Repository.GetLatestNamespacePipelineRelease method") + } + + mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease = f + mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineReleaseOrigin = minimock.CallerInfo(1) + return mmGetLatestNamespacePipelineRelease.mock +} + +// When sets expectation for the Repository.GetLatestNamespacePipelineRelease which will trigger the result defined by the following // Then helper -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) When(ctx context.Context, u1 uuid.UUID) *RepositoryMockGetDefinitionByUIDExpectation { - if mmGetDefinitionByUID.mock.funcGetDefinitionByUID != nil { - mmGetDefinitionByUID.mock.t.Fatalf("RepositoryMock.GetDefinitionByUID mock is already set by Set") +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) *RepositoryMockGetLatestNamespacePipelineReleaseExpectation { + if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") } - expectation := &RepositoryMockGetDefinitionByUIDExpectation{ - mock: mmGetDefinitionByUID.mock, - params: &RepositoryMockGetDefinitionByUIDParams{ctx, u1}, - expectationOrigins: RepositoryMockGetDefinitionByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{ + mock: mmGetLatestNamespacePipelineRelease.mock, + params: &RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView}, + expectationOrigins: RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetDefinitionByUID.expectations = append(mmGetDefinitionByUID.expectations, expectation) + mmGetLatestNamespacePipelineRelease.expectations = append(mmGetLatestNamespacePipelineRelease.expectations, expectation) return expectation } -// Then sets up Repository.GetDefinitionByUID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetDefinitionByUIDExpectation) Then(cp1 *datamodel.ComponentDefinition, err error) *RepositoryMock { - e.results = &RepositoryMockGetDefinitionByUIDResults{cp1, err} +// Then sets up Repository.GetLatestNamespacePipelineRelease return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetLatestNamespacePipelineReleaseExpectation) Then(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { + e.results = &RepositoryMockGetLatestNamespacePipelineReleaseResults{pp1, err} return e.mock } -// Times sets number of times Repository.GetDefinitionByUID should be invoked -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Times(n uint64) *mRepositoryMockGetDefinitionByUID { +// Times sets number of times Repository.GetLatestNamespacePipelineRelease should be invoked +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Times(n uint64) *mRepositoryMockGetLatestNamespacePipelineRelease { if n == 0 { - mmGetDefinitionByUID.mock.t.Fatalf("Times of RepositoryMock.GetDefinitionByUID mock can not be zero") + mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Times of RepositoryMock.GetLatestNamespacePipelineRelease mock can not be zero") } - mm_atomic.StoreUint64(&mmGetDefinitionByUID.expectedInvocations, n) - mmGetDefinitionByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetDefinitionByUID + mm_atomic.StoreUint64(&mmGetLatestNamespacePipelineRelease.expectedInvocations, n) + mmGetLatestNamespacePipelineRelease.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetLatestNamespacePipelineRelease } -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) invocationsDone() bool { - if len(mmGetDefinitionByUID.expectations) == 0 && mmGetDefinitionByUID.defaultExpectation == nil && mmGetDefinitionByUID.mock.funcGetDefinitionByUID == nil { +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) invocationsDone() bool { + if len(mmGetLatestNamespacePipelineRelease.expectations) == 0 && mmGetLatestNamespacePipelineRelease.defaultExpectation == nil && mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetDefinitionByUID.mock.afterGetDefinitionByUIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetDefinitionByUID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.mock.afterGetLatestNamespacePipelineReleaseCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetDefinitionByUID implements mm_repository.Repository -func (mmGetDefinitionByUID *RepositoryMock) GetDefinitionByUID(ctx context.Context, u1 uuid.UUID) (cp1 *datamodel.ComponentDefinition, err error) { - mm_atomic.AddUint64(&mmGetDefinitionByUID.beforeGetDefinitionByUIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetDefinitionByUID.afterGetDefinitionByUIDCounter, 1) +// GetLatestNamespacePipelineRelease implements mm_repository.Repository +func (mmGetLatestNamespacePipelineRelease *RepositoryMock) GetLatestNamespacePipelineRelease(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error) { + mm_atomic.AddUint64(&mmGetLatestNamespacePipelineRelease.beforeGetLatestNamespacePipelineReleaseCounter, 1) + defer mm_atomic.AddUint64(&mmGetLatestNamespacePipelineRelease.afterGetLatestNamespacePipelineReleaseCounter, 1) - mmGetDefinitionByUID.t.Helper() + mmGetLatestNamespacePipelineRelease.t.Helper() - if mmGetDefinitionByUID.inspectFuncGetDefinitionByUID != nil { - mmGetDefinitionByUID.inspectFuncGetDefinitionByUID(ctx, u1) + if mmGetLatestNamespacePipelineRelease.inspectFuncGetLatestNamespacePipelineRelease != nil { + mmGetLatestNamespacePipelineRelease.inspectFuncGetLatestNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, isBasicView) } - mm_params := RepositoryMockGetDefinitionByUIDParams{ctx, u1} + mm_params := RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView} // Record call args - mmGetDefinitionByUID.GetDefinitionByUIDMock.mutex.Lock() - mmGetDefinitionByUID.GetDefinitionByUIDMock.callArgs = append(mmGetDefinitionByUID.GetDefinitionByUIDMock.callArgs, &mm_params) - mmGetDefinitionByUID.GetDefinitionByUIDMock.mutex.Unlock() - - for _, e := range mmGetDefinitionByUID.GetDefinitionByUIDMock.expectations { + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.mutex.Lock() + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.callArgs = append(mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.callArgs, &mm_params) + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.mutex.Unlock() + + for _, e := range mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.cp1, e.results.err + return e.results.pp1, e.results.err } } - if mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.params - mm_want_ptrs := mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.paramPtrs + if mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.Counter, 1) + mm_want := mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.params + mm_want_ptrs := mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetDefinitionByUIDParams{ctx, u1} + mm_got := RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetDefinitionByUID.t.Errorf("RepositoryMock.GetDefinitionByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.u1 != nil && !minimock.Equal(*mm_want_ptrs.u1, mm_got.u1) { - mmGetDefinitionByUID.t.Errorf("RepositoryMock.GetDefinitionByUID got unexpected parameter u1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.originU1, *mm_want_ptrs.u1, mm_got.u1, minimock.Diff(*mm_want_ptrs.u1, mm_got.u1)) + if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { + mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + } + + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + } + + if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { + mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetDefinitionByUID.t.Errorf("RepositoryMock.GetDefinitionByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetDefinitionByUID.GetDefinitionByUIDMock.defaultExpectation.results + mm_results := mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.results if mm_results == nil { - mmGetDefinitionByUID.t.Fatal("No results are set for the RepositoryMock.GetDefinitionByUID") + mmGetLatestNamespacePipelineRelease.t.Fatal("No results are set for the RepositoryMock.GetLatestNamespacePipelineRelease") } - return (*mm_results).cp1, (*mm_results).err + return (*mm_results).pp1, (*mm_results).err } - if mmGetDefinitionByUID.funcGetDefinitionByUID != nil { - return mmGetDefinitionByUID.funcGetDefinitionByUID(ctx, u1) + if mmGetLatestNamespacePipelineRelease.funcGetLatestNamespacePipelineRelease != nil { + return mmGetLatestNamespacePipelineRelease.funcGetLatestNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, isBasicView) } - mmGetDefinitionByUID.t.Fatalf("Unexpected call to RepositoryMock.GetDefinitionByUID. %v %v", ctx, u1) + mmGetLatestNamespacePipelineRelease.t.Fatalf("Unexpected call to RepositoryMock.GetLatestNamespacePipelineRelease. %v %v %v %v", ctx, ownerPermalink, pipelineUID, isBasicView) return } -// GetDefinitionByUIDAfterCounter returns a count of finished RepositoryMock.GetDefinitionByUID invocations -func (mmGetDefinitionByUID *RepositoryMock) GetDefinitionByUIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetDefinitionByUID.afterGetDefinitionByUIDCounter) +// GetLatestNamespacePipelineReleaseAfterCounter returns a count of finished RepositoryMock.GetLatestNamespacePipelineRelease invocations +func (mmGetLatestNamespacePipelineRelease *RepositoryMock) GetLatestNamespacePipelineReleaseAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.afterGetLatestNamespacePipelineReleaseCounter) } -// GetDefinitionByUIDBeforeCounter returns a count of RepositoryMock.GetDefinitionByUID invocations -func (mmGetDefinitionByUID *RepositoryMock) GetDefinitionByUIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetDefinitionByUID.beforeGetDefinitionByUIDCounter) +// GetLatestNamespacePipelineReleaseBeforeCounter returns a count of RepositoryMock.GetLatestNamespacePipelineRelease invocations +func (mmGetLatestNamespacePipelineRelease *RepositoryMock) GetLatestNamespacePipelineReleaseBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.beforeGetLatestNamespacePipelineReleaseCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetDefinitionByUID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetLatestNamespacePipelineRelease. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetDefinitionByUID *mRepositoryMockGetDefinitionByUID) Calls() []*RepositoryMockGetDefinitionByUIDParams { - mmGetDefinitionByUID.mutex.RLock() +func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Calls() []*RepositoryMockGetLatestNamespacePipelineReleaseParams { + mmGetLatestNamespacePipelineRelease.mutex.RLock() - argCopy := make([]*RepositoryMockGetDefinitionByUIDParams, len(mmGetDefinitionByUID.callArgs)) - copy(argCopy, mmGetDefinitionByUID.callArgs) + argCopy := make([]*RepositoryMockGetLatestNamespacePipelineReleaseParams, len(mmGetLatestNamespacePipelineRelease.callArgs)) + copy(argCopy, mmGetLatestNamespacePipelineRelease.callArgs) - mmGetDefinitionByUID.mutex.RUnlock() + mmGetLatestNamespacePipelineRelease.mutex.RUnlock() return argCopy } -// MinimockGetDefinitionByUIDDone returns true if the count of the GetDefinitionByUID invocations corresponds +// MinimockGetLatestNamespacePipelineReleaseDone returns true if the count of the GetLatestNamespacePipelineRelease invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetDefinitionByUIDDone() bool { - if m.GetDefinitionByUIDMock.optional { +func (m *RepositoryMock) MinimockGetLatestNamespacePipelineReleaseDone() bool { + if m.GetLatestNamespacePipelineReleaseMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetDefinitionByUIDMock.expectations { + for _, e := range m.GetLatestNamespacePipelineReleaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetDefinitionByUIDMock.invocationsDone() + return m.GetLatestNamespacePipelineReleaseMock.invocationsDone() } -// MinimockGetDefinitionByUIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetDefinitionByUIDInspect() { - for _, e := range m.GetDefinitionByUIDMock.expectations { +// MinimockGetLatestNamespacePipelineReleaseInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetLatestNamespacePipelineReleaseInspect() { + for _, e := range m.GetLatestNamespacePipelineReleaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetDefinitionByUIDCounter := mm_atomic.LoadUint64(&m.afterGetDefinitionByUIDCounter) + afterGetLatestNamespacePipelineReleaseCounter := mm_atomic.LoadUint64(&m.afterGetLatestNamespacePipelineReleaseCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetDefinitionByUIDMock.defaultExpectation != nil && afterGetDefinitionByUIDCounter < 1 { - if m.GetDefinitionByUIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s", m.GetDefinitionByUIDMock.defaultExpectation.returnOrigin) + if m.GetLatestNamespacePipelineReleaseMock.defaultExpectation != nil && afterGetLatestNamespacePipelineReleaseCounter < 1 { + if m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s", m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s with params: %#v", m.GetDefinitionByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetDefinitionByUIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s with params: %#v", m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetDefinitionByUID != nil && afterGetDefinitionByUIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetDefinitionByUID at\n%s", m.funcGetDefinitionByUIDOrigin) + if m.funcGetLatestNamespacePipelineRelease != nil && afterGetLatestNamespacePipelineReleaseCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s", m.funcGetLatestNamespacePipelineReleaseOrigin) } - if !m.GetDefinitionByUIDMock.invocationsDone() && afterGetDefinitionByUIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetDefinitionByUID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetDefinitionByUIDMock.expectedInvocations), m.GetDefinitionByUIDMock.expectedInvocationsOrigin, afterGetDefinitionByUIDCounter) + if !m.GetLatestNamespacePipelineReleaseMock.invocationsDone() && afterGetLatestNamespacePipelineReleaseCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetLatestNamespacePipelineReleaseMock.expectedInvocations), m.GetLatestNamespacePipelineReleaseMock.expectedInvocationsOrigin, afterGetLatestNamespacePipelineReleaseCounter) } } -type mRepositoryMockGetHubStats struct { +type mRepositoryMockGetNamespaceConnectionByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetHubStatsExpectation - expectations []*RepositoryMockGetHubStatsExpectation + defaultExpectation *RepositoryMockGetNamespaceConnectionByIDExpectation + expectations []*RepositoryMockGetNamespaceConnectionByIDExpectation - callArgs []*RepositoryMockGetHubStatsParams + callArgs []*RepositoryMockGetNamespaceConnectionByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetHubStatsExpectation specifies expectation struct of the Repository.GetHubStats -type RepositoryMockGetHubStatsExpectation struct { +// RepositoryMockGetNamespaceConnectionByIDExpectation specifies expectation struct of the Repository.GetNamespaceConnectionByID +type RepositoryMockGetNamespaceConnectionByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockGetHubStatsParams - paramPtrs *RepositoryMockGetHubStatsParamPtrs - expectationOrigins RepositoryMockGetHubStatsExpectationOrigins - results *RepositoryMockGetHubStatsResults + params *RepositoryMockGetNamespaceConnectionByIDParams + paramPtrs *RepositoryMockGetNamespaceConnectionByIDParamPtrs + expectationOrigins RepositoryMockGetNamespaceConnectionByIDExpectationOrigins + results *RepositoryMockGetNamespaceConnectionByIDResults returnOrigin string Counter uint64 } -// RepositoryMockGetHubStatsParams contains parameters of the Repository.GetHubStats -type RepositoryMockGetHubStatsParams struct { - uidAllowList []uuid.UUID +// RepositoryMockGetNamespaceConnectionByIDParams contains parameters of the Repository.GetNamespaceConnectionByID +type RepositoryMockGetNamespaceConnectionByIDParams struct { + ctx context.Context + nsUID uuid.UUID + id string } -// RepositoryMockGetHubStatsParamPtrs contains pointers to parameters of the Repository.GetHubStats -type RepositoryMockGetHubStatsParamPtrs struct { - uidAllowList *[]uuid.UUID +// RepositoryMockGetNamespaceConnectionByIDParamPtrs contains pointers to parameters of the Repository.GetNamespaceConnectionByID +type RepositoryMockGetNamespaceConnectionByIDParamPtrs struct { + ctx *context.Context + nsUID *uuid.UUID + id *string } -// RepositoryMockGetHubStatsResults contains results of the Repository.GetHubStats -type RepositoryMockGetHubStatsResults struct { - hp1 *datamodel.HubStats +// RepositoryMockGetNamespaceConnectionByIDResults contains results of the Repository.GetNamespaceConnectionByID +type RepositoryMockGetNamespaceConnectionByIDResults struct { + cp1 *datamodel.Connection err error } -// RepositoryMockGetHubStatsOrigins contains origins of expectations of the Repository.GetHubStats -type RepositoryMockGetHubStatsExpectationOrigins struct { - origin string - originUidAllowList string +// RepositoryMockGetNamespaceConnectionByIDOrigins contains origins of expectations of the Repository.GetNamespaceConnectionByID +type RepositoryMockGetNamespaceConnectionByIDExpectationOrigins struct { + origin string + originCtx string + originNsUID string + originId string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -6798,320 +6837,379 @@ type RepositoryMockGetHubStatsExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetHubStats *mRepositoryMockGetHubStats) Optional() *mRepositoryMockGetHubStats { - mmGetHubStats.optional = true - return mmGetHubStats +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Optional() *mRepositoryMockGetNamespaceConnectionByID { + mmGetNamespaceConnectionByID.optional = true + return mmGetNamespaceConnectionByID } -// Expect sets up expected params for Repository.GetHubStats -func (mmGetHubStats *mRepositoryMockGetHubStats) Expect(uidAllowList []uuid.UUID) *mRepositoryMockGetHubStats { - if mmGetHubStats.mock.funcGetHubStats != nil { - mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") +// Expect sets up expected params for Repository.GetNamespaceConnectionByID +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Expect(ctx context.Context, nsUID uuid.UUID, id string) *mRepositoryMockGetNamespaceConnectionByID { + if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") } - if mmGetHubStats.defaultExpectation == nil { - mmGetHubStats.defaultExpectation = &RepositoryMockGetHubStatsExpectation{} + if mmGetNamespaceConnectionByID.defaultExpectation == nil { + mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} } - if mmGetHubStats.defaultExpectation.paramPtrs != nil { - mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by ExpectParams functions") + if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by ExpectParams functions") } - mmGetHubStats.defaultExpectation.params = &RepositoryMockGetHubStatsParams{uidAllowList} - mmGetHubStats.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetHubStats.expectations { - if minimock.Equal(e.params, mmGetHubStats.defaultExpectation.params) { - mmGetHubStats.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetHubStats.defaultExpectation.params) + mmGetNamespaceConnectionByID.defaultExpectation.params = &RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id} + mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetNamespaceConnectionByID.expectations { + if minimock.Equal(e.params, mmGetNamespaceConnectionByID.defaultExpectation.params) { + mmGetNamespaceConnectionByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespaceConnectionByID.defaultExpectation.params) } } - return mmGetHubStats + return mmGetNamespaceConnectionByID } -// ExpectUidAllowListParam1 sets up expected param uidAllowList for Repository.GetHubStats -func (mmGetHubStats *mRepositoryMockGetHubStats) ExpectUidAllowListParam1(uidAllowList []uuid.UUID) *mRepositoryMockGetHubStats { - if mmGetHubStats.mock.funcGetHubStats != nil { - mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespaceConnectionByID +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespaceConnectionByID { + if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") } - if mmGetHubStats.defaultExpectation == nil { - mmGetHubStats.defaultExpectation = &RepositoryMockGetHubStatsExpectation{} + if mmGetNamespaceConnectionByID.defaultExpectation == nil { + mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} } - if mmGetHubStats.defaultExpectation.params != nil { - mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Expect") + if mmGetNamespaceConnectionByID.defaultExpectation.params != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Expect") } - if mmGetHubStats.defaultExpectation.paramPtrs == nil { - mmGetHubStats.defaultExpectation.paramPtrs = &RepositoryMockGetHubStatsParamPtrs{} + if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { + mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceConnectionByIDParamPtrs{} } - mmGetHubStats.defaultExpectation.paramPtrs.uidAllowList = &uidAllowList - mmGetHubStats.defaultExpectation.expectationOrigins.originUidAllowList = minimock.CallerInfo(1) + mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetHubStats + return mmGetNamespaceConnectionByID } -// Inspect accepts an inspector function that has same arguments as the Repository.GetHubStats -func (mmGetHubStats *mRepositoryMockGetHubStats) Inspect(f func(uidAllowList []uuid.UUID)) *mRepositoryMockGetHubStats { - if mmGetHubStats.mock.inspectFuncGetHubStats != nil { - mmGetHubStats.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetHubStats") +// ExpectNsUIDParam2 sets up expected param nsUID for Repository.GetNamespaceConnectionByID +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) ExpectNsUIDParam2(nsUID uuid.UUID) *mRepositoryMockGetNamespaceConnectionByID { + if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") } - mmGetHubStats.mock.inspectFuncGetHubStats = f - - return mmGetHubStats -} - -// Return sets up results that will be returned by Repository.GetHubStats -func (mmGetHubStats *mRepositoryMockGetHubStats) Return(hp1 *datamodel.HubStats, err error) *RepositoryMock { - if mmGetHubStats.mock.funcGetHubStats != nil { - mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") + if mmGetNamespaceConnectionByID.defaultExpectation == nil { + mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} } - if mmGetHubStats.defaultExpectation == nil { - mmGetHubStats.defaultExpectation = &RepositoryMockGetHubStatsExpectation{mock: mmGetHubStats.mock} + if mmGetNamespaceConnectionByID.defaultExpectation.params != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Expect") } - mmGetHubStats.defaultExpectation.results = &RepositoryMockGetHubStatsResults{hp1, err} - mmGetHubStats.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetHubStats.mock -} -// Set uses given function f to mock the Repository.GetHubStats method -func (mmGetHubStats *mRepositoryMockGetHubStats) Set(f func(uidAllowList []uuid.UUID) (hp1 *datamodel.HubStats, err error)) *RepositoryMock { - if mmGetHubStats.defaultExpectation != nil { - mmGetHubStats.mock.t.Fatalf("Default expectation is already set for the Repository.GetHubStats method") + if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { + mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceConnectionByIDParamPtrs{} } + mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs.nsUID = &nsUID + mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.originNsUID = minimock.CallerInfo(1) - if len(mmGetHubStats.expectations) > 0 { - mmGetHubStats.mock.t.Fatalf("Some expectations are already set for the Repository.GetHubStats method") + return mmGetNamespaceConnectionByID +} + +// ExpectIdParam3 sets up expected param id for Repository.GetNamespaceConnectionByID +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) ExpectIdParam3(id string) *mRepositoryMockGetNamespaceConnectionByID { + if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") } - mmGetHubStats.mock.funcGetHubStats = f - mmGetHubStats.mock.funcGetHubStatsOrigin = minimock.CallerInfo(1) - return mmGetHubStats.mock + if mmGetNamespaceConnectionByID.defaultExpectation == nil { + mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} + } + + if mmGetNamespaceConnectionByID.defaultExpectation.params != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Expect") + } + + if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { + mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceConnectionByIDParamPtrs{} + } + mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs.id = &id + mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + + return mmGetNamespaceConnectionByID } -// When sets expectation for the Repository.GetHubStats which will trigger the result defined by the following +// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespaceConnectionByID +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Inspect(f func(ctx context.Context, nsUID uuid.UUID, id string)) *mRepositoryMockGetNamespaceConnectionByID { + if mmGetNamespaceConnectionByID.mock.inspectFuncGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespaceConnectionByID") + } + + mmGetNamespaceConnectionByID.mock.inspectFuncGetNamespaceConnectionByID = f + + return mmGetNamespaceConnectionByID +} + +// Return sets up results that will be returned by Repository.GetNamespaceConnectionByID +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Return(cp1 *datamodel.Connection, err error) *RepositoryMock { + if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") + } + + if mmGetNamespaceConnectionByID.defaultExpectation == nil { + mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{mock: mmGetNamespaceConnectionByID.mock} + } + mmGetNamespaceConnectionByID.defaultExpectation.results = &RepositoryMockGetNamespaceConnectionByIDResults{cp1, err} + mmGetNamespaceConnectionByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetNamespaceConnectionByID.mock +} + +// Set uses given function f to mock the Repository.GetNamespaceConnectionByID method +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Set(f func(ctx context.Context, nsUID uuid.UUID, id string) (cp1 *datamodel.Connection, err error)) *RepositoryMock { + if mmGetNamespaceConnectionByID.defaultExpectation != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespaceConnectionByID method") + } + + if len(mmGetNamespaceConnectionByID.expectations) > 0 { + mmGetNamespaceConnectionByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespaceConnectionByID method") + } + + mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID = f + mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByIDOrigin = minimock.CallerInfo(1) + return mmGetNamespaceConnectionByID.mock +} + +// When sets expectation for the Repository.GetNamespaceConnectionByID which will trigger the result defined by the following // Then helper -func (mmGetHubStats *mRepositoryMockGetHubStats) When(uidAllowList []uuid.UUID) *RepositoryMockGetHubStatsExpectation { - if mmGetHubStats.mock.funcGetHubStats != nil { - mmGetHubStats.mock.t.Fatalf("RepositoryMock.GetHubStats mock is already set by Set") +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) When(ctx context.Context, nsUID uuid.UUID, id string) *RepositoryMockGetNamespaceConnectionByIDExpectation { + if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") } - expectation := &RepositoryMockGetHubStatsExpectation{ - mock: mmGetHubStats.mock, - params: &RepositoryMockGetHubStatsParams{uidAllowList}, - expectationOrigins: RepositoryMockGetHubStatsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetNamespaceConnectionByIDExpectation{ + mock: mmGetNamespaceConnectionByID.mock, + params: &RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id}, + expectationOrigins: RepositoryMockGetNamespaceConnectionByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetHubStats.expectations = append(mmGetHubStats.expectations, expectation) + mmGetNamespaceConnectionByID.expectations = append(mmGetNamespaceConnectionByID.expectations, expectation) return expectation } -// Then sets up Repository.GetHubStats return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetHubStatsExpectation) Then(hp1 *datamodel.HubStats, err error) *RepositoryMock { - e.results = &RepositoryMockGetHubStatsResults{hp1, err} +// Then sets up Repository.GetNamespaceConnectionByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetNamespaceConnectionByIDExpectation) Then(cp1 *datamodel.Connection, err error) *RepositoryMock { + e.results = &RepositoryMockGetNamespaceConnectionByIDResults{cp1, err} return e.mock } -// Times sets number of times Repository.GetHubStats should be invoked -func (mmGetHubStats *mRepositoryMockGetHubStats) Times(n uint64) *mRepositoryMockGetHubStats { +// Times sets number of times Repository.GetNamespaceConnectionByID should be invoked +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Times(n uint64) *mRepositoryMockGetNamespaceConnectionByID { if n == 0 { - mmGetHubStats.mock.t.Fatalf("Times of RepositoryMock.GetHubStats mock can not be zero") + mmGetNamespaceConnectionByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespaceConnectionByID mock can not be zero") } - mm_atomic.StoreUint64(&mmGetHubStats.expectedInvocations, n) - mmGetHubStats.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetHubStats + mm_atomic.StoreUint64(&mmGetNamespaceConnectionByID.expectedInvocations, n) + mmGetNamespaceConnectionByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetNamespaceConnectionByID } -func (mmGetHubStats *mRepositoryMockGetHubStats) invocationsDone() bool { - if len(mmGetHubStats.expectations) == 0 && mmGetHubStats.defaultExpectation == nil && mmGetHubStats.mock.funcGetHubStats == nil { +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) invocationsDone() bool { + if len(mmGetNamespaceConnectionByID.expectations) == 0 && mmGetNamespaceConnectionByID.defaultExpectation == nil && mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetHubStats.mock.afterGetHubStatsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetHubStats.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.mock.afterGetNamespaceConnectionByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetHubStats implements mm_repository.Repository -func (mmGetHubStats *RepositoryMock) GetHubStats(uidAllowList []uuid.UUID) (hp1 *datamodel.HubStats, err error) { - mm_atomic.AddUint64(&mmGetHubStats.beforeGetHubStatsCounter, 1) - defer mm_atomic.AddUint64(&mmGetHubStats.afterGetHubStatsCounter, 1) +// GetNamespaceConnectionByID implements mm_repository.Repository +func (mmGetNamespaceConnectionByID *RepositoryMock) GetNamespaceConnectionByID(ctx context.Context, nsUID uuid.UUID, id string) (cp1 *datamodel.Connection, err error) { + mm_atomic.AddUint64(&mmGetNamespaceConnectionByID.beforeGetNamespaceConnectionByIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetNamespaceConnectionByID.afterGetNamespaceConnectionByIDCounter, 1) - mmGetHubStats.t.Helper() + mmGetNamespaceConnectionByID.t.Helper() - if mmGetHubStats.inspectFuncGetHubStats != nil { - mmGetHubStats.inspectFuncGetHubStats(uidAllowList) + if mmGetNamespaceConnectionByID.inspectFuncGetNamespaceConnectionByID != nil { + mmGetNamespaceConnectionByID.inspectFuncGetNamespaceConnectionByID(ctx, nsUID, id) } - mm_params := RepositoryMockGetHubStatsParams{uidAllowList} + mm_params := RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id} // Record call args - mmGetHubStats.GetHubStatsMock.mutex.Lock() - mmGetHubStats.GetHubStatsMock.callArgs = append(mmGetHubStats.GetHubStatsMock.callArgs, &mm_params) - mmGetHubStats.GetHubStatsMock.mutex.Unlock() + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.mutex.Lock() + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.callArgs = append(mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.callArgs, &mm_params) + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.mutex.Unlock() - for _, e := range mmGetHubStats.GetHubStatsMock.expectations { + for _, e := range mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.hp1, e.results.err + return e.results.cp1, e.results.err } } - if mmGetHubStats.GetHubStatsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetHubStats.GetHubStatsMock.defaultExpectation.Counter, 1) - mm_want := mmGetHubStats.GetHubStatsMock.defaultExpectation.params - mm_want_ptrs := mmGetHubStats.GetHubStatsMock.defaultExpectation.paramPtrs + if mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.params + mm_want_ptrs := mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetHubStatsParams{uidAllowList} + mm_got := RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id} if mm_want_ptrs != nil { - if mm_want_ptrs.uidAllowList != nil && !minimock.Equal(*mm_want_ptrs.uidAllowList, mm_got.uidAllowList) { - mmGetHubStats.t.Errorf("RepositoryMock.GetHubStats got unexpected parameter uidAllowList, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetHubStats.GetHubStatsMock.defaultExpectation.expectationOrigins.originUidAllowList, *mm_want_ptrs.uidAllowList, mm_got.uidAllowList, minimock.Diff(*mm_want_ptrs.uidAllowList, mm_got.uidAllowList)) + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.nsUID != nil && !minimock.Equal(*mm_want_ptrs.nsUID, mm_got.nsUID) { + mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameter nsUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originNsUID, *mm_want_ptrs.nsUID, mm_got.nsUID, minimock.Diff(*mm_want_ptrs.nsUID, mm_got.nsUID)) + } + + if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { + mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetHubStats.t.Errorf("RepositoryMock.GetHubStats got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetHubStats.GetHubStatsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetHubStats.GetHubStatsMock.defaultExpectation.results + mm_results := mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.results if mm_results == nil { - mmGetHubStats.t.Fatal("No results are set for the RepositoryMock.GetHubStats") + mmGetNamespaceConnectionByID.t.Fatal("No results are set for the RepositoryMock.GetNamespaceConnectionByID") } - return (*mm_results).hp1, (*mm_results).err + return (*mm_results).cp1, (*mm_results).err } - if mmGetHubStats.funcGetHubStats != nil { - return mmGetHubStats.funcGetHubStats(uidAllowList) + if mmGetNamespaceConnectionByID.funcGetNamespaceConnectionByID != nil { + return mmGetNamespaceConnectionByID.funcGetNamespaceConnectionByID(ctx, nsUID, id) } - mmGetHubStats.t.Fatalf("Unexpected call to RepositoryMock.GetHubStats. %v", uidAllowList) + mmGetNamespaceConnectionByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespaceConnectionByID. %v %v %v", ctx, nsUID, id) return } -// GetHubStatsAfterCounter returns a count of finished RepositoryMock.GetHubStats invocations -func (mmGetHubStats *RepositoryMock) GetHubStatsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetHubStats.afterGetHubStatsCounter) +// GetNamespaceConnectionByIDAfterCounter returns a count of finished RepositoryMock.GetNamespaceConnectionByID invocations +func (mmGetNamespaceConnectionByID *RepositoryMock) GetNamespaceConnectionByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.afterGetNamespaceConnectionByIDCounter) } -// GetHubStatsBeforeCounter returns a count of RepositoryMock.GetHubStats invocations -func (mmGetHubStats *RepositoryMock) GetHubStatsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetHubStats.beforeGetHubStatsCounter) +// GetNamespaceConnectionByIDBeforeCounter returns a count of RepositoryMock.GetNamespaceConnectionByID invocations +func (mmGetNamespaceConnectionByID *RepositoryMock) GetNamespaceConnectionByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.beforeGetNamespaceConnectionByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetHubStats. +// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespaceConnectionByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetHubStats *mRepositoryMockGetHubStats) Calls() []*RepositoryMockGetHubStatsParams { - mmGetHubStats.mutex.RLock() +func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Calls() []*RepositoryMockGetNamespaceConnectionByIDParams { + mmGetNamespaceConnectionByID.mutex.RLock() - argCopy := make([]*RepositoryMockGetHubStatsParams, len(mmGetHubStats.callArgs)) - copy(argCopy, mmGetHubStats.callArgs) + argCopy := make([]*RepositoryMockGetNamespaceConnectionByIDParams, len(mmGetNamespaceConnectionByID.callArgs)) + copy(argCopy, mmGetNamespaceConnectionByID.callArgs) - mmGetHubStats.mutex.RUnlock() + mmGetNamespaceConnectionByID.mutex.RUnlock() return argCopy } -// MinimockGetHubStatsDone returns true if the count of the GetHubStats invocations corresponds +// MinimockGetNamespaceConnectionByIDDone returns true if the count of the GetNamespaceConnectionByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetHubStatsDone() bool { - if m.GetHubStatsMock.optional { +func (m *RepositoryMock) MinimockGetNamespaceConnectionByIDDone() bool { + if m.GetNamespaceConnectionByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetHubStatsMock.expectations { + for _, e := range m.GetNamespaceConnectionByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetHubStatsMock.invocationsDone() + return m.GetNamespaceConnectionByIDMock.invocationsDone() } -// MinimockGetHubStatsInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetHubStatsInspect() { - for _, e := range m.GetHubStatsMock.expectations { +// MinimockGetNamespaceConnectionByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetNamespaceConnectionByIDInspect() { + for _, e := range m.GetNamespaceConnectionByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetHubStatsCounter := mm_atomic.LoadUint64(&m.afterGetHubStatsCounter) + afterGetNamespaceConnectionByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespaceConnectionByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetHubStatsMock.defaultExpectation != nil && afterGetHubStatsCounter < 1 { - if m.GetHubStatsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s", m.GetHubStatsMock.defaultExpectation.returnOrigin) + if m.GetNamespaceConnectionByIDMock.defaultExpectation != nil && afterGetNamespaceConnectionByIDCounter < 1 { + if m.GetNamespaceConnectionByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s", m.GetNamespaceConnectionByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s with params: %#v", m.GetHubStatsMock.defaultExpectation.expectationOrigins.origin, *m.GetHubStatsMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s with params: %#v", m.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespaceConnectionByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetHubStats != nil && afterGetHubStatsCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetHubStats at\n%s", m.funcGetHubStatsOrigin) + if m.funcGetNamespaceConnectionByID != nil && afterGetNamespaceConnectionByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s", m.funcGetNamespaceConnectionByIDOrigin) } - if !m.GetHubStatsMock.invocationsDone() && afterGetHubStatsCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetHubStats at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetHubStatsMock.expectedInvocations), m.GetHubStatsMock.expectedInvocationsOrigin, afterGetHubStatsCounter) + if !m.GetNamespaceConnectionByIDMock.invocationsDone() && afterGetNamespaceConnectionByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespaceConnectionByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetNamespaceConnectionByIDMock.expectedInvocations), m.GetNamespaceConnectionByIDMock.expectedInvocationsOrigin, afterGetNamespaceConnectionByIDCounter) } } -type mRepositoryMockGetLatestNamespacePipelineRelease struct { +type mRepositoryMockGetNamespacePipelineByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetLatestNamespacePipelineReleaseExpectation - expectations []*RepositoryMockGetLatestNamespacePipelineReleaseExpectation + defaultExpectation *RepositoryMockGetNamespacePipelineByIDExpectation + expectations []*RepositoryMockGetNamespacePipelineByIDExpectation - callArgs []*RepositoryMockGetLatestNamespacePipelineReleaseParams + callArgs []*RepositoryMockGetNamespacePipelineByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetLatestNamespacePipelineReleaseExpectation specifies expectation struct of the Repository.GetLatestNamespacePipelineRelease -type RepositoryMockGetLatestNamespacePipelineReleaseExpectation struct { +// RepositoryMockGetNamespacePipelineByIDExpectation specifies expectation struct of the Repository.GetNamespacePipelineByID +type RepositoryMockGetNamespacePipelineByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockGetLatestNamespacePipelineReleaseParams - paramPtrs *RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs - expectationOrigins RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins - results *RepositoryMockGetLatestNamespacePipelineReleaseResults + params *RepositoryMockGetNamespacePipelineByIDParams + paramPtrs *RepositoryMockGetNamespacePipelineByIDParamPtrs + expectationOrigins RepositoryMockGetNamespacePipelineByIDExpectationOrigins + results *RepositoryMockGetNamespacePipelineByIDResults returnOrigin string Counter uint64 } -// RepositoryMockGetLatestNamespacePipelineReleaseParams contains parameters of the Repository.GetLatestNamespacePipelineRelease -type RepositoryMockGetLatestNamespacePipelineReleaseParams struct { +// RepositoryMockGetNamespacePipelineByIDParams contains parameters of the Repository.GetNamespacePipelineByID +type RepositoryMockGetNamespacePipelineByIDParams struct { ctx context.Context ownerPermalink string - pipelineUID uuid.UUID + id string isBasicView bool + embedReleases bool } -// RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs contains pointers to parameters of the Repository.GetLatestNamespacePipelineRelease -type RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs struct { +// RepositoryMockGetNamespacePipelineByIDParamPtrs contains pointers to parameters of the Repository.GetNamespacePipelineByID +type RepositoryMockGetNamespacePipelineByIDParamPtrs struct { ctx *context.Context ownerPermalink *string - pipelineUID *uuid.UUID + id *string isBasicView *bool + embedReleases *bool } -// RepositoryMockGetLatestNamespacePipelineReleaseResults contains results of the Repository.GetLatestNamespacePipelineRelease -type RepositoryMockGetLatestNamespacePipelineReleaseResults struct { - pp1 *datamodel.PipelineRelease +// RepositoryMockGetNamespacePipelineByIDResults contains results of the Repository.GetNamespacePipelineByID +type RepositoryMockGetNamespacePipelineByIDResults struct { + pp1 *datamodel.Pipeline err error } -// RepositoryMockGetLatestNamespacePipelineReleaseOrigins contains origins of expectations of the Repository.GetLatestNamespacePipelineRelease -type RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins struct { +// RepositoryMockGetNamespacePipelineByIDOrigins contains origins of expectations of the Repository.GetNamespacePipelineByID +type RepositoryMockGetNamespacePipelineByIDExpectationOrigins struct { origin string originCtx string originOwnerPermalink string - originPipelineUID string + originId string originIsBasicView string + originEmbedReleases string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -7119,401 +7217,435 @@ type RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Optional() *mRepositoryMockGetLatestNamespacePipelineRelease { - mmGetLatestNamespacePipelineRelease.optional = true - return mmGetLatestNamespacePipelineRelease +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Optional() *mRepositoryMockGetNamespacePipelineByID { + mmGetNamespacePipelineByID.optional = true + return mmGetNamespacePipelineByID } -// Expect sets up expected params for Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) *mRepositoryMockGetLatestNamespacePipelineRelease { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") +// Expect sets up expected params for Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Expect(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by ExpectParams functions") + if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by ExpectParams functions") } - mmGetLatestNamespacePipelineRelease.defaultExpectation.params = &RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView} - mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetLatestNamespacePipelineRelease.expectations { - if minimock.Equal(e.params, mmGetLatestNamespacePipelineRelease.defaultExpectation.params) { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetLatestNamespacePipelineRelease.defaultExpectation.params) + mmGetNamespacePipelineByID.defaultExpectation.params = &RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases} + mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetNamespacePipelineByID.expectations { + if minimock.Equal(e.params, mmGetNamespacePipelineByID.defaultExpectation.params) { + mmGetNamespacePipelineByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespacePipelineByID.defaultExpectation.params) } } - return mmGetLatestNamespacePipelineRelease + return mmGetNamespacePipelineByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetLatestNamespacePipelineRelease { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") + if mmGetNamespacePipelineByID.defaultExpectation.params != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} + if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} } - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.ctx = &ctx - mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease + return mmGetNamespacePipelineByID } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetLatestNamespacePipelineRelease { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") + if mmGetNamespacePipelineByID.defaultExpectation.params != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} + if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} } - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease + return mmGetNamespacePipelineByID } -// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockGetLatestNamespacePipelineRelease { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") +// ExpectIdParam3 sets up expected param id for Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectIdParam3(id string) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") + if mmGetNamespacePipelineByID.defaultExpectation.params != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} + if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} } - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.id = &id + mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease + return mmGetNamespacePipelineByID } -// ExpectIsBasicViewParam4 sets up expected param isBasicView for Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) ExpectIsBasicViewParam4(isBasicView bool) *mRepositoryMockGetLatestNamespacePipelineRelease { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") +// ExpectIsBasicViewParam4 sets up expected param isBasicView for Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectIsBasicViewParam4(isBasicView bool) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{} + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.params != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Expect") + if mmGetNamespacePipelineByID.defaultExpectation.params != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs = &RepositoryMockGetLatestNamespacePipelineReleaseParamPtrs{} + if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} } - mmGetLatestNamespacePipelineRelease.defaultExpectation.paramPtrs.isBasicView = &isBasicView - mmGetLatestNamespacePipelineRelease.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.isBasicView = &isBasicView + mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease + return mmGetNamespacePipelineByID } -// Inspect accepts an inspector function that has same arguments as the Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool)) *mRepositoryMockGetLatestNamespacePipelineRelease { - if mmGetLatestNamespacePipelineRelease.mock.inspectFuncGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetLatestNamespacePipelineRelease") +// ExpectEmbedReleasesParam5 sets up expected param embedReleases for Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectEmbedReleasesParam5(embedReleases bool) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - mmGetLatestNamespacePipelineRelease.mock.inspectFuncGetLatestNamespacePipelineRelease = f - - return mmGetLatestNamespacePipelineRelease -} + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} + } -// Return sets up results that will be returned by Repository.GetLatestNamespacePipelineRelease -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Return(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") + if mmGetNamespacePipelineByID.defaultExpectation.params != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") } - if mmGetLatestNamespacePipelineRelease.defaultExpectation == nil { - mmGetLatestNamespacePipelineRelease.defaultExpectation = &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{mock: mmGetLatestNamespacePipelineRelease.mock} + if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} } - mmGetLatestNamespacePipelineRelease.defaultExpectation.results = &RepositoryMockGetLatestNamespacePipelineReleaseResults{pp1, err} - mmGetLatestNamespacePipelineRelease.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease.mock + mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.embedReleases = &embedReleases + mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originEmbedReleases = minimock.CallerInfo(1) + + return mmGetNamespacePipelineByID } -// Set uses given function f to mock the Repository.GetLatestNamespacePipelineRelease method -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error)) *RepositoryMock { - if mmGetLatestNamespacePipelineRelease.defaultExpectation != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Default expectation is already set for the Repository.GetLatestNamespacePipelineRelease method") +// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool)) *mRepositoryMockGetNamespacePipelineByID { + if mmGetNamespacePipelineByID.mock.inspectFuncGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespacePipelineByID") } - if len(mmGetLatestNamespacePipelineRelease.expectations) > 0 { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Some expectations are already set for the Repository.GetLatestNamespacePipelineRelease method") - } + mmGetNamespacePipelineByID.mock.inspectFuncGetNamespacePipelineByID = f - mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease = f - mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineReleaseOrigin = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease.mock + return mmGetNamespacePipelineByID } -// When sets expectation for the Repository.GetLatestNamespacePipelineRelease which will trigger the result defined by the following -// Then helper -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) *RepositoryMockGetLatestNamespacePipelineReleaseExpectation { - if mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("RepositoryMock.GetLatestNamespacePipelineRelease mock is already set by Set") +// Return sets up results that will be returned by Repository.GetNamespacePipelineByID +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Return(pp1 *datamodel.Pipeline, err error) *RepositoryMock { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") } - expectation := &RepositoryMockGetLatestNamespacePipelineReleaseExpectation{ - mock: mmGetLatestNamespacePipelineRelease.mock, - params: &RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView}, - expectationOrigins: RepositoryMockGetLatestNamespacePipelineReleaseExpectationOrigins{origin: minimock.CallerInfo(1)}, + if mmGetNamespacePipelineByID.defaultExpectation == nil { + mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{mock: mmGetNamespacePipelineByID.mock} } - mmGetLatestNamespacePipelineRelease.expectations = append(mmGetLatestNamespacePipelineRelease.expectations, expectation) - return expectation + mmGetNamespacePipelineByID.defaultExpectation.results = &RepositoryMockGetNamespacePipelineByIDResults{pp1, err} + mmGetNamespacePipelineByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetNamespacePipelineByID.mock } -// Then sets up Repository.GetLatestNamespacePipelineRelease return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetLatestNamespacePipelineReleaseExpectation) Then(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { - e.results = &RepositoryMockGetLatestNamespacePipelineReleaseResults{pp1, err} - return e.mock -} +// Set uses given function f to mock the Repository.GetNamespacePipelineByID method +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Set(f func(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error)) *RepositoryMock { + if mmGetNamespacePipelineByID.defaultExpectation != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespacePipelineByID method") + } -// Times sets number of times Repository.GetLatestNamespacePipelineRelease should be invoked -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Times(n uint64) *mRepositoryMockGetLatestNamespacePipelineRelease { + if len(mmGetNamespacePipelineByID.expectations) > 0 { + mmGetNamespacePipelineByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespacePipelineByID method") + } + + mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID = f + mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByIDOrigin = minimock.CallerInfo(1) + return mmGetNamespacePipelineByID.mock +} + +// When sets expectation for the Repository.GetNamespacePipelineByID which will trigger the result defined by the following +// Then helper +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) When(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) *RepositoryMockGetNamespacePipelineByIDExpectation { + if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") + } + + expectation := &RepositoryMockGetNamespacePipelineByIDExpectation{ + mock: mmGetNamespacePipelineByID.mock, + params: &RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases}, + expectationOrigins: RepositoryMockGetNamespacePipelineByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmGetNamespacePipelineByID.expectations = append(mmGetNamespacePipelineByID.expectations, expectation) + return expectation +} + +// Then sets up Repository.GetNamespacePipelineByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetNamespacePipelineByIDExpectation) Then(pp1 *datamodel.Pipeline, err error) *RepositoryMock { + e.results = &RepositoryMockGetNamespacePipelineByIDResults{pp1, err} + return e.mock +} + +// Times sets number of times Repository.GetNamespacePipelineByID should be invoked +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Times(n uint64) *mRepositoryMockGetNamespacePipelineByID { if n == 0 { - mmGetLatestNamespacePipelineRelease.mock.t.Fatalf("Times of RepositoryMock.GetLatestNamespacePipelineRelease mock can not be zero") + mmGetNamespacePipelineByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespacePipelineByID mock can not be zero") } - mm_atomic.StoreUint64(&mmGetLatestNamespacePipelineRelease.expectedInvocations, n) - mmGetLatestNamespacePipelineRelease.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetLatestNamespacePipelineRelease + mm_atomic.StoreUint64(&mmGetNamespacePipelineByID.expectedInvocations, n) + mmGetNamespacePipelineByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetNamespacePipelineByID } -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) invocationsDone() bool { - if len(mmGetLatestNamespacePipelineRelease.expectations) == 0 && mmGetLatestNamespacePipelineRelease.defaultExpectation == nil && mmGetLatestNamespacePipelineRelease.mock.funcGetLatestNamespacePipelineRelease == nil { +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) invocationsDone() bool { + if len(mmGetNamespacePipelineByID.expectations) == 0 && mmGetNamespacePipelineByID.defaultExpectation == nil && mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.mock.afterGetLatestNamespacePipelineReleaseCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.mock.afterGetNamespacePipelineByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetLatestNamespacePipelineRelease implements mm_repository.Repository -func (mmGetLatestNamespacePipelineRelease *RepositoryMock) GetLatestNamespacePipelineRelease(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error) { - mm_atomic.AddUint64(&mmGetLatestNamespacePipelineRelease.beforeGetLatestNamespacePipelineReleaseCounter, 1) - defer mm_atomic.AddUint64(&mmGetLatestNamespacePipelineRelease.afterGetLatestNamespacePipelineReleaseCounter, 1) +// GetNamespacePipelineByID implements mm_repository.Repository +func (mmGetNamespacePipelineByID *RepositoryMock) GetNamespacePipelineByID(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error) { + mm_atomic.AddUint64(&mmGetNamespacePipelineByID.beforeGetNamespacePipelineByIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetNamespacePipelineByID.afterGetNamespacePipelineByIDCounter, 1) - mmGetLatestNamespacePipelineRelease.t.Helper() + mmGetNamespacePipelineByID.t.Helper() - if mmGetLatestNamespacePipelineRelease.inspectFuncGetLatestNamespacePipelineRelease != nil { - mmGetLatestNamespacePipelineRelease.inspectFuncGetLatestNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, isBasicView) + if mmGetNamespacePipelineByID.inspectFuncGetNamespacePipelineByID != nil { + mmGetNamespacePipelineByID.inspectFuncGetNamespacePipelineByID(ctx, ownerPermalink, id, isBasicView, embedReleases) } - mm_params := RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView} + mm_params := RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases} // Record call args - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.mutex.Lock() - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.callArgs = append(mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.callArgs, &mm_params) - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.mutex.Unlock() + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.mutex.Lock() + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.callArgs = append(mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.callArgs, &mm_params) + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.mutex.Unlock() - for _, e := range mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.expectations { + for _, e := range mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.pp1, e.results.err } } - if mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.Counter, 1) - mm_want := mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.params - mm_want_ptrs := mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.paramPtrs + if mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.params + mm_want_ptrs := mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetLatestNamespacePipelineReleaseParams{ctx, ownerPermalink, pipelineUID, isBasicView} + mm_got := RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) } - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { + mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { - mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) + mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) + } + + if mm_want_ptrs.embedReleases != nil && !minimock.Equal(*mm_want_ptrs.embedReleases, mm_got.embedReleases) { + mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter embedReleases, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originEmbedReleases, *mm_want_ptrs.embedReleases, mm_got.embedReleases, minimock.Diff(*mm_want_ptrs.embedReleases, mm_got.embedReleases)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetLatestNamespacePipelineRelease.t.Errorf("RepositoryMock.GetLatestNamespacePipelineRelease got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetLatestNamespacePipelineRelease.GetLatestNamespacePipelineReleaseMock.defaultExpectation.results + mm_results := mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.results if mm_results == nil { - mmGetLatestNamespacePipelineRelease.t.Fatal("No results are set for the RepositoryMock.GetLatestNamespacePipelineRelease") + mmGetNamespacePipelineByID.t.Fatal("No results are set for the RepositoryMock.GetNamespacePipelineByID") } return (*mm_results).pp1, (*mm_results).err } - if mmGetLatestNamespacePipelineRelease.funcGetLatestNamespacePipelineRelease != nil { - return mmGetLatestNamespacePipelineRelease.funcGetLatestNamespacePipelineRelease(ctx, ownerPermalink, pipelineUID, isBasicView) + if mmGetNamespacePipelineByID.funcGetNamespacePipelineByID != nil { + return mmGetNamespacePipelineByID.funcGetNamespacePipelineByID(ctx, ownerPermalink, id, isBasicView, embedReleases) } - mmGetLatestNamespacePipelineRelease.t.Fatalf("Unexpected call to RepositoryMock.GetLatestNamespacePipelineRelease. %v %v %v %v", ctx, ownerPermalink, pipelineUID, isBasicView) + mmGetNamespacePipelineByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespacePipelineByID. %v %v %v %v %v", ctx, ownerPermalink, id, isBasicView, embedReleases) return } -// GetLatestNamespacePipelineReleaseAfterCounter returns a count of finished RepositoryMock.GetLatestNamespacePipelineRelease invocations -func (mmGetLatestNamespacePipelineRelease *RepositoryMock) GetLatestNamespacePipelineReleaseAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.afterGetLatestNamespacePipelineReleaseCounter) +// GetNamespacePipelineByIDAfterCounter returns a count of finished RepositoryMock.GetNamespacePipelineByID invocations +func (mmGetNamespacePipelineByID *RepositoryMock) GetNamespacePipelineByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.afterGetNamespacePipelineByIDCounter) } -// GetLatestNamespacePipelineReleaseBeforeCounter returns a count of RepositoryMock.GetLatestNamespacePipelineRelease invocations -func (mmGetLatestNamespacePipelineRelease *RepositoryMock) GetLatestNamespacePipelineReleaseBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetLatestNamespacePipelineRelease.beforeGetLatestNamespacePipelineReleaseCounter) +// GetNamespacePipelineByIDBeforeCounter returns a count of RepositoryMock.GetNamespacePipelineByID invocations +func (mmGetNamespacePipelineByID *RepositoryMock) GetNamespacePipelineByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.beforeGetNamespacePipelineByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetLatestNamespacePipelineRelease. +// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespacePipelineByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetLatestNamespacePipelineRelease *mRepositoryMockGetLatestNamespacePipelineRelease) Calls() []*RepositoryMockGetLatestNamespacePipelineReleaseParams { - mmGetLatestNamespacePipelineRelease.mutex.RLock() +func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Calls() []*RepositoryMockGetNamespacePipelineByIDParams { + mmGetNamespacePipelineByID.mutex.RLock() - argCopy := make([]*RepositoryMockGetLatestNamespacePipelineReleaseParams, len(mmGetLatestNamespacePipelineRelease.callArgs)) - copy(argCopy, mmGetLatestNamespacePipelineRelease.callArgs) + argCopy := make([]*RepositoryMockGetNamespacePipelineByIDParams, len(mmGetNamespacePipelineByID.callArgs)) + copy(argCopy, mmGetNamespacePipelineByID.callArgs) - mmGetLatestNamespacePipelineRelease.mutex.RUnlock() + mmGetNamespacePipelineByID.mutex.RUnlock() return argCopy } -// MinimockGetLatestNamespacePipelineReleaseDone returns true if the count of the GetLatestNamespacePipelineRelease invocations corresponds +// MinimockGetNamespacePipelineByIDDone returns true if the count of the GetNamespacePipelineByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetLatestNamespacePipelineReleaseDone() bool { - if m.GetLatestNamespacePipelineReleaseMock.optional { +func (m *RepositoryMock) MinimockGetNamespacePipelineByIDDone() bool { + if m.GetNamespacePipelineByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetLatestNamespacePipelineReleaseMock.expectations { + for _, e := range m.GetNamespacePipelineByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetLatestNamespacePipelineReleaseMock.invocationsDone() + return m.GetNamespacePipelineByIDMock.invocationsDone() } -// MinimockGetLatestNamespacePipelineReleaseInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetLatestNamespacePipelineReleaseInspect() { - for _, e := range m.GetLatestNamespacePipelineReleaseMock.expectations { +// MinimockGetNamespacePipelineByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetNamespacePipelineByIDInspect() { + for _, e := range m.GetNamespacePipelineByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetLatestNamespacePipelineReleaseCounter := mm_atomic.LoadUint64(&m.afterGetLatestNamespacePipelineReleaseCounter) + afterGetNamespacePipelineByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespacePipelineByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetLatestNamespacePipelineReleaseMock.defaultExpectation != nil && afterGetLatestNamespacePipelineReleaseCounter < 1 { - if m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s", m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.returnOrigin) + if m.GetNamespacePipelineByIDMock.defaultExpectation != nil && afterGetNamespacePipelineByIDCounter < 1 { + if m.GetNamespacePipelineByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s", m.GetNamespacePipelineByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s with params: %#v", m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.expectationOrigins.origin, *m.GetLatestNamespacePipelineReleaseMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s with params: %#v", m.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespacePipelineByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetLatestNamespacePipelineRelease != nil && afterGetLatestNamespacePipelineReleaseCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s", m.funcGetLatestNamespacePipelineReleaseOrigin) + if m.funcGetNamespacePipelineByID != nil && afterGetNamespacePipelineByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s", m.funcGetNamespacePipelineByIDOrigin) } - if !m.GetLatestNamespacePipelineReleaseMock.invocationsDone() && afterGetLatestNamespacePipelineReleaseCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetLatestNamespacePipelineRelease at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetLatestNamespacePipelineReleaseMock.expectedInvocations), m.GetLatestNamespacePipelineReleaseMock.expectedInvocationsOrigin, afterGetLatestNamespacePipelineReleaseCounter) + if !m.GetNamespacePipelineByIDMock.invocationsDone() && afterGetNamespacePipelineByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespacePipelineByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetNamespacePipelineByIDMock.expectedInvocations), m.GetNamespacePipelineByIDMock.expectedInvocationsOrigin, afterGetNamespacePipelineByIDCounter) } } -type mRepositoryMockGetNamespaceConnectionByID struct { +type mRepositoryMockGetNamespacePipelineReleaseByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetNamespaceConnectionByIDExpectation - expectations []*RepositoryMockGetNamespaceConnectionByIDExpectation + defaultExpectation *RepositoryMockGetNamespacePipelineReleaseByIDExpectation + expectations []*RepositoryMockGetNamespacePipelineReleaseByIDExpectation - callArgs []*RepositoryMockGetNamespaceConnectionByIDParams + callArgs []*RepositoryMockGetNamespacePipelineReleaseByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetNamespaceConnectionByIDExpectation specifies expectation struct of the Repository.GetNamespaceConnectionByID -type RepositoryMockGetNamespaceConnectionByIDExpectation struct { +// RepositoryMockGetNamespacePipelineReleaseByIDExpectation specifies expectation struct of the Repository.GetNamespacePipelineReleaseByID +type RepositoryMockGetNamespacePipelineReleaseByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockGetNamespaceConnectionByIDParams - paramPtrs *RepositoryMockGetNamespaceConnectionByIDParamPtrs - expectationOrigins RepositoryMockGetNamespaceConnectionByIDExpectationOrigins - results *RepositoryMockGetNamespaceConnectionByIDResults + params *RepositoryMockGetNamespacePipelineReleaseByIDParams + paramPtrs *RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs + expectationOrigins RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins + results *RepositoryMockGetNamespacePipelineReleaseByIDResults returnOrigin string Counter uint64 } -// RepositoryMockGetNamespaceConnectionByIDParams contains parameters of the Repository.GetNamespaceConnectionByID -type RepositoryMockGetNamespaceConnectionByIDParams struct { - ctx context.Context - nsUID uuid.UUID - id string +// RepositoryMockGetNamespacePipelineReleaseByIDParams contains parameters of the Repository.GetNamespacePipelineReleaseByID +type RepositoryMockGetNamespacePipelineReleaseByIDParams struct { + ctx context.Context + ownerPermalink string + pipelineUID uuid.UUID + id string + isBasicView bool } -// RepositoryMockGetNamespaceConnectionByIDParamPtrs contains pointers to parameters of the Repository.GetNamespaceConnectionByID -type RepositoryMockGetNamespaceConnectionByIDParamPtrs struct { - ctx *context.Context - nsUID *uuid.UUID - id *string +// RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs contains pointers to parameters of the Repository.GetNamespacePipelineReleaseByID +type RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs struct { + ctx *context.Context + ownerPermalink *string + pipelineUID *uuid.UUID + id *string + isBasicView *bool } -// RepositoryMockGetNamespaceConnectionByIDResults contains results of the Repository.GetNamespaceConnectionByID -type RepositoryMockGetNamespaceConnectionByIDResults struct { - cp1 *datamodel.Connection +// RepositoryMockGetNamespacePipelineReleaseByIDResults contains results of the Repository.GetNamespacePipelineReleaseByID +type RepositoryMockGetNamespacePipelineReleaseByIDResults struct { + pp1 *datamodel.PipelineRelease err error } -// RepositoryMockGetNamespaceConnectionByIDOrigins contains origins of expectations of the Repository.GetNamespaceConnectionByID -type RepositoryMockGetNamespaceConnectionByIDExpectationOrigins struct { - origin string - originCtx string - originNsUID string - originId string +// RepositoryMockGetNamespacePipelineReleaseByIDOrigins contains origins of expectations of the Repository.GetNamespacePipelineReleaseByID +type RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins struct { + origin string + originCtx string + originOwnerPermalink string + originPipelineUID string + originId string + originIsBasicView string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -7521,379 +7653,429 @@ type RepositoryMockGetNamespaceConnectionByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Optional() *mRepositoryMockGetNamespaceConnectionByID { - mmGetNamespaceConnectionByID.optional = true - return mmGetNamespaceConnectionByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Optional() *mRepositoryMockGetNamespacePipelineReleaseByID { + mmGetNamespacePipelineReleaseByID.optional = true + return mmGetNamespacePipelineReleaseByID } -// Expect sets up expected params for Repository.GetNamespaceConnectionByID -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Expect(ctx context.Context, nsUID uuid.UUID, id string) *mRepositoryMockGetNamespaceConnectionByID { - if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") +// Expect sets up expected params for Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - if mmGetNamespaceConnectionByID.defaultExpectation == nil { - mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} } - if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by ExpectParams functions") + if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by ExpectParams functions") } - mmGetNamespaceConnectionByID.defaultExpectation.params = &RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id} - mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetNamespaceConnectionByID.expectations { - if minimock.Equal(e.params, mmGetNamespaceConnectionByID.defaultExpectation.params) { - mmGetNamespaceConnectionByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespaceConnectionByID.defaultExpectation.params) + mmGetNamespacePipelineReleaseByID.defaultExpectation.params = &RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView} + mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetNamespacePipelineReleaseByID.expectations { + if minimock.Equal(e.params, mmGetNamespacePipelineReleaseByID.defaultExpectation.params) { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespacePipelineReleaseByID.defaultExpectation.params) } } - return mmGetNamespaceConnectionByID + return mmGetNamespacePipelineReleaseByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespaceConnectionByID -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespaceConnectionByID { - if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - if mmGetNamespaceConnectionByID.defaultExpectation == nil { - mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} } - if mmGetNamespaceConnectionByID.defaultExpectation.params != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Expect") + if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") } - if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { - mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceConnectionByIDParamPtrs{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} } - mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetNamespaceConnectionByID + return mmGetNamespacePipelineReleaseByID } -// ExpectNsUIDParam2 sets up expected param nsUID for Repository.GetNamespaceConnectionByID -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) ExpectNsUIDParam2(nsUID uuid.UUID) *mRepositoryMockGetNamespaceConnectionByID { - if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - if mmGetNamespaceConnectionByID.defaultExpectation == nil { - mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} } - if mmGetNamespaceConnectionByID.defaultExpectation.params != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Expect") + if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") } - if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { - mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceConnectionByIDParamPtrs{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} } - mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs.nsUID = &nsUID - mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.originNsUID = minimock.CallerInfo(1) + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmGetNamespaceConnectionByID + return mmGetNamespacePipelineReleaseByID } -// ExpectIdParam3 sets up expected param id for Repository.GetNamespaceConnectionByID -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) ExpectIdParam3(id string) *mRepositoryMockGetNamespaceConnectionByID { - if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") +// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - if mmGetNamespaceConnectionByID.defaultExpectation == nil { - mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} } - if mmGetNamespaceConnectionByID.defaultExpectation.params != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Expect") + if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") } - if mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs == nil { - mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceConnectionByIDParamPtrs{} + if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} } - mmGetNamespaceConnectionByID.defaultExpectation.paramPtrs.id = &id - mmGetNamespaceConnectionByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - return mmGetNamespaceConnectionByID + return mmGetNamespacePipelineReleaseByID } -// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespaceConnectionByID -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Inspect(f func(ctx context.Context, nsUID uuid.UUID, id string)) *mRepositoryMockGetNamespaceConnectionByID { - if mmGetNamespaceConnectionByID.mock.inspectFuncGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespaceConnectionByID") +// ExpectIdParam4 sets up expected param id for Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectIdParam4(id string) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - mmGetNamespaceConnectionByID.mock.inspectFuncGetNamespaceConnectionByID = f + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + } - return mmGetNamespaceConnectionByID + if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + } + + if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + } + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.id = &id + mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + + return mmGetNamespacePipelineReleaseByID } -// Return sets up results that will be returned by Repository.GetNamespaceConnectionByID -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Return(cp1 *datamodel.Connection, err error) *RepositoryMock { - if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") +// ExpectIsBasicViewParam5 sets up expected param isBasicView for Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectIsBasicViewParam5(isBasicView bool) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - if mmGetNamespaceConnectionByID.defaultExpectation == nil { - mmGetNamespaceConnectionByID.defaultExpectation = &RepositoryMockGetNamespaceConnectionByIDExpectation{mock: mmGetNamespaceConnectionByID.mock} + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} } - mmGetNamespaceConnectionByID.defaultExpectation.results = &RepositoryMockGetNamespaceConnectionByIDResults{cp1, err} - mmGetNamespaceConnectionByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetNamespaceConnectionByID.mock + + if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + } + + if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + } + mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.isBasicView = &isBasicView + mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + + return mmGetNamespacePipelineReleaseByID } -// Set uses given function f to mock the Repository.GetNamespaceConnectionByID method -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Set(f func(ctx context.Context, nsUID uuid.UUID, id string) (cp1 *datamodel.Connection, err error)) *RepositoryMock { - if mmGetNamespaceConnectionByID.defaultExpectation != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespaceConnectionByID method") +// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool)) *mRepositoryMockGetNamespacePipelineReleaseByID { + if mmGetNamespacePipelineReleaseByID.mock.inspectFuncGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespacePipelineReleaseByID") } - if len(mmGetNamespaceConnectionByID.expectations) > 0 { - mmGetNamespaceConnectionByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespaceConnectionByID method") + mmGetNamespacePipelineReleaseByID.mock.inspectFuncGetNamespacePipelineReleaseByID = f + + return mmGetNamespacePipelineReleaseByID +} + +// Return sets up results that will be returned by Repository.GetNamespacePipelineReleaseByID +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Return(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID = f - mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByIDOrigin = minimock.CallerInfo(1) - return mmGetNamespaceConnectionByID.mock + if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { + mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{mock: mmGetNamespacePipelineReleaseByID.mock} + } + mmGetNamespacePipelineReleaseByID.defaultExpectation.results = &RepositoryMockGetNamespacePipelineReleaseByIDResults{pp1, err} + mmGetNamespacePipelineReleaseByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetNamespacePipelineReleaseByID.mock } -// When sets expectation for the Repository.GetNamespaceConnectionByID which will trigger the result defined by the following +// Set uses given function f to mock the Repository.GetNamespacePipelineReleaseByID method +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error)) *RepositoryMock { + if mmGetNamespacePipelineReleaseByID.defaultExpectation != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespacePipelineReleaseByID method") + } + + if len(mmGetNamespacePipelineReleaseByID.expectations) > 0 { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespacePipelineReleaseByID method") + } + + mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID = f + mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByIDOrigin = minimock.CallerInfo(1) + return mmGetNamespacePipelineReleaseByID.mock +} + +// When sets expectation for the Repository.GetNamespacePipelineReleaseByID which will trigger the result defined by the following // Then helper -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) When(ctx context.Context, nsUID uuid.UUID, id string) *RepositoryMockGetNamespaceConnectionByIDExpectation { - if mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.mock.t.Fatalf("RepositoryMock.GetNamespaceConnectionByID mock is already set by Set") +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) *RepositoryMockGetNamespacePipelineReleaseByIDExpectation { + if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") } - expectation := &RepositoryMockGetNamespaceConnectionByIDExpectation{ - mock: mmGetNamespaceConnectionByID.mock, - params: &RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id}, - expectationOrigins: RepositoryMockGetNamespaceConnectionByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{ + mock: mmGetNamespacePipelineReleaseByID.mock, + params: &RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView}, + expectationOrigins: RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetNamespaceConnectionByID.expectations = append(mmGetNamespaceConnectionByID.expectations, expectation) + mmGetNamespacePipelineReleaseByID.expectations = append(mmGetNamespacePipelineReleaseByID.expectations, expectation) return expectation } -// Then sets up Repository.GetNamespaceConnectionByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetNamespaceConnectionByIDExpectation) Then(cp1 *datamodel.Connection, err error) *RepositoryMock { - e.results = &RepositoryMockGetNamespaceConnectionByIDResults{cp1, err} +// Then sets up Repository.GetNamespacePipelineReleaseByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetNamespacePipelineReleaseByIDExpectation) Then(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { + e.results = &RepositoryMockGetNamespacePipelineReleaseByIDResults{pp1, err} return e.mock } -// Times sets number of times Repository.GetNamespaceConnectionByID should be invoked -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Times(n uint64) *mRepositoryMockGetNamespaceConnectionByID { +// Times sets number of times Repository.GetNamespacePipelineReleaseByID should be invoked +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Times(n uint64) *mRepositoryMockGetNamespacePipelineReleaseByID { if n == 0 { - mmGetNamespaceConnectionByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespaceConnectionByID mock can not be zero") + mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespacePipelineReleaseByID mock can not be zero") } - mm_atomic.StoreUint64(&mmGetNamespaceConnectionByID.expectedInvocations, n) - mmGetNamespaceConnectionByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetNamespaceConnectionByID + mm_atomic.StoreUint64(&mmGetNamespacePipelineReleaseByID.expectedInvocations, n) + mmGetNamespacePipelineReleaseByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetNamespacePipelineReleaseByID } -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) invocationsDone() bool { - if len(mmGetNamespaceConnectionByID.expectations) == 0 && mmGetNamespaceConnectionByID.defaultExpectation == nil && mmGetNamespaceConnectionByID.mock.funcGetNamespaceConnectionByID == nil { +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) invocationsDone() bool { + if len(mmGetNamespacePipelineReleaseByID.expectations) == 0 && mmGetNamespacePipelineReleaseByID.defaultExpectation == nil && mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.mock.afterGetNamespaceConnectionByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.mock.afterGetNamespacePipelineReleaseByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetNamespaceConnectionByID implements mm_repository.Repository -func (mmGetNamespaceConnectionByID *RepositoryMock) GetNamespaceConnectionByID(ctx context.Context, nsUID uuid.UUID, id string) (cp1 *datamodel.Connection, err error) { - mm_atomic.AddUint64(&mmGetNamespaceConnectionByID.beforeGetNamespaceConnectionByIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetNamespaceConnectionByID.afterGetNamespaceConnectionByIDCounter, 1) +// GetNamespacePipelineReleaseByID implements mm_repository.Repository +func (mmGetNamespacePipelineReleaseByID *RepositoryMock) GetNamespacePipelineReleaseByID(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error) { + mm_atomic.AddUint64(&mmGetNamespacePipelineReleaseByID.beforeGetNamespacePipelineReleaseByIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetNamespacePipelineReleaseByID.afterGetNamespacePipelineReleaseByIDCounter, 1) - mmGetNamespaceConnectionByID.t.Helper() + mmGetNamespacePipelineReleaseByID.t.Helper() - if mmGetNamespaceConnectionByID.inspectFuncGetNamespaceConnectionByID != nil { - mmGetNamespaceConnectionByID.inspectFuncGetNamespaceConnectionByID(ctx, nsUID, id) + if mmGetNamespacePipelineReleaseByID.inspectFuncGetNamespacePipelineReleaseByID != nil { + mmGetNamespacePipelineReleaseByID.inspectFuncGetNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id, isBasicView) } - mm_params := RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id} + mm_params := RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView} // Record call args - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.mutex.Lock() - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.callArgs = append(mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.callArgs, &mm_params) - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.mutex.Unlock() + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.mutex.Lock() + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.callArgs = append(mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.callArgs, &mm_params) + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.mutex.Unlock() - for _, e := range mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.expectations { + for _, e := range mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.cp1, e.results.err + return e.results.pp1, e.results.err } } - if mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.params - mm_want_ptrs := mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.paramPtrs + if mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.params + mm_want_ptrs := mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetNamespaceConnectionByIDParams{ctx, nsUID, id} + mm_got := RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.nsUID != nil && !minimock.Equal(*mm_want_ptrs.nsUID, mm_got.nsUID) { - mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameter nsUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originNsUID, *mm_want_ptrs.nsUID, mm_got.nsUID, minimock.Diff(*mm_want_ptrs.nsUID, mm_got.nsUID)) + if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { + mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + } + + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) } if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + } + + if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { + mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetNamespaceConnectionByID.t.Errorf("RepositoryMock.GetNamespaceConnectionByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetNamespaceConnectionByID.GetNamespaceConnectionByIDMock.defaultExpectation.results + mm_results := mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.results if mm_results == nil { - mmGetNamespaceConnectionByID.t.Fatal("No results are set for the RepositoryMock.GetNamespaceConnectionByID") + mmGetNamespacePipelineReleaseByID.t.Fatal("No results are set for the RepositoryMock.GetNamespacePipelineReleaseByID") } - return (*mm_results).cp1, (*mm_results).err + return (*mm_results).pp1, (*mm_results).err } - if mmGetNamespaceConnectionByID.funcGetNamespaceConnectionByID != nil { - return mmGetNamespaceConnectionByID.funcGetNamespaceConnectionByID(ctx, nsUID, id) + if mmGetNamespacePipelineReleaseByID.funcGetNamespacePipelineReleaseByID != nil { + return mmGetNamespacePipelineReleaseByID.funcGetNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id, isBasicView) } - mmGetNamespaceConnectionByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespaceConnectionByID. %v %v %v", ctx, nsUID, id) + mmGetNamespacePipelineReleaseByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespacePipelineReleaseByID. %v %v %v %v %v", ctx, ownerPermalink, pipelineUID, id, isBasicView) return } -// GetNamespaceConnectionByIDAfterCounter returns a count of finished RepositoryMock.GetNamespaceConnectionByID invocations -func (mmGetNamespaceConnectionByID *RepositoryMock) GetNamespaceConnectionByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.afterGetNamespaceConnectionByIDCounter) +// GetNamespacePipelineReleaseByIDAfterCounter returns a count of finished RepositoryMock.GetNamespacePipelineReleaseByID invocations +func (mmGetNamespacePipelineReleaseByID *RepositoryMock) GetNamespacePipelineReleaseByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.afterGetNamespacePipelineReleaseByIDCounter) } -// GetNamespaceConnectionByIDBeforeCounter returns a count of RepositoryMock.GetNamespaceConnectionByID invocations -func (mmGetNamespaceConnectionByID *RepositoryMock) GetNamespaceConnectionByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespaceConnectionByID.beforeGetNamespaceConnectionByIDCounter) +// GetNamespacePipelineReleaseByIDBeforeCounter returns a count of RepositoryMock.GetNamespacePipelineReleaseByID invocations +func (mmGetNamespacePipelineReleaseByID *RepositoryMock) GetNamespacePipelineReleaseByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.beforeGetNamespacePipelineReleaseByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespaceConnectionByID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespacePipelineReleaseByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetNamespaceConnectionByID *mRepositoryMockGetNamespaceConnectionByID) Calls() []*RepositoryMockGetNamespaceConnectionByIDParams { - mmGetNamespaceConnectionByID.mutex.RLock() +func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Calls() []*RepositoryMockGetNamespacePipelineReleaseByIDParams { + mmGetNamespacePipelineReleaseByID.mutex.RLock() - argCopy := make([]*RepositoryMockGetNamespaceConnectionByIDParams, len(mmGetNamespaceConnectionByID.callArgs)) - copy(argCopy, mmGetNamespaceConnectionByID.callArgs) + argCopy := make([]*RepositoryMockGetNamespacePipelineReleaseByIDParams, len(mmGetNamespacePipelineReleaseByID.callArgs)) + copy(argCopy, mmGetNamespacePipelineReleaseByID.callArgs) - mmGetNamespaceConnectionByID.mutex.RUnlock() + mmGetNamespacePipelineReleaseByID.mutex.RUnlock() return argCopy } -// MinimockGetNamespaceConnectionByIDDone returns true if the count of the GetNamespaceConnectionByID invocations corresponds +// MinimockGetNamespacePipelineReleaseByIDDone returns true if the count of the GetNamespacePipelineReleaseByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetNamespaceConnectionByIDDone() bool { - if m.GetNamespaceConnectionByIDMock.optional { +func (m *RepositoryMock) MinimockGetNamespacePipelineReleaseByIDDone() bool { + if m.GetNamespacePipelineReleaseByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetNamespaceConnectionByIDMock.expectations { + for _, e := range m.GetNamespacePipelineReleaseByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetNamespaceConnectionByIDMock.invocationsDone() + return m.GetNamespacePipelineReleaseByIDMock.invocationsDone() } -// MinimockGetNamespaceConnectionByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetNamespaceConnectionByIDInspect() { - for _, e := range m.GetNamespaceConnectionByIDMock.expectations { +// MinimockGetNamespacePipelineReleaseByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetNamespacePipelineReleaseByIDInspect() { + for _, e := range m.GetNamespacePipelineReleaseByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetNamespaceConnectionByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespaceConnectionByIDCounter) + afterGetNamespacePipelineReleaseByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespacePipelineReleaseByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetNamespaceConnectionByIDMock.defaultExpectation != nil && afterGetNamespaceConnectionByIDCounter < 1 { - if m.GetNamespaceConnectionByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s", m.GetNamespaceConnectionByIDMock.defaultExpectation.returnOrigin) + if m.GetNamespacePipelineReleaseByIDMock.defaultExpectation != nil && afterGetNamespacePipelineReleaseByIDCounter < 1 { + if m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s", m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s with params: %#v", m.GetNamespaceConnectionByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespaceConnectionByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s with params: %#v", m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetNamespaceConnectionByID != nil && afterGetNamespaceConnectionByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceConnectionByID at\n%s", m.funcGetNamespaceConnectionByIDOrigin) + if m.funcGetNamespacePipelineReleaseByID != nil && afterGetNamespacePipelineReleaseByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s", m.funcGetNamespacePipelineReleaseByIDOrigin) } - if !m.GetNamespaceConnectionByIDMock.invocationsDone() && afterGetNamespaceConnectionByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespaceConnectionByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetNamespaceConnectionByIDMock.expectedInvocations), m.GetNamespaceConnectionByIDMock.expectedInvocationsOrigin, afterGetNamespaceConnectionByIDCounter) + if !m.GetNamespacePipelineReleaseByIDMock.invocationsDone() && afterGetNamespacePipelineReleaseByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetNamespacePipelineReleaseByIDMock.expectedInvocations), m.GetNamespacePipelineReleaseByIDMock.expectedInvocationsOrigin, afterGetNamespacePipelineReleaseByIDCounter) } } -type mRepositoryMockGetNamespacePipelineByID struct { +type mRepositoryMockGetNamespaceSecretByID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetNamespacePipelineByIDExpectation - expectations []*RepositoryMockGetNamespacePipelineByIDExpectation + defaultExpectation *RepositoryMockGetNamespaceSecretByIDExpectation + expectations []*RepositoryMockGetNamespaceSecretByIDExpectation - callArgs []*RepositoryMockGetNamespacePipelineByIDParams + callArgs []*RepositoryMockGetNamespaceSecretByIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetNamespacePipelineByIDExpectation specifies expectation struct of the Repository.GetNamespacePipelineByID -type RepositoryMockGetNamespacePipelineByIDExpectation struct { +// RepositoryMockGetNamespaceSecretByIDExpectation specifies expectation struct of the Repository.GetNamespaceSecretByID +type RepositoryMockGetNamespaceSecretByIDExpectation struct { mock *RepositoryMock - params *RepositoryMockGetNamespacePipelineByIDParams - paramPtrs *RepositoryMockGetNamespacePipelineByIDParamPtrs - expectationOrigins RepositoryMockGetNamespacePipelineByIDExpectationOrigins - results *RepositoryMockGetNamespacePipelineByIDResults + params *RepositoryMockGetNamespaceSecretByIDParams + paramPtrs *RepositoryMockGetNamespaceSecretByIDParamPtrs + expectationOrigins RepositoryMockGetNamespaceSecretByIDExpectationOrigins + results *RepositoryMockGetNamespaceSecretByIDResults returnOrigin string Counter uint64 } -// RepositoryMockGetNamespacePipelineByIDParams contains parameters of the Repository.GetNamespacePipelineByID -type RepositoryMockGetNamespacePipelineByIDParams struct { +// RepositoryMockGetNamespaceSecretByIDParams contains parameters of the Repository.GetNamespaceSecretByID +type RepositoryMockGetNamespaceSecretByIDParams struct { ctx context.Context ownerPermalink string id string - isBasicView bool - embedReleases bool } -// RepositoryMockGetNamespacePipelineByIDParamPtrs contains pointers to parameters of the Repository.GetNamespacePipelineByID -type RepositoryMockGetNamespacePipelineByIDParamPtrs struct { +// RepositoryMockGetNamespaceSecretByIDParamPtrs contains pointers to parameters of the Repository.GetNamespaceSecretByID +type RepositoryMockGetNamespaceSecretByIDParamPtrs struct { ctx *context.Context ownerPermalink *string id *string - isBasicView *bool - embedReleases *bool } -// RepositoryMockGetNamespacePipelineByIDResults contains results of the Repository.GetNamespacePipelineByID -type RepositoryMockGetNamespacePipelineByIDResults struct { - pp1 *datamodel.Pipeline +// RepositoryMockGetNamespaceSecretByIDResults contains results of the Repository.GetNamespaceSecretByID +type RepositoryMockGetNamespaceSecretByIDResults struct { + sp1 *datamodel.Secret err error } -// RepositoryMockGetNamespacePipelineByIDOrigins contains origins of expectations of the Repository.GetNamespacePipelineByID -type RepositoryMockGetNamespacePipelineByIDExpectationOrigins struct { +// RepositoryMockGetNamespaceSecretByIDOrigins contains origins of expectations of the Repository.GetNamespaceSecretByID +type RepositoryMockGetNamespaceSecretByIDExpectationOrigins struct { origin string originCtx string originOwnerPermalink string originId string - originIsBasicView string - originEmbedReleases string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -7901,435 +8083,383 @@ type RepositoryMockGetNamespacePipelineByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Optional() *mRepositoryMockGetNamespacePipelineByID { - mmGetNamespacePipelineByID.optional = true - return mmGetNamespacePipelineByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Optional() *mRepositoryMockGetNamespaceSecretByID { + mmGetNamespaceSecretByID.optional = true + return mmGetNamespaceSecretByID } -// Expect sets up expected params for Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Expect(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") +// Expect sets up expected params for Repository.GetNamespaceSecretByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Expect(ctx context.Context, ownerPermalink string, id string) *mRepositoryMockGetNamespaceSecretByID { + if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") } - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} + if mmGetNamespaceSecretByID.defaultExpectation == nil { + mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} } - if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by ExpectParams functions") + if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by ExpectParams functions") } - mmGetNamespacePipelineByID.defaultExpectation.params = &RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases} - mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetNamespacePipelineByID.expectations { - if minimock.Equal(e.params, mmGetNamespacePipelineByID.defaultExpectation.params) { - mmGetNamespacePipelineByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespacePipelineByID.defaultExpectation.params) + mmGetNamespaceSecretByID.defaultExpectation.params = &RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id} + mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetNamespaceSecretByID.expectations { + if minimock.Equal(e.params, mmGetNamespaceSecretByID.defaultExpectation.params) { + mmGetNamespaceSecretByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespaceSecretByID.defaultExpectation.params) } } - return mmGetNamespacePipelineByID + return mmGetNamespaceSecretByID } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespaceSecretByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespaceSecretByID { + if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") } - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} + if mmGetNamespaceSecretByID.defaultExpectation == nil { + mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} } - if mmGetNamespacePipelineByID.defaultExpectation.params != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") + if mmGetNamespaceSecretByID.defaultExpectation.params != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Expect") } - if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} + if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs == nil { + mmGetNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceSecretByIDParamPtrs{} } - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetNamespaceSecretByID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetNamespacePipelineByID + return mmGetNamespaceSecretByID } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") +// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetNamespaceSecretByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetNamespaceSecretByID { + if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") } - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} + if mmGetNamespaceSecretByID.defaultExpectation == nil { + mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} } - if mmGetNamespacePipelineByID.defaultExpectation.params != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") + if mmGetNamespaceSecretByID.defaultExpectation.params != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Expect") } - if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} + if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs == nil { + mmGetNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceSecretByIDParamPtrs{} } - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmGetNamespaceSecretByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink + mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) - return mmGetNamespacePipelineByID + return mmGetNamespaceSecretByID } -// ExpectIdParam3 sets up expected param id for Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectIdParam3(id string) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") - } - - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} - } - - if mmGetNamespacePipelineByID.defaultExpectation.params != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") - } - - if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} - } - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.id = &id - mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) - - return mmGetNamespacePipelineByID -} - -// ExpectIsBasicViewParam4 sets up expected param isBasicView for Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectIsBasicViewParam4(isBasicView bool) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") - } - - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} - } - - if mmGetNamespacePipelineByID.defaultExpectation.params != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") - } - - if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} - } - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.isBasicView = &isBasicView - mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) - - return mmGetNamespacePipelineByID -} - -// ExpectEmbedReleasesParam5 sets up expected param embedReleases for Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) ExpectEmbedReleasesParam5(embedReleases bool) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") +// ExpectIdParam3 sets up expected param id for Repository.GetNamespaceSecretByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) ExpectIdParam3(id string) *mRepositoryMockGetNamespaceSecretByID { + if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") } - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{} + if mmGetNamespaceSecretByID.defaultExpectation == nil { + mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} } - if mmGetNamespacePipelineByID.defaultExpectation.params != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Expect") + if mmGetNamespaceSecretByID.defaultExpectation.params != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Expect") } - if mmGetNamespacePipelineByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineByIDParamPtrs{} + if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs == nil { + mmGetNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceSecretByIDParamPtrs{} } - mmGetNamespacePipelineByID.defaultExpectation.paramPtrs.embedReleases = &embedReleases - mmGetNamespacePipelineByID.defaultExpectation.expectationOrigins.originEmbedReleases = minimock.CallerInfo(1) + mmGetNamespaceSecretByID.defaultExpectation.paramPtrs.id = &id + mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) - return mmGetNamespacePipelineByID + return mmGetNamespaceSecretByID } -// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool)) *mRepositoryMockGetNamespacePipelineByID { - if mmGetNamespacePipelineByID.mock.inspectFuncGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespacePipelineByID") +// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespaceSecretByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string)) *mRepositoryMockGetNamespaceSecretByID { + if mmGetNamespaceSecretByID.mock.inspectFuncGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespaceSecretByID") } - mmGetNamespacePipelineByID.mock.inspectFuncGetNamespacePipelineByID = f + mmGetNamespaceSecretByID.mock.inspectFuncGetNamespaceSecretByID = f - return mmGetNamespacePipelineByID + return mmGetNamespaceSecretByID } -// Return sets up results that will be returned by Repository.GetNamespacePipelineByID -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Return(pp1 *datamodel.Pipeline, err error) *RepositoryMock { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") +// Return sets up results that will be returned by Repository.GetNamespaceSecretByID +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Return(sp1 *datamodel.Secret, err error) *RepositoryMock { + if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") } - if mmGetNamespacePipelineByID.defaultExpectation == nil { - mmGetNamespacePipelineByID.defaultExpectation = &RepositoryMockGetNamespacePipelineByIDExpectation{mock: mmGetNamespacePipelineByID.mock} + if mmGetNamespaceSecretByID.defaultExpectation == nil { + mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{mock: mmGetNamespaceSecretByID.mock} } - mmGetNamespacePipelineByID.defaultExpectation.results = &RepositoryMockGetNamespacePipelineByIDResults{pp1, err} - mmGetNamespacePipelineByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetNamespacePipelineByID.mock + mmGetNamespaceSecretByID.defaultExpectation.results = &RepositoryMockGetNamespaceSecretByIDResults{sp1, err} + mmGetNamespaceSecretByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetNamespaceSecretByID.mock } -// Set uses given function f to mock the Repository.GetNamespacePipelineByID method -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Set(f func(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error)) *RepositoryMock { - if mmGetNamespacePipelineByID.defaultExpectation != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespacePipelineByID method") +// Set uses given function f to mock the Repository.GetNamespaceSecretByID method +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Set(f func(ctx context.Context, ownerPermalink string, id string) (sp1 *datamodel.Secret, err error)) *RepositoryMock { + if mmGetNamespaceSecretByID.defaultExpectation != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespaceSecretByID method") } - if len(mmGetNamespacePipelineByID.expectations) > 0 { - mmGetNamespacePipelineByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespacePipelineByID method") + if len(mmGetNamespaceSecretByID.expectations) > 0 { + mmGetNamespaceSecretByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespaceSecretByID method") } - mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID = f - mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByIDOrigin = minimock.CallerInfo(1) - return mmGetNamespacePipelineByID.mock + mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID = f + mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByIDOrigin = minimock.CallerInfo(1) + return mmGetNamespaceSecretByID.mock } -// When sets expectation for the Repository.GetNamespacePipelineByID which will trigger the result defined by the following +// When sets expectation for the Repository.GetNamespaceSecretByID which will trigger the result defined by the following // Then helper -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) When(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) *RepositoryMockGetNamespacePipelineByIDExpectation { - if mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineByID mock is already set by Set") +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) When(ctx context.Context, ownerPermalink string, id string) *RepositoryMockGetNamespaceSecretByIDExpectation { + if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") } - expectation := &RepositoryMockGetNamespacePipelineByIDExpectation{ - mock: mmGetNamespacePipelineByID.mock, - params: &RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases}, - expectationOrigins: RepositoryMockGetNamespacePipelineByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetNamespaceSecretByIDExpectation{ + mock: mmGetNamespaceSecretByID.mock, + params: &RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id}, + expectationOrigins: RepositoryMockGetNamespaceSecretByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetNamespacePipelineByID.expectations = append(mmGetNamespacePipelineByID.expectations, expectation) + mmGetNamespaceSecretByID.expectations = append(mmGetNamespaceSecretByID.expectations, expectation) return expectation } -// Then sets up Repository.GetNamespacePipelineByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetNamespacePipelineByIDExpectation) Then(pp1 *datamodel.Pipeline, err error) *RepositoryMock { - e.results = &RepositoryMockGetNamespacePipelineByIDResults{pp1, err} +// Then sets up Repository.GetNamespaceSecretByID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetNamespaceSecretByIDExpectation) Then(sp1 *datamodel.Secret, err error) *RepositoryMock { + e.results = &RepositoryMockGetNamespaceSecretByIDResults{sp1, err} return e.mock } -// Times sets number of times Repository.GetNamespacePipelineByID should be invoked -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Times(n uint64) *mRepositoryMockGetNamespacePipelineByID { +// Times sets number of times Repository.GetNamespaceSecretByID should be invoked +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Times(n uint64) *mRepositoryMockGetNamespaceSecretByID { if n == 0 { - mmGetNamespacePipelineByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespacePipelineByID mock can not be zero") + mmGetNamespaceSecretByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespaceSecretByID mock can not be zero") } - mm_atomic.StoreUint64(&mmGetNamespacePipelineByID.expectedInvocations, n) - mmGetNamespacePipelineByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetNamespacePipelineByID + mm_atomic.StoreUint64(&mmGetNamespaceSecretByID.expectedInvocations, n) + mmGetNamespaceSecretByID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetNamespaceSecretByID } -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) invocationsDone() bool { - if len(mmGetNamespacePipelineByID.expectations) == 0 && mmGetNamespacePipelineByID.defaultExpectation == nil && mmGetNamespacePipelineByID.mock.funcGetNamespacePipelineByID == nil { +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) invocationsDone() bool { + if len(mmGetNamespaceSecretByID.expectations) == 0 && mmGetNamespaceSecretByID.defaultExpectation == nil && mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.mock.afterGetNamespacePipelineByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.mock.afterGetNamespaceSecretByIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetNamespacePipelineByID implements mm_repository.Repository -func (mmGetNamespacePipelineByID *RepositoryMock) GetNamespacePipelineByID(ctx context.Context, ownerPermalink string, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error) { - mm_atomic.AddUint64(&mmGetNamespacePipelineByID.beforeGetNamespacePipelineByIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetNamespacePipelineByID.afterGetNamespacePipelineByIDCounter, 1) +// GetNamespaceSecretByID implements mm_repository.Repository +func (mmGetNamespaceSecretByID *RepositoryMock) GetNamespaceSecretByID(ctx context.Context, ownerPermalink string, id string) (sp1 *datamodel.Secret, err error) { + mm_atomic.AddUint64(&mmGetNamespaceSecretByID.beforeGetNamespaceSecretByIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetNamespaceSecretByID.afterGetNamespaceSecretByIDCounter, 1) - mmGetNamespacePipelineByID.t.Helper() + mmGetNamespaceSecretByID.t.Helper() - if mmGetNamespacePipelineByID.inspectFuncGetNamespacePipelineByID != nil { - mmGetNamespacePipelineByID.inspectFuncGetNamespacePipelineByID(ctx, ownerPermalink, id, isBasicView, embedReleases) + if mmGetNamespaceSecretByID.inspectFuncGetNamespaceSecretByID != nil { + mmGetNamespaceSecretByID.inspectFuncGetNamespaceSecretByID(ctx, ownerPermalink, id) } - mm_params := RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases} + mm_params := RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id} // Record call args - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.mutex.Lock() - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.callArgs = append(mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.callArgs, &mm_params) - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.mutex.Unlock() + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.mutex.Lock() + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.callArgs = append(mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.callArgs, &mm_params) + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.mutex.Unlock() - for _, e := range mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.expectations { + for _, e := range mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.pp1, e.results.err + return e.results.sp1, e.results.err } } - if mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.params - mm_want_ptrs := mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.paramPtrs + if mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.params + mm_want_ptrs := mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetNamespacePipelineByIDParams{ctx, ownerPermalink, id, isBasicView, embedReleases} + mm_got := RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) } if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) - } - - if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { - mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) - } - - if mm_want_ptrs.embedReleases != nil && !minimock.Equal(*mm_want_ptrs.embedReleases, mm_got.embedReleases) { - mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameter embedReleases, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.originEmbedReleases, *mm_want_ptrs.embedReleases, mm_got.embedReleases, minimock.Diff(*mm_want_ptrs.embedReleases, mm_got.embedReleases)) + mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetNamespacePipelineByID.t.Errorf("RepositoryMock.GetNamespacePipelineByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetNamespacePipelineByID.GetNamespacePipelineByIDMock.defaultExpectation.results + mm_results := mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.results if mm_results == nil { - mmGetNamespacePipelineByID.t.Fatal("No results are set for the RepositoryMock.GetNamespacePipelineByID") + mmGetNamespaceSecretByID.t.Fatal("No results are set for the RepositoryMock.GetNamespaceSecretByID") } - return (*mm_results).pp1, (*mm_results).err + return (*mm_results).sp1, (*mm_results).err } - if mmGetNamespacePipelineByID.funcGetNamespacePipelineByID != nil { - return mmGetNamespacePipelineByID.funcGetNamespacePipelineByID(ctx, ownerPermalink, id, isBasicView, embedReleases) + if mmGetNamespaceSecretByID.funcGetNamespaceSecretByID != nil { + return mmGetNamespaceSecretByID.funcGetNamespaceSecretByID(ctx, ownerPermalink, id) } - mmGetNamespacePipelineByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespacePipelineByID. %v %v %v %v %v", ctx, ownerPermalink, id, isBasicView, embedReleases) + mmGetNamespaceSecretByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespaceSecretByID. %v %v %v", ctx, ownerPermalink, id) return } -// GetNamespacePipelineByIDAfterCounter returns a count of finished RepositoryMock.GetNamespacePipelineByID invocations -func (mmGetNamespacePipelineByID *RepositoryMock) GetNamespacePipelineByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.afterGetNamespacePipelineByIDCounter) +// GetNamespaceSecretByIDAfterCounter returns a count of finished RepositoryMock.GetNamespaceSecretByID invocations +func (mmGetNamespaceSecretByID *RepositoryMock) GetNamespaceSecretByIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.afterGetNamespaceSecretByIDCounter) } -// GetNamespacePipelineByIDBeforeCounter returns a count of RepositoryMock.GetNamespacePipelineByID invocations -func (mmGetNamespacePipelineByID *RepositoryMock) GetNamespacePipelineByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespacePipelineByID.beforeGetNamespacePipelineByIDCounter) +// GetNamespaceSecretByIDBeforeCounter returns a count of RepositoryMock.GetNamespaceSecretByID invocations +func (mmGetNamespaceSecretByID *RepositoryMock) GetNamespaceSecretByIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.beforeGetNamespaceSecretByIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespacePipelineByID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespaceSecretByID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetNamespacePipelineByID *mRepositoryMockGetNamespacePipelineByID) Calls() []*RepositoryMockGetNamespacePipelineByIDParams { - mmGetNamespacePipelineByID.mutex.RLock() - - argCopy := make([]*RepositoryMockGetNamespacePipelineByIDParams, len(mmGetNamespacePipelineByID.callArgs)) - copy(argCopy, mmGetNamespacePipelineByID.callArgs) +func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Calls() []*RepositoryMockGetNamespaceSecretByIDParams { + mmGetNamespaceSecretByID.mutex.RLock() - mmGetNamespacePipelineByID.mutex.RUnlock() + argCopy := make([]*RepositoryMockGetNamespaceSecretByIDParams, len(mmGetNamespaceSecretByID.callArgs)) + copy(argCopy, mmGetNamespaceSecretByID.callArgs) + + mmGetNamespaceSecretByID.mutex.RUnlock() return argCopy } -// MinimockGetNamespacePipelineByIDDone returns true if the count of the GetNamespacePipelineByID invocations corresponds +// MinimockGetNamespaceSecretByIDDone returns true if the count of the GetNamespaceSecretByID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetNamespacePipelineByIDDone() bool { - if m.GetNamespacePipelineByIDMock.optional { +func (m *RepositoryMock) MinimockGetNamespaceSecretByIDDone() bool { + if m.GetNamespaceSecretByIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetNamespacePipelineByIDMock.expectations { + for _, e := range m.GetNamespaceSecretByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetNamespacePipelineByIDMock.invocationsDone() + return m.GetNamespaceSecretByIDMock.invocationsDone() } -// MinimockGetNamespacePipelineByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetNamespacePipelineByIDInspect() { - for _, e := range m.GetNamespacePipelineByIDMock.expectations { +// MinimockGetNamespaceSecretByIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetNamespaceSecretByIDInspect() { + for _, e := range m.GetNamespaceSecretByIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetNamespacePipelineByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespacePipelineByIDCounter) + afterGetNamespaceSecretByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespaceSecretByIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetNamespacePipelineByIDMock.defaultExpectation != nil && afterGetNamespacePipelineByIDCounter < 1 { - if m.GetNamespacePipelineByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s", m.GetNamespacePipelineByIDMock.defaultExpectation.returnOrigin) + if m.GetNamespaceSecretByIDMock.defaultExpectation != nil && afterGetNamespaceSecretByIDCounter < 1 { + if m.GetNamespaceSecretByIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s", m.GetNamespaceSecretByIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s with params: %#v", m.GetNamespacePipelineByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespacePipelineByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s with params: %#v", m.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespaceSecretByIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetNamespacePipelineByID != nil && afterGetNamespacePipelineByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineByID at\n%s", m.funcGetNamespacePipelineByIDOrigin) + if m.funcGetNamespaceSecretByID != nil && afterGetNamespaceSecretByIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s", m.funcGetNamespaceSecretByIDOrigin) } - if !m.GetNamespacePipelineByIDMock.invocationsDone() && afterGetNamespacePipelineByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespacePipelineByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetNamespacePipelineByIDMock.expectedInvocations), m.GetNamespacePipelineByIDMock.expectedInvocationsOrigin, afterGetNamespacePipelineByIDCounter) + if !m.GetNamespaceSecretByIDMock.invocationsDone() && afterGetNamespaceSecretByIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespaceSecretByID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetNamespaceSecretByIDMock.expectedInvocations), m.GetNamespaceSecretByIDMock.expectedInvocationsOrigin, afterGetNamespaceSecretByIDCounter) } } -type mRepositoryMockGetNamespacePipelineReleaseByID struct { +type mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetNamespacePipelineReleaseByIDExpectation - expectations []*RepositoryMockGetNamespacePipelineReleaseByIDExpectation + defaultExpectation *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation + expectations []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation - callArgs []*RepositoryMockGetNamespacePipelineReleaseByIDParams + callArgs []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetNamespacePipelineReleaseByIDExpectation specifies expectation struct of the Repository.GetNamespacePipelineReleaseByID -type RepositoryMockGetNamespacePipelineReleaseByIDExpectation struct { +// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation specifies expectation struct of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation struct { mock *RepositoryMock - params *RepositoryMockGetNamespacePipelineReleaseByIDParams - paramPtrs *RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs - expectationOrigins RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins - results *RepositoryMockGetNamespacePipelineReleaseByIDResults + params *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams + paramPtrs *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs + expectationOrigins RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectationOrigins + results *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults returnOrigin string Counter uint64 } -// RepositoryMockGetNamespacePipelineReleaseByIDParams contains parameters of the Repository.GetNamespacePipelineReleaseByID -type RepositoryMockGetNamespacePipelineReleaseByIDParams struct { - ctx context.Context - ownerPermalink string - pipelineUID uuid.UUID - id string - isBasicView bool +// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams contains parameters of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams struct { + ctx context.Context + pipelineRunID string + page int + pageSize int + filter filtering.Filter + order ordering.OrderBy } -// RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs contains pointers to parameters of the Repository.GetNamespacePipelineReleaseByID -type RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs struct { - ctx *context.Context - ownerPermalink *string - pipelineUID *uuid.UUID - id *string - isBasicView *bool +// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs contains pointers to parameters of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs struct { + ctx *context.Context + pipelineRunID *string + page *int + pageSize *int + filter *filtering.Filter + order *ordering.OrderBy } -// RepositoryMockGetNamespacePipelineReleaseByIDResults contains results of the Repository.GetNamespacePipelineReleaseByID -type RepositoryMockGetNamespacePipelineReleaseByIDResults struct { - pp1 *datamodel.PipelineRelease +// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults contains results of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults struct { + ca1 []datamodel.ComponentRun + i1 int64 err error } -// RepositoryMockGetNamespacePipelineReleaseByIDOrigins contains origins of expectations of the Repository.GetNamespacePipelineReleaseByID -type RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins struct { - origin string - originCtx string - originOwnerPermalink string - originPipelineUID string - originId string - originIsBasicView string +// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsOrigins contains origins of expectations of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectationOrigins struct { + origin string + originCtx string + originPipelineRunID string + originPage string + originPageSize string + originFilter string + originOrder string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -8337,429 +8467,455 @@ type RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Optional() *mRepositoryMockGetNamespacePipelineReleaseByID { - mmGetNamespacePipelineReleaseByID.optional = true - return mmGetNamespacePipelineReleaseByID +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Optional() *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.optional = true + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// Expect sets up expected params for Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Expect(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// Expect sets up expected params for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Expect(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by ExpectParams functions") + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by ExpectParams functions") } - mmGetNamespacePipelineReleaseByID.defaultExpectation.params = &RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView} - mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetNamespacePipelineReleaseByID.expectations { - if minimock.Equal(e.params, mmGetNamespacePipelineReleaseByID.defaultExpectation.params) { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespacePipelineReleaseByID.defaultExpectation.params) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order} + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations { + if minimock.Equal(e.params, mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params) { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params) } } - return mmGetNamespacePipelineReleaseByID + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} } - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// ExpectPipelineRunIDParam2 sets up expected param pipelineRunID for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectPipelineRunIDParam2(pipelineRunID string) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} } - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.pipelineRunID = &pipelineRunID + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originPipelineRunID = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectPipelineUIDParam3(pipelineUID uuid.UUID) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// ExpectPageParam3 sets up expected param page for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectPageParam3(page int) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} } - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.page = &page + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originPage = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// ExpectIdParam4 sets up expected param id for Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectIdParam4(id string) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// ExpectPageSizeParam4 sets up expected param pageSize for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectPageSizeParam4(pageSize int) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} } - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.id = &id - mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.pageSize = &pageSize + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originPageSize = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// ExpectIsBasicViewParam5 sets up expected param isBasicView for Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) ExpectIsBasicViewParam5(isBasicView bool) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// ExpectFilterParam5 sets up expected param filter for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectFilterParam5(filter filtering.Filter) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.params != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Expect") + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespacePipelineReleaseByIDParamPtrs{} + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} } - mmGetNamespacePipelineReleaseByID.defaultExpectation.paramPtrs.isBasicView = &isBasicView - mmGetNamespacePipelineReleaseByID.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.filter = &filter + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originFilter = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Inspect(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool)) *mRepositoryMockGetNamespacePipelineReleaseByID { - if mmGetNamespacePipelineReleaseByID.mock.inspectFuncGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespacePipelineReleaseByID") +// ExpectOrderParam6 sets up expected param order for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectOrderParam6(order ordering.OrderBy) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - mmGetNamespacePipelineReleaseByID.mock.inspectFuncGetNamespacePipelineReleaseByID = f + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + } - return mmGetNamespacePipelineReleaseByID + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + } + + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + } + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.order = &order + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originOrder = minimock.CallerInfo(1) + + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -// Return sets up results that will be returned by Repository.GetNamespacePipelineReleaseByID -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Return(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Inspect(f func(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy)) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions") } - if mmGetNamespacePipelineReleaseByID.defaultExpectation == nil { - mmGetNamespacePipelineReleaseByID.defaultExpectation = &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{mock: mmGetNamespacePipelineReleaseByID.mock} + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions = f + + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions +} + +// Return sets up results that will be returned by Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Return(ca1 []datamodel.ComponentRun, i1 int64, err error) *RepositoryMock { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - mmGetNamespacePipelineReleaseByID.defaultExpectation.results = &RepositoryMockGetNamespacePipelineReleaseByIDResults{pp1, err} - mmGetNamespacePipelineReleaseByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID.mock + + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{mock: mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock} + } + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.results = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults{ca1, i1, err} + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock } -// Set uses given function f to mock the Repository.GetNamespacePipelineReleaseByID method -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Set(f func(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error)) *RepositoryMock { - if mmGetNamespacePipelineReleaseByID.defaultExpectation != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespacePipelineReleaseByID method") +// Set uses given function f to mock the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions method +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Set(f func(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (ca1 []datamodel.ComponentRun, i1 int64, err error)) *RepositoryMock { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions method") } - if len(mmGetNamespacePipelineReleaseByID.expectations) > 0 { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespacePipelineReleaseByID method") + if len(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations) > 0 { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions method") } - mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID = f - mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByIDOrigin = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID.mock + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions = f + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissionsOrigin = minimock.CallerInfo(1) + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock } -// When sets expectation for the Repository.GetNamespacePipelineReleaseByID which will trigger the result defined by the following +// When sets expectation for the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions which will trigger the result defined by the following // Then helper -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) When(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) *RepositoryMockGetNamespacePipelineReleaseByIDExpectation { - if mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("RepositoryMock.GetNamespacePipelineReleaseByID mock is already set by Set") +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) When(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation { + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") } - expectation := &RepositoryMockGetNamespacePipelineReleaseByIDExpectation{ - mock: mmGetNamespacePipelineReleaseByID.mock, - params: &RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView}, - expectationOrigins: RepositoryMockGetNamespacePipelineReleaseByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{ + mock: mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock, + params: &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order}, + expectationOrigins: RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetNamespacePipelineReleaseByID.expectations = append(mmGetNamespacePipelineReleaseByID.expectations, expectation) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations = append(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations, expectation) return expectation } -// Then sets up Repository.GetNamespacePipelineReleaseByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetNamespacePipelineReleaseByIDExpectation) Then(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { - e.results = &RepositoryMockGetNamespacePipelineReleaseByIDResults{pp1, err} +// Then sets up Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation) Then(ca1 []datamodel.ComponentRun, i1 int64, err error) *RepositoryMock { + e.results = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults{ca1, i1, err} return e.mock } -// Times sets number of times Repository.GetNamespacePipelineReleaseByID should be invoked -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Times(n uint64) *mRepositoryMockGetNamespacePipelineReleaseByID { +// Times sets number of times Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions should be invoked +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Times(n uint64) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { if n == 0 { - mmGetNamespacePipelineReleaseByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespacePipelineReleaseByID mock can not be zero") + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock can not be zero") } - mm_atomic.StoreUint64(&mmGetNamespacePipelineReleaseByID.expectedInvocations, n) - mmGetNamespacePipelineReleaseByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetNamespacePipelineReleaseByID + mm_atomic.StoreUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectedInvocations, n) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions } -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) invocationsDone() bool { - if len(mmGetNamespacePipelineReleaseByID.expectations) == 0 && mmGetNamespacePipelineReleaseByID.defaultExpectation == nil && mmGetNamespacePipelineReleaseByID.mock.funcGetNamespacePipelineReleaseByID == nil { +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) invocationsDone() bool { + if len(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations) == 0 && mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil && mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.mock.afterGetNamespacePipelineReleaseByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetNamespacePipelineReleaseByID implements mm_repository.Repository -func (mmGetNamespacePipelineReleaseByID *RepositoryMock) GetNamespacePipelineReleaseByID(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, id string, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error) { - mm_atomic.AddUint64(&mmGetNamespacePipelineReleaseByID.beforeGetNamespacePipelineReleaseByIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetNamespacePipelineReleaseByID.afterGetNamespacePipelineReleaseByIDCounter, 1) +// GetPaginatedComponentRunsByPipelineRunIDWithPermissions implements mm_repository.Repository +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *RepositoryMock) GetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (ca1 []datamodel.ComponentRun, i1 int64, err error) { + mm_atomic.AddUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.beforeGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter, 1) + defer mm_atomic.AddUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter, 1) - mmGetNamespacePipelineReleaseByID.t.Helper() + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Helper() - if mmGetNamespacePipelineReleaseByID.inspectFuncGetNamespacePipelineReleaseByID != nil { - mmGetNamespacePipelineReleaseByID.inspectFuncGetNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id, isBasicView) + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx, pipelineRunID, page, pageSize, filter, order) } - mm_params := RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView} + mm_params := RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order} // Record call args - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.mutex.Lock() - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.callArgs = append(mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.callArgs, &mm_params) - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.mutex.Unlock() + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.mutex.Lock() + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.callArgs = append(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.callArgs, &mm_params) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.mutex.Unlock() - for _, e := range mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.expectations { + for _, e := range mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.pp1, e.results.err + return e.results.ca1, e.results.i1, e.results.err } } - if mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.params - mm_want_ptrs := mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.paramPtrs + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.Counter, 1) + mm_want := mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.params + mm_want_ptrs := mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetNamespacePipelineReleaseByIDParams{ctx, ownerPermalink, pipelineUID, id, isBasicView} + mm_got := RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + if mm_want_ptrs.pipelineRunID != nil && !minimock.Equal(*mm_want_ptrs.pipelineRunID, mm_got.pipelineRunID) { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter pipelineRunID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originPipelineRunID, *mm_want_ptrs.pipelineRunID, mm_got.pipelineRunID, minimock.Diff(*mm_want_ptrs.pipelineRunID, mm_got.pipelineRunID)) } - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) + if mm_want_ptrs.page != nil && !minimock.Equal(*mm_want_ptrs.page, mm_got.page) { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter page, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originPage, *mm_want_ptrs.page, mm_got.page, minimock.Diff(*mm_want_ptrs.page, mm_got.page)) } - if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + if mm_want_ptrs.pageSize != nil && !minimock.Equal(*mm_want_ptrs.pageSize, mm_got.pageSize) { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter pageSize, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originPageSize, *mm_want_ptrs.pageSize, mm_got.pageSize, minimock.Diff(*mm_want_ptrs.pageSize, mm_got.pageSize)) } - if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { - mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) + if mm_want_ptrs.filter != nil && !minimock.Equal(*mm_want_ptrs.filter, mm_got.filter) { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter filter, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originFilter, *mm_want_ptrs.filter, mm_got.filter, minimock.Diff(*mm_want_ptrs.filter, mm_got.filter)) + } + + if mm_want_ptrs.order != nil && !minimock.Equal(*mm_want_ptrs.order, mm_got.order) { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter order, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originOrder, *mm_want_ptrs.order, mm_got.order, minimock.Diff(*mm_want_ptrs.order, mm_got.order)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetNamespacePipelineReleaseByID.t.Errorf("RepositoryMock.GetNamespacePipelineReleaseByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetNamespacePipelineReleaseByID.GetNamespacePipelineReleaseByIDMock.defaultExpectation.results + mm_results := mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.results if mm_results == nil { - mmGetNamespacePipelineReleaseByID.t.Fatal("No results are set for the RepositoryMock.GetNamespacePipelineReleaseByID") + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Fatal("No results are set for the RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions") } - return (*mm_results).pp1, (*mm_results).err + return (*mm_results).ca1, (*mm_results).i1, (*mm_results).err } - if mmGetNamespacePipelineReleaseByID.funcGetNamespacePipelineReleaseByID != nil { - return mmGetNamespacePipelineReleaseByID.funcGetNamespacePipelineReleaseByID(ctx, ownerPermalink, pipelineUID, id, isBasicView) + if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { + return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx, pipelineRunID, page, pageSize, filter, order) } - mmGetNamespacePipelineReleaseByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespacePipelineReleaseByID. %v %v %v %v %v", ctx, ownerPermalink, pipelineUID, id, isBasicView) + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions. %v %v %v %v %v %v", ctx, pipelineRunID, page, pageSize, filter, order) return } -// GetNamespacePipelineReleaseByIDAfterCounter returns a count of finished RepositoryMock.GetNamespacePipelineReleaseByID invocations -func (mmGetNamespacePipelineReleaseByID *RepositoryMock) GetNamespacePipelineReleaseByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.afterGetNamespacePipelineReleaseByIDCounter) +// GetPaginatedComponentRunsByPipelineRunIDWithPermissionsAfterCounter returns a count of finished RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions invocations +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *RepositoryMock) GetPaginatedComponentRunsByPipelineRunIDWithPermissionsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) } -// GetNamespacePipelineReleaseByIDBeforeCounter returns a count of RepositoryMock.GetNamespacePipelineReleaseByID invocations -func (mmGetNamespacePipelineReleaseByID *RepositoryMock) GetNamespacePipelineReleaseByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespacePipelineReleaseByID.beforeGetNamespacePipelineReleaseByIDCounter) +// GetPaginatedComponentRunsByPipelineRunIDWithPermissionsBeforeCounter returns a count of RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions invocations +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *RepositoryMock) GetPaginatedComponentRunsByPipelineRunIDWithPermissionsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.beforeGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespacePipelineReleaseByID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetNamespacePipelineReleaseByID *mRepositoryMockGetNamespacePipelineReleaseByID) Calls() []*RepositoryMockGetNamespacePipelineReleaseByIDParams { - mmGetNamespacePipelineReleaseByID.mutex.RLock() +func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Calls() []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams { + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mutex.RLock() - argCopy := make([]*RepositoryMockGetNamespacePipelineReleaseByIDParams, len(mmGetNamespacePipelineReleaseByID.callArgs)) - copy(argCopy, mmGetNamespacePipelineReleaseByID.callArgs) + argCopy := make([]*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams, len(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.callArgs)) + copy(argCopy, mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.callArgs) - mmGetNamespacePipelineReleaseByID.mutex.RUnlock() + mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mutex.RUnlock() return argCopy } -// MinimockGetNamespacePipelineReleaseByIDDone returns true if the count of the GetNamespacePipelineReleaseByID invocations corresponds +// MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsDone returns true if the count of the GetPaginatedComponentRunsByPipelineRunIDWithPermissions invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetNamespacePipelineReleaseByIDDone() bool { - if m.GetNamespacePipelineReleaseByIDMock.optional { +func (m *RepositoryMock) MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsDone() bool { + if m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetNamespacePipelineReleaseByIDMock.expectations { + for _, e := range m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetNamespacePipelineReleaseByIDMock.invocationsDone() + return m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.invocationsDone() } -// MinimockGetNamespacePipelineReleaseByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetNamespacePipelineReleaseByIDInspect() { - for _, e := range m.GetNamespacePipelineReleaseByIDMock.expectations { +// MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsInspect() { + for _, e := range m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetNamespacePipelineReleaseByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespacePipelineReleaseByIDCounter) + afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetNamespacePipelineReleaseByIDMock.defaultExpectation != nil && afterGetNamespacePipelineReleaseByIDCounter < 1 { - if m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s", m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.returnOrigin) + if m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation != nil && afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter < 1 { + if m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s", m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s with params: %#v", m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespacePipelineReleaseByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s with params: %#v", m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetNamespacePipelineReleaseByID != nil && afterGetNamespacePipelineReleaseByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s", m.funcGetNamespacePipelineReleaseByIDOrigin) + if m.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil && afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s", m.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissionsOrigin) } - if !m.GetNamespacePipelineReleaseByIDMock.invocationsDone() && afterGetNamespacePipelineReleaseByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespacePipelineReleaseByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetNamespacePipelineReleaseByIDMock.expectedInvocations), m.GetNamespacePipelineReleaseByIDMock.expectedInvocationsOrigin, afterGetNamespacePipelineReleaseByIDCounter) + if !m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.invocationsDone() && afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectedInvocations), m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectedInvocationsOrigin, afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) } } -type mRepositoryMockGetNamespaceSecretByID struct { +type mRepositoryMockGetPaginatedPipelineRunsByRequester struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetNamespaceSecretByIDExpectation - expectations []*RepositoryMockGetNamespaceSecretByIDExpectation + defaultExpectation *RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation + expectations []*RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation - callArgs []*RepositoryMockGetNamespaceSecretByIDParams + callArgs []*RepositoryMockGetPaginatedPipelineRunsByRequesterParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetNamespaceSecretByIDExpectation specifies expectation struct of the Repository.GetNamespaceSecretByID -type RepositoryMockGetNamespaceSecretByIDExpectation struct { +// RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation specifies expectation struct of the Repository.GetPaginatedPipelineRunsByRequester +type RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation struct { mock *RepositoryMock - params *RepositoryMockGetNamespaceSecretByIDParams - paramPtrs *RepositoryMockGetNamespaceSecretByIDParamPtrs - expectationOrigins RepositoryMockGetNamespaceSecretByIDExpectationOrigins - results *RepositoryMockGetNamespaceSecretByIDResults + params *RepositoryMockGetPaginatedPipelineRunsByRequesterParams + paramPtrs *RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs + expectationOrigins RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins + results *RepositoryMockGetPaginatedPipelineRunsByRequesterResults returnOrigin string Counter uint64 } -// RepositoryMockGetNamespaceSecretByIDParams contains parameters of the Repository.GetNamespaceSecretByID -type RepositoryMockGetNamespaceSecretByIDParams struct { - ctx context.Context - ownerPermalink string - id string +// RepositoryMockGetPaginatedPipelineRunsByRequesterParams contains parameters of the Repository.GetPaginatedPipelineRunsByRequester +type RepositoryMockGetPaginatedPipelineRunsByRequesterParams struct { + ctx context.Context + params mm_repository.GetPipelineRunsByRequesterParams } -// RepositoryMockGetNamespaceSecretByIDParamPtrs contains pointers to parameters of the Repository.GetNamespaceSecretByID -type RepositoryMockGetNamespaceSecretByIDParamPtrs struct { - ctx *context.Context - ownerPermalink *string - id *string +// RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs contains pointers to parameters of the Repository.GetPaginatedPipelineRunsByRequester +type RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs struct { + ctx *context.Context + params *mm_repository.GetPipelineRunsByRequesterParams } -// RepositoryMockGetNamespaceSecretByIDResults contains results of the Repository.GetNamespaceSecretByID -type RepositoryMockGetNamespaceSecretByIDResults struct { - sp1 *datamodel.Secret +// RepositoryMockGetPaginatedPipelineRunsByRequesterResults contains results of the Repository.GetPaginatedPipelineRunsByRequester +type RepositoryMockGetPaginatedPipelineRunsByRequesterResults struct { + pa1 []datamodel.PipelineRun + i1 int64 err error } -// RepositoryMockGetNamespaceSecretByIDOrigins contains origins of expectations of the Repository.GetNamespaceSecretByID -type RepositoryMockGetNamespaceSecretByIDExpectationOrigins struct { - origin string - originCtx string - originOwnerPermalink string - originId string +// RepositoryMockGetPaginatedPipelineRunsByRequesterOrigins contains origins of expectations of the Repository.GetPaginatedPipelineRunsByRequester +type RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins struct { + origin string + originCtx string + originParams string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -8767,383 +8923,361 @@ type RepositoryMockGetNamespaceSecretByIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Optional() *mRepositoryMockGetNamespaceSecretByID { - mmGetNamespaceSecretByID.optional = true - return mmGetNamespaceSecretByID +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Optional() *mRepositoryMockGetPaginatedPipelineRunsByRequester { + mmGetPaginatedPipelineRunsByRequester.optional = true + return mmGetPaginatedPipelineRunsByRequester } -// Expect sets up expected params for Repository.GetNamespaceSecretByID -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Expect(ctx context.Context, ownerPermalink string, id string) *mRepositoryMockGetNamespaceSecretByID { - if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") +// Expect sets up expected params for Repository.GetPaginatedPipelineRunsByRequester +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Expect(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) *mRepositoryMockGetPaginatedPipelineRunsByRequester { + if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") } - if mmGetNamespaceSecretByID.defaultExpectation == nil { - mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { + mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{} } - if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by ExpectParams functions") + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by ExpectParams functions") } - mmGetNamespaceSecretByID.defaultExpectation.params = &RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id} - mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetNamespaceSecretByID.expectations { - if minimock.Equal(e.params, mmGetNamespaceSecretByID.defaultExpectation.params) { - mmGetNamespaceSecretByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetNamespaceSecretByID.defaultExpectation.params) + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params = &RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params} + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPaginatedPipelineRunsByRequester.expectations { + if minimock.Equal(e.params, mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params) { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params) } } - return mmGetNamespaceSecretByID -} - -// ExpectCtxParam1 sets up expected param ctx for Repository.GetNamespaceSecretByID -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetNamespaceSecretByID { - if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") - } - - if mmGetNamespaceSecretByID.defaultExpectation == nil { - mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} - } - - if mmGetNamespaceSecretByID.defaultExpectation.params != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Expect") - } - - if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs == nil { - mmGetNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceSecretByIDParamPtrs{} - } - mmGetNamespaceSecretByID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmGetNamespaceSecretByID + return mmGetPaginatedPipelineRunsByRequester } -// ExpectOwnerPermalinkParam2 sets up expected param ownerPermalink for Repository.GetNamespaceSecretByID -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) ExpectOwnerPermalinkParam2(ownerPermalink string) *mRepositoryMockGetNamespaceSecretByID { - if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedPipelineRunsByRequester +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedPipelineRunsByRequester { + if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") } - if mmGetNamespaceSecretByID.defaultExpectation == nil { - mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { + mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{} } - if mmGetNamespaceSecretByID.defaultExpectation.params != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Expect") + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Expect") } - if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs == nil { - mmGetNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceSecretByIDParamPtrs{} + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs{} } - mmGetNamespaceSecretByID.defaultExpectation.paramPtrs.ownerPermalink = &ownerPermalink - mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.originOwnerPermalink = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetNamespaceSecretByID + return mmGetPaginatedPipelineRunsByRequester } -// ExpectIdParam3 sets up expected param id for Repository.GetNamespaceSecretByID -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) ExpectIdParam3(id string) *mRepositoryMockGetNamespaceSecretByID { - if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") +// ExpectParamsParam2 sets up expected param params for Repository.GetPaginatedPipelineRunsByRequester +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) ExpectParamsParam2(params mm_repository.GetPipelineRunsByRequesterParams) *mRepositoryMockGetPaginatedPipelineRunsByRequester { + if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") } - if mmGetNamespaceSecretByID.defaultExpectation == nil { - mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{} + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { + mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{} } - if mmGetNamespaceSecretByID.defaultExpectation.params != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Expect") + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Expect") } - if mmGetNamespaceSecretByID.defaultExpectation.paramPtrs == nil { - mmGetNamespaceSecretByID.defaultExpectation.paramPtrs = &RepositoryMockGetNamespaceSecretByIDParamPtrs{} + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs{} } - mmGetNamespaceSecretByID.defaultExpectation.paramPtrs.id = &id - mmGetNamespaceSecretByID.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs.params = ¶ms + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.expectationOrigins.originParams = minimock.CallerInfo(1) - return mmGetNamespaceSecretByID + return mmGetPaginatedPipelineRunsByRequester } -// Inspect accepts an inspector function that has same arguments as the Repository.GetNamespaceSecretByID -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Inspect(f func(ctx context.Context, ownerPermalink string, id string)) *mRepositoryMockGetNamespaceSecretByID { - if mmGetNamespaceSecretByID.mock.inspectFuncGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetNamespaceSecretByID") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedPipelineRunsByRequester +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Inspect(f func(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams)) *mRepositoryMockGetPaginatedPipelineRunsByRequester { + if mmGetPaginatedPipelineRunsByRequester.mock.inspectFuncGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedPipelineRunsByRequester") } - mmGetNamespaceSecretByID.mock.inspectFuncGetNamespaceSecretByID = f + mmGetPaginatedPipelineRunsByRequester.mock.inspectFuncGetPaginatedPipelineRunsByRequester = f - return mmGetNamespaceSecretByID + return mmGetPaginatedPipelineRunsByRequester } -// Return sets up results that will be returned by Repository.GetNamespaceSecretByID -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Return(sp1 *datamodel.Secret, err error) *RepositoryMock { - if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") +// Return sets up results that will be returned by Repository.GetPaginatedPipelineRunsByRequester +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Return(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { + if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") } - if mmGetNamespaceSecretByID.defaultExpectation == nil { - mmGetNamespaceSecretByID.defaultExpectation = &RepositoryMockGetNamespaceSecretByIDExpectation{mock: mmGetNamespaceSecretByID.mock} + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { + mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{mock: mmGetPaginatedPipelineRunsByRequester.mock} } - mmGetNamespaceSecretByID.defaultExpectation.results = &RepositoryMockGetNamespaceSecretByIDResults{sp1, err} - mmGetNamespaceSecretByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetNamespaceSecretByID.mock + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.results = &RepositoryMockGetPaginatedPipelineRunsByRequesterResults{pa1, i1, err} + mmGetPaginatedPipelineRunsByRequester.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPaginatedPipelineRunsByRequester.mock } -// Set uses given function f to mock the Repository.GetNamespaceSecretByID method -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Set(f func(ctx context.Context, ownerPermalink string, id string) (sp1 *datamodel.Secret, err error)) *RepositoryMock { - if mmGetNamespaceSecretByID.defaultExpectation != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("Default expectation is already set for the Repository.GetNamespaceSecretByID method") +// Set uses given function f to mock the Repository.GetPaginatedPipelineRunsByRequester method +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Set(f func(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) (pa1 []datamodel.PipelineRun, i1 int64, err error)) *RepositoryMock { + if mmGetPaginatedPipelineRunsByRequester.defaultExpectation != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedPipelineRunsByRequester method") } - if len(mmGetNamespaceSecretByID.expectations) > 0 { - mmGetNamespaceSecretByID.mock.t.Fatalf("Some expectations are already set for the Repository.GetNamespaceSecretByID method") + if len(mmGetPaginatedPipelineRunsByRequester.expectations) > 0 { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedPipelineRunsByRequester method") } - mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID = f - mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByIDOrigin = minimock.CallerInfo(1) - return mmGetNamespaceSecretByID.mock + mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester = f + mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequesterOrigin = minimock.CallerInfo(1) + return mmGetPaginatedPipelineRunsByRequester.mock } -// When sets expectation for the Repository.GetNamespaceSecretByID which will trigger the result defined by the following +// When sets expectation for the Repository.GetPaginatedPipelineRunsByRequester which will trigger the result defined by the following // Then helper -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) When(ctx context.Context, ownerPermalink string, id string) *RepositoryMockGetNamespaceSecretByIDExpectation { - if mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.mock.t.Fatalf("RepositoryMock.GetNamespaceSecretByID mock is already set by Set") +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) When(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) *RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation { + if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") } - expectation := &RepositoryMockGetNamespaceSecretByIDExpectation{ - mock: mmGetNamespaceSecretByID.mock, - params: &RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id}, - expectationOrigins: RepositoryMockGetNamespaceSecretByIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{ + mock: mmGetPaginatedPipelineRunsByRequester.mock, + params: &RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params}, + expectationOrigins: RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetNamespaceSecretByID.expectations = append(mmGetNamespaceSecretByID.expectations, expectation) + mmGetPaginatedPipelineRunsByRequester.expectations = append(mmGetPaginatedPipelineRunsByRequester.expectations, expectation) return expectation } -// Then sets up Repository.GetNamespaceSecretByID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetNamespaceSecretByIDExpectation) Then(sp1 *datamodel.Secret, err error) *RepositoryMock { - e.results = &RepositoryMockGetNamespaceSecretByIDResults{sp1, err} +// Then sets up Repository.GetPaginatedPipelineRunsByRequester return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation) Then(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { + e.results = &RepositoryMockGetPaginatedPipelineRunsByRequesterResults{pa1, i1, err} return e.mock } -// Times sets number of times Repository.GetNamespaceSecretByID should be invoked -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Times(n uint64) *mRepositoryMockGetNamespaceSecretByID { +// Times sets number of times Repository.GetPaginatedPipelineRunsByRequester should be invoked +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Times(n uint64) *mRepositoryMockGetPaginatedPipelineRunsByRequester { if n == 0 { - mmGetNamespaceSecretByID.mock.t.Fatalf("Times of RepositoryMock.GetNamespaceSecretByID mock can not be zero") + mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedPipelineRunsByRequester mock can not be zero") } - mm_atomic.StoreUint64(&mmGetNamespaceSecretByID.expectedInvocations, n) - mmGetNamespaceSecretByID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetNamespaceSecretByID + mm_atomic.StoreUint64(&mmGetPaginatedPipelineRunsByRequester.expectedInvocations, n) + mmGetPaginatedPipelineRunsByRequester.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPaginatedPipelineRunsByRequester } -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) invocationsDone() bool { - if len(mmGetNamespaceSecretByID.expectations) == 0 && mmGetNamespaceSecretByID.defaultExpectation == nil && mmGetNamespaceSecretByID.mock.funcGetNamespaceSecretByID == nil { +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) invocationsDone() bool { + if len(mmGetPaginatedPipelineRunsByRequester.expectations) == 0 && mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil && mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.mock.afterGetNamespaceSecretByIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.mock.afterGetPaginatedPipelineRunsByRequesterCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetNamespaceSecretByID implements mm_repository.Repository -func (mmGetNamespaceSecretByID *RepositoryMock) GetNamespaceSecretByID(ctx context.Context, ownerPermalink string, id string) (sp1 *datamodel.Secret, err error) { - mm_atomic.AddUint64(&mmGetNamespaceSecretByID.beforeGetNamespaceSecretByIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetNamespaceSecretByID.afterGetNamespaceSecretByIDCounter, 1) +// GetPaginatedPipelineRunsByRequester implements mm_repository.Repository +func (mmGetPaginatedPipelineRunsByRequester *RepositoryMock) GetPaginatedPipelineRunsByRequester(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) (pa1 []datamodel.PipelineRun, i1 int64, err error) { + mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByRequester.beforeGetPaginatedPipelineRunsByRequesterCounter, 1) + defer mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByRequester.afterGetPaginatedPipelineRunsByRequesterCounter, 1) - mmGetNamespaceSecretByID.t.Helper() + mmGetPaginatedPipelineRunsByRequester.t.Helper() - if mmGetNamespaceSecretByID.inspectFuncGetNamespaceSecretByID != nil { - mmGetNamespaceSecretByID.inspectFuncGetNamespaceSecretByID(ctx, ownerPermalink, id) + if mmGetPaginatedPipelineRunsByRequester.inspectFuncGetPaginatedPipelineRunsByRequester != nil { + mmGetPaginatedPipelineRunsByRequester.inspectFuncGetPaginatedPipelineRunsByRequester(ctx, params) } - mm_params := RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id} + mm_params := RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params} // Record call args - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.mutex.Lock() - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.callArgs = append(mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.callArgs, &mm_params) - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.mutex.Unlock() + mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.mutex.Lock() + mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.callArgs = append(mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.callArgs, &mm_params) + mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.mutex.Unlock() - for _, e := range mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.expectations { + for _, e := range mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.sp1, e.results.err + return e.results.pa1, e.results.i1, e.results.err } } - if mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.params - mm_want_ptrs := mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.paramPtrs + if mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.Counter, 1) + mm_want := mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.params + mm_want_ptrs := mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetNamespaceSecretByIDParams{ctx, ownerPermalink, id} + mm_got := RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.ownerPermalink != nil && !minimock.Equal(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink) { - mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameter ownerPermalink, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originOwnerPermalink, *mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink, minimock.Diff(*mm_want_ptrs.ownerPermalink, mm_got.ownerPermalink)) + mmGetPaginatedPipelineRunsByRequester.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByRequester got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + if mm_want_ptrs.params != nil && !minimock.Equal(*mm_want_ptrs.params, mm_got.params) { + mmGetPaginatedPipelineRunsByRequester.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByRequester got unexpected parameter params, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.originParams, *mm_want_ptrs.params, mm_got.params, minimock.Diff(*mm_want_ptrs.params, mm_got.params)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetNamespaceSecretByID.t.Errorf("RepositoryMock.GetNamespaceSecretByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPaginatedPipelineRunsByRequester.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByRequester got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetNamespaceSecretByID.GetNamespaceSecretByIDMock.defaultExpectation.results + mm_results := mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.results if mm_results == nil { - mmGetNamespaceSecretByID.t.Fatal("No results are set for the RepositoryMock.GetNamespaceSecretByID") + mmGetPaginatedPipelineRunsByRequester.t.Fatal("No results are set for the RepositoryMock.GetPaginatedPipelineRunsByRequester") } - return (*mm_results).sp1, (*mm_results).err + return (*mm_results).pa1, (*mm_results).i1, (*mm_results).err } - if mmGetNamespaceSecretByID.funcGetNamespaceSecretByID != nil { - return mmGetNamespaceSecretByID.funcGetNamespaceSecretByID(ctx, ownerPermalink, id) + if mmGetPaginatedPipelineRunsByRequester.funcGetPaginatedPipelineRunsByRequester != nil { + return mmGetPaginatedPipelineRunsByRequester.funcGetPaginatedPipelineRunsByRequester(ctx, params) } - mmGetNamespaceSecretByID.t.Fatalf("Unexpected call to RepositoryMock.GetNamespaceSecretByID. %v %v %v", ctx, ownerPermalink, id) + mmGetPaginatedPipelineRunsByRequester.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedPipelineRunsByRequester. %v %v", ctx, params) return } -// GetNamespaceSecretByIDAfterCounter returns a count of finished RepositoryMock.GetNamespaceSecretByID invocations -func (mmGetNamespaceSecretByID *RepositoryMock) GetNamespaceSecretByIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.afterGetNamespaceSecretByIDCounter) +// GetPaginatedPipelineRunsByRequesterAfterCounter returns a count of finished RepositoryMock.GetPaginatedPipelineRunsByRequester invocations +func (mmGetPaginatedPipelineRunsByRequester *RepositoryMock) GetPaginatedPipelineRunsByRequesterAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.afterGetPaginatedPipelineRunsByRequesterCounter) } -// GetNamespaceSecretByIDBeforeCounter returns a count of RepositoryMock.GetNamespaceSecretByID invocations -func (mmGetNamespaceSecretByID *RepositoryMock) GetNamespaceSecretByIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetNamespaceSecretByID.beforeGetNamespaceSecretByIDCounter) +// GetPaginatedPipelineRunsByRequesterBeforeCounter returns a count of RepositoryMock.GetPaginatedPipelineRunsByRequester invocations +func (mmGetPaginatedPipelineRunsByRequester *RepositoryMock) GetPaginatedPipelineRunsByRequesterBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.beforeGetPaginatedPipelineRunsByRequesterCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetNamespaceSecretByID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedPipelineRunsByRequester. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetNamespaceSecretByID *mRepositoryMockGetNamespaceSecretByID) Calls() []*RepositoryMockGetNamespaceSecretByIDParams { - mmGetNamespaceSecretByID.mutex.RLock() +func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Calls() []*RepositoryMockGetPaginatedPipelineRunsByRequesterParams { + mmGetPaginatedPipelineRunsByRequester.mutex.RLock() - argCopy := make([]*RepositoryMockGetNamespaceSecretByIDParams, len(mmGetNamespaceSecretByID.callArgs)) - copy(argCopy, mmGetNamespaceSecretByID.callArgs) + argCopy := make([]*RepositoryMockGetPaginatedPipelineRunsByRequesterParams, len(mmGetPaginatedPipelineRunsByRequester.callArgs)) + copy(argCopy, mmGetPaginatedPipelineRunsByRequester.callArgs) - mmGetNamespaceSecretByID.mutex.RUnlock() + mmGetPaginatedPipelineRunsByRequester.mutex.RUnlock() return argCopy } -// MinimockGetNamespaceSecretByIDDone returns true if the count of the GetNamespaceSecretByID invocations corresponds +// MinimockGetPaginatedPipelineRunsByRequesterDone returns true if the count of the GetPaginatedPipelineRunsByRequester invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetNamespaceSecretByIDDone() bool { - if m.GetNamespaceSecretByIDMock.optional { +func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsByRequesterDone() bool { + if m.GetPaginatedPipelineRunsByRequesterMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetNamespaceSecretByIDMock.expectations { + for _, e := range m.GetPaginatedPipelineRunsByRequesterMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetNamespaceSecretByIDMock.invocationsDone() + return m.GetPaginatedPipelineRunsByRequesterMock.invocationsDone() } -// MinimockGetNamespaceSecretByIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetNamespaceSecretByIDInspect() { - for _, e := range m.GetNamespaceSecretByIDMock.expectations { +// MinimockGetPaginatedPipelineRunsByRequesterInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsByRequesterInspect() { + for _, e := range m.GetPaginatedPipelineRunsByRequesterMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetNamespaceSecretByIDCounter := mm_atomic.LoadUint64(&m.afterGetNamespaceSecretByIDCounter) + afterGetPaginatedPipelineRunsByRequesterCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedPipelineRunsByRequesterCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetNamespaceSecretByIDMock.defaultExpectation != nil && afterGetNamespaceSecretByIDCounter < 1 { - if m.GetNamespaceSecretByIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s", m.GetNamespaceSecretByIDMock.defaultExpectation.returnOrigin) + if m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation != nil && afterGetPaginatedPipelineRunsByRequesterCounter < 1 { + if m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s", m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s with params: %#v", m.GetNamespaceSecretByIDMock.defaultExpectation.expectationOrigins.origin, *m.GetNamespaceSecretByIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s with params: %#v", m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetNamespaceSecretByID != nil && afterGetNamespaceSecretByIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetNamespaceSecretByID at\n%s", m.funcGetNamespaceSecretByIDOrigin) + if m.funcGetPaginatedPipelineRunsByRequester != nil && afterGetPaginatedPipelineRunsByRequesterCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s", m.funcGetPaginatedPipelineRunsByRequesterOrigin) } - if !m.GetNamespaceSecretByIDMock.invocationsDone() && afterGetNamespaceSecretByIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetNamespaceSecretByID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetNamespaceSecretByIDMock.expectedInvocations), m.GetNamespaceSecretByIDMock.expectedInvocationsOrigin, afterGetNamespaceSecretByIDCounter) + if !m.GetPaginatedPipelineRunsByRequesterMock.invocationsDone() && afterGetPaginatedPipelineRunsByRequesterCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPaginatedPipelineRunsByRequesterMock.expectedInvocations), m.GetPaginatedPipelineRunsByRequesterMock.expectedInvocationsOrigin, afterGetPaginatedPipelineRunsByRequesterCounter) } } -type mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions struct { +type mRepositoryMockGetPaginatedPipelineRunsWithPermissions struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation - expectations []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation + defaultExpectation *RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation + expectations []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation - callArgs []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams + callArgs []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation specifies expectation struct of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation struct { +// RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation specifies expectation struct of the Repository.GetPaginatedPipelineRunsWithPermissions +type RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams - paramPtrs *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs - expectationOrigins RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectationOrigins - results *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults + params *RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams + paramPtrs *RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs + expectationOrigins RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins + results *RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults returnOrigin string Counter uint64 } -// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams contains parameters of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams struct { - ctx context.Context - pipelineRunID string - page int - pageSize int - filter filtering.Filter - order ordering.OrderBy +// RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams contains parameters of the Repository.GetPaginatedPipelineRunsWithPermissions +type RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams struct { + ctx context.Context + requesterUID string + pipelineUID string + page int + pageSize int + filter filtering.Filter + order ordering.OrderBy + isOwner bool } -// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs contains pointers to parameters of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs struct { - ctx *context.Context - pipelineRunID *string - page *int - pageSize *int - filter *filtering.Filter - order *ordering.OrderBy +// RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs contains pointers to parameters of the Repository.GetPaginatedPipelineRunsWithPermissions +type RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs struct { + ctx *context.Context + requesterUID *string + pipelineUID *string + page *int + pageSize *int + filter *filtering.Filter + order *ordering.OrderBy + isOwner *bool } -// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults contains results of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults struct { - ca1 []datamodel.ComponentRun +// RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults contains results of the Repository.GetPaginatedPipelineRunsWithPermissions +type RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults struct { + pa1 []datamodel.PipelineRun i1 int64 err error } -// RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsOrigins contains origins of expectations of the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectationOrigins struct { - origin string - originCtx string - originPipelineRunID string - originPage string - originPageSize string - originFilter string - originOrder string +// RepositoryMockGetPaginatedPipelineRunsWithPermissionsOrigins contains origins of expectations of the Repository.GetPaginatedPipelineRunsWithPermissions +type RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins struct { + origin string + originCtx string + originRequesterUID string + originPipelineUID string + originPage string + originPageSize string + originFilter string + originOrder string + originIsOwner string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -9151,455 +9285,516 @@ type RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpect // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Optional() *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.optional = true - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Optional() *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + mmGetPaginatedPipelineRunsWithPermissions.optional = true + return mmGetPaginatedPipelineRunsWithPermissions } -// Expect sets up expected params for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Expect(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") - } - - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} +// Expect sets up expected params for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Expect(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by ExpectParams functions") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order} - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations { - if minimock.Equal(e.params, mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params) + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by ExpectParams functions") + } + + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner} + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPaginatedPipelineRunsWithPermissions.expectations { + if minimock.Equal(e.params, mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params) { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params) } } - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// ExpectPipelineRunIDParam2 sets up expected param pipelineRunID for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectPipelineRunIDParam2(pipelineRunID string) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectRequesterUIDParam2 sets up expected param requesterUID for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectRequesterUIDParam2(requesterUID string) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.pipelineRunID = &pipelineRunID - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originPipelineRunID = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.requesterUID = &requesterUID + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originRequesterUID = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// ExpectPageParam3 sets up expected param page for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectPageParam3(page int) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectPipelineUIDParam3(pipelineUID string) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.page = &page - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originPage = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// ExpectPageSizeParam4 sets up expected param pageSize for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectPageSizeParam4(pageSize int) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectPageParam4 sets up expected param page for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectPageParam4(page int) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.pageSize = &pageSize - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originPageSize = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.page = &page + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originPage = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// ExpectFilterParam5 sets up expected param filter for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectFilterParam5(filter filtering.Filter) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectPageSizeParam5 sets up expected param pageSize for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectPageSizeParam5(pageSize int) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.filter = &filter - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originFilter = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.pageSize = &pageSize + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originPageSize = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// ExpectOrderParam6 sets up expected param order for Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) ExpectOrderParam6(order ordering.OrderBy) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectFilterParam6 sets up expected param filter for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectFilterParam6(filter filtering.Filter) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Expect") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParamPtrs{} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.paramPtrs.order = &order - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.expectationOrigins.originOrder = minimock.CallerInfo(1) + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.filter = &filter + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originFilter = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + return mmGetPaginatedPipelineRunsWithPermissions } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Inspect(f func(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy)) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions") +// ExpectOrderParam7 sets up expected param order for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectOrderParam7(order ordering.OrderBy) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions = f + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} + } - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") + } + + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} + } + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.order = &order + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originOrder = minimock.CallerInfo(1) + + return mmGetPaginatedPipelineRunsWithPermissions } -// Return sets up results that will be returned by Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Return(ca1 []datamodel.ComponentRun, i1 int64, err error) *RepositoryMock { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// ExpectIsOwnerParam8 sets up expected param isOwner for Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectIsOwnerParam8(isOwner bool) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{mock: mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock} + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.results = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults{ca1, i1, err} - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock -} -// Set uses given function f to mock the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions method -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Set(f func(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (ca1 []datamodel.ComponentRun, i1 int64, err error)) *RepositoryMock { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions method") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") } - if len(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations) > 0 { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions method") + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} } + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.isOwner = &isOwner + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originIsOwner = minimock.CallerInfo(1) - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions = f - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissionsOrigin = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock + return mmGetPaginatedPipelineRunsWithPermissions } -// When sets expectation for the Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions which will trigger the result defined by the following -// Then helper -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) When(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation { - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock is already set by Set") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Inspect(f func(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool)) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { + if mmGetPaginatedPipelineRunsWithPermissions.mock.inspectFuncGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedPipelineRunsWithPermissions") } - expectation := &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation{ - mock: mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock, - params: &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order}, - expectationOrigins: RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectationOrigins{origin: minimock.CallerInfo(1)}, - } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations = append(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations, expectation) - return expectation + mmGetPaginatedPipelineRunsWithPermissions.mock.inspectFuncGetPaginatedPipelineRunsWithPermissions = f + + return mmGetPaginatedPipelineRunsWithPermissions } -// Then sets up Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsExpectation) Then(ca1 []datamodel.ComponentRun, i1 int64, err error) *RepositoryMock { - e.results = &RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsResults{ca1, i1, err} +// Return sets up results that will be returned by Repository.GetPaginatedPipelineRunsWithPermissions +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Return(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") + } + + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{mock: mmGetPaginatedPipelineRunsWithPermissions.mock} + } + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.results = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults{pa1, i1, err} + mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPaginatedPipelineRunsWithPermissions.mock +} + +// Set uses given function f to mock the Repository.GetPaginatedPipelineRunsWithPermissions method +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Set(f func(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) (pa1 []datamodel.PipelineRun, i1 int64, err error)) *RepositoryMock { + if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedPipelineRunsWithPermissions method") + } + + if len(mmGetPaginatedPipelineRunsWithPermissions.expectations) > 0 { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedPipelineRunsWithPermissions method") + } + + mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions = f + mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissionsOrigin = minimock.CallerInfo(1) + return mmGetPaginatedPipelineRunsWithPermissions.mock +} + +// When sets expectation for the Repository.GetPaginatedPipelineRunsWithPermissions which will trigger the result defined by the following +// Then helper +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) When(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) *RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation { + if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") + } + + expectation := &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{ + mock: mmGetPaginatedPipelineRunsWithPermissions.mock, + params: &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner}, + expectationOrigins: RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmGetPaginatedPipelineRunsWithPermissions.expectations = append(mmGetPaginatedPipelineRunsWithPermissions.expectations, expectation) + return expectation +} + +// Then sets up Repository.GetPaginatedPipelineRunsWithPermissions return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation) Then(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { + e.results = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults{pa1, i1, err} return e.mock } -// Times sets number of times Repository.GetPaginatedComponentRunsByPipelineRunIDWithPermissions should be invoked -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Times(n uint64) *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions { +// Times sets number of times Repository.GetPaginatedPipelineRunsWithPermissions should be invoked +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Times(n uint64) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { if n == 0 { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions mock can not be zero") + mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectedInvocations, n) - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions + mm_atomic.StoreUint64(&mmGetPaginatedPipelineRunsWithPermissions.expectedInvocations, n) + mmGetPaginatedPipelineRunsWithPermissions.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPaginatedPipelineRunsWithPermissions } -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) invocationsDone() bool { - if len(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectations) == 0 && mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.defaultExpectation == nil && mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions == nil { +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) invocationsDone() bool { + if len(mmGetPaginatedPipelineRunsWithPermissions.expectations) == 0 && mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil && mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mock.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.mock.afterGetPaginatedPipelineRunsWithPermissionsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPaginatedComponentRunsByPipelineRunIDWithPermissions implements mm_repository.Repository -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *RepositoryMock) GetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx context.Context, pipelineRunID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (ca1 []datamodel.ComponentRun, i1 int64, err error) { - mm_atomic.AddUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.beforeGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter, 1) - defer mm_atomic.AddUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter, 1) +// GetPaginatedPipelineRunsWithPermissions implements mm_repository.Repository +func (mmGetPaginatedPipelineRunsWithPermissions *RepositoryMock) GetPaginatedPipelineRunsWithPermissions(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) (pa1 []datamodel.PipelineRun, i1 int64, err error) { + mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsWithPermissions.beforeGetPaginatedPipelineRunsWithPermissionsCounter, 1) + defer mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsWithPermissions.afterGetPaginatedPipelineRunsWithPermissionsCounter, 1) - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Helper() + mmGetPaginatedPipelineRunsWithPermissions.t.Helper() - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.inspectFuncGetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx, pipelineRunID, page, pageSize, filter, order) + if mmGetPaginatedPipelineRunsWithPermissions.inspectFuncGetPaginatedPipelineRunsWithPermissions != nil { + mmGetPaginatedPipelineRunsWithPermissions.inspectFuncGetPaginatedPipelineRunsWithPermissions(ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner) } - mm_params := RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order} + mm_params := RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner} // Record call args - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.mutex.Lock() - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.callArgs = append(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.callArgs, &mm_params) - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.mutex.Unlock() + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.mutex.Lock() + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.callArgs = append(mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.callArgs, &mm_params) + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.mutex.Unlock() - for _, e := range mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectations { + for _, e := range mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.ca1, e.results.i1, e.results.err + return e.results.pa1, e.results.i1, e.results.err } } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.Counter, 1) - mm_want := mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.params - mm_want_ptrs := mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.paramPtrs + if mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.Counter, 1) + mm_want := mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.params + mm_want_ptrs := mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{ctx, pipelineRunID, page, pageSize, filter, order} + mm_got := RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.pipelineRunID != nil && !minimock.Equal(*mm_want_ptrs.pipelineRunID, mm_got.pipelineRunID) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter pipelineRunID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originPipelineRunID, *mm_want_ptrs.pipelineRunID, mm_got.pipelineRunID, minimock.Diff(*mm_want_ptrs.pipelineRunID, mm_got.pipelineRunID)) + if mm_want_ptrs.requesterUID != nil && !minimock.Equal(*mm_want_ptrs.requesterUID, mm_got.requesterUID) { + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter requesterUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originRequesterUID, *mm_want_ptrs.requesterUID, mm_got.requesterUID, minimock.Diff(*mm_want_ptrs.requesterUID, mm_got.requesterUID)) + } + + if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) } if mm_want_ptrs.page != nil && !minimock.Equal(*mm_want_ptrs.page, mm_got.page) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter page, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originPage, *mm_want_ptrs.page, mm_got.page, minimock.Diff(*mm_want_ptrs.page, mm_got.page)) + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter page, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originPage, *mm_want_ptrs.page, mm_got.page, minimock.Diff(*mm_want_ptrs.page, mm_got.page)) } if mm_want_ptrs.pageSize != nil && !minimock.Equal(*mm_want_ptrs.pageSize, mm_got.pageSize) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter pageSize, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originPageSize, *mm_want_ptrs.pageSize, mm_got.pageSize, minimock.Diff(*mm_want_ptrs.pageSize, mm_got.pageSize)) + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter pageSize, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originPageSize, *mm_want_ptrs.pageSize, mm_got.pageSize, minimock.Diff(*mm_want_ptrs.pageSize, mm_got.pageSize)) } if mm_want_ptrs.filter != nil && !minimock.Equal(*mm_want_ptrs.filter, mm_got.filter) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter filter, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originFilter, *mm_want_ptrs.filter, mm_got.filter, minimock.Diff(*mm_want_ptrs.filter, mm_got.filter)) + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter filter, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originFilter, *mm_want_ptrs.filter, mm_got.filter, minimock.Diff(*mm_want_ptrs.filter, mm_got.filter)) } if mm_want_ptrs.order != nil && !minimock.Equal(*mm_want_ptrs.order, mm_got.order) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameter order, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.originOrder, *mm_want_ptrs.order, mm_got.order, minimock.Diff(*mm_want_ptrs.order, mm_got.order)) + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter order, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originOrder, *mm_want_ptrs.order, mm_got.order, minimock.Diff(*mm_want_ptrs.order, mm_got.order)) + } + + if mm_want_ptrs.isOwner != nil && !minimock.Equal(*mm_want_ptrs.isOwner, mm_got.isOwner) { + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter isOwner, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originIsOwner, *mm_want_ptrs.isOwner, mm_got.isOwner, minimock.Diff(*mm_want_ptrs.isOwner, mm_got.isOwner)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Errorf("RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.results + mm_results := mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.results if mm_results == nil { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Fatal("No results are set for the RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions") + mmGetPaginatedPipelineRunsWithPermissions.t.Fatal("No results are set for the RepositoryMock.GetPaginatedPipelineRunsWithPermissions") } - return (*mm_results).ca1, (*mm_results).i1, (*mm_results).err + return (*mm_results).pa1, (*mm_results).i1, (*mm_results).err } - if mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil { - return mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx, pipelineRunID, page, pageSize, filter, order) + if mmGetPaginatedPipelineRunsWithPermissions.funcGetPaginatedPipelineRunsWithPermissions != nil { + return mmGetPaginatedPipelineRunsWithPermissions.funcGetPaginatedPipelineRunsWithPermissions(ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner) } - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions. %v %v %v %v %v %v", ctx, pipelineRunID, page, pageSize, filter, order) + mmGetPaginatedPipelineRunsWithPermissions.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions. %v %v %v %v %v %v %v %v", ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner) return } -// GetPaginatedComponentRunsByPipelineRunIDWithPermissionsAfterCounter returns a count of finished RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions invocations -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *RepositoryMock) GetPaginatedComponentRunsByPipelineRunIDWithPermissionsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) +// GetPaginatedPipelineRunsWithPermissionsAfterCounter returns a count of finished RepositoryMock.GetPaginatedPipelineRunsWithPermissions invocations +func (mmGetPaginatedPipelineRunsWithPermissions *RepositoryMock) GetPaginatedPipelineRunsWithPermissionsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.afterGetPaginatedPipelineRunsWithPermissionsCounter) } -// GetPaginatedComponentRunsByPipelineRunIDWithPermissionsBeforeCounter returns a count of RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions invocations -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *RepositoryMock) GetPaginatedComponentRunsByPipelineRunIDWithPermissionsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.beforeGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) +// GetPaginatedPipelineRunsWithPermissionsBeforeCounter returns a count of RepositoryMock.GetPaginatedPipelineRunsWithPermissions invocations +func (mmGetPaginatedPipelineRunsWithPermissions *RepositoryMock) GetPaginatedPipelineRunsWithPermissionsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.beforeGetPaginatedPipelineRunsWithPermissionsCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions *mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions) Calls() []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams { - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mutex.RLock() +func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Calls() []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams { + mmGetPaginatedPipelineRunsWithPermissions.mutex.RLock() - argCopy := make([]*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams, len(mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.callArgs)) - copy(argCopy, mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.callArgs) + argCopy := make([]*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams, len(mmGetPaginatedPipelineRunsWithPermissions.callArgs)) + copy(argCopy, mmGetPaginatedPipelineRunsWithPermissions.callArgs) - mmGetPaginatedComponentRunsByPipelineRunIDWithPermissions.mutex.RUnlock() + mmGetPaginatedPipelineRunsWithPermissions.mutex.RUnlock() return argCopy } -// MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsDone returns true if the count of the GetPaginatedComponentRunsByPipelineRunIDWithPermissions invocations corresponds +// MinimockGetPaginatedPipelineRunsWithPermissionsDone returns true if the count of the GetPaginatedPipelineRunsWithPermissions invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsDone() bool { - if m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.optional { +func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsWithPermissionsDone() bool { + if m.GetPaginatedPipelineRunsWithPermissionsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectations { + for _, e := range m.GetPaginatedPipelineRunsWithPermissionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.invocationsDone() + return m.GetPaginatedPipelineRunsWithPermissionsMock.invocationsDone() } -// MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsInspect() { - for _, e := range m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectations { +// MinimockGetPaginatedPipelineRunsWithPermissionsInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsWithPermissionsInspect() { + for _, e := range m.GetPaginatedPipelineRunsWithPermissionsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) + afterGetPaginatedPipelineRunsWithPermissionsCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedPipelineRunsWithPermissionsCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation != nil && afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter < 1 { - if m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s", m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.returnOrigin) + if m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation != nil && afterGetPaginatedPipelineRunsWithPermissionsCounter < 1 { + if m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s", m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s with params: %#v", m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s with params: %#v", m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissions != nil && afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s", m.funcGetPaginatedComponentRunsByPipelineRunIDWithPermissionsOrigin) + if m.funcGetPaginatedPipelineRunsWithPermissions != nil && afterGetPaginatedPipelineRunsWithPermissionsCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s", m.funcGetPaginatedPipelineRunsWithPermissionsOrigin) } - if !m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.invocationsDone() && afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedComponentRunsByPipelineRunIDWithPermissions at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectedInvocations), m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.expectedInvocationsOrigin, afterGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter) + if !m.GetPaginatedPipelineRunsWithPermissionsMock.invocationsDone() && afterGetPaginatedPipelineRunsWithPermissionsCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPaginatedPipelineRunsWithPermissionsMock.expectedInvocations), m.GetPaginatedPipelineRunsWithPermissionsMock.expectedInvocationsOrigin, afterGetPaginatedPipelineRunsWithPermissionsCounter) } } -type mRepositoryMockGetPaginatedPipelineRunsByRequester struct { +type mRepositoryMockGetPipelineByIDAdmin struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation - expectations []*RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation + defaultExpectation *RepositoryMockGetPipelineByIDAdminExpectation + expectations []*RepositoryMockGetPipelineByIDAdminExpectation - callArgs []*RepositoryMockGetPaginatedPipelineRunsByRequesterParams + callArgs []*RepositoryMockGetPipelineByIDAdminParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation specifies expectation struct of the Repository.GetPaginatedPipelineRunsByRequester -type RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation struct { +// RepositoryMockGetPipelineByIDAdminExpectation specifies expectation struct of the Repository.GetPipelineByIDAdmin +type RepositoryMockGetPipelineByIDAdminExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPaginatedPipelineRunsByRequesterParams - paramPtrs *RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs - expectationOrigins RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins - results *RepositoryMockGetPaginatedPipelineRunsByRequesterResults + params *RepositoryMockGetPipelineByIDAdminParams + paramPtrs *RepositoryMockGetPipelineByIDAdminParamPtrs + expectationOrigins RepositoryMockGetPipelineByIDAdminExpectationOrigins + results *RepositoryMockGetPipelineByIDAdminResults returnOrigin string Counter uint64 } -// RepositoryMockGetPaginatedPipelineRunsByRequesterParams contains parameters of the Repository.GetPaginatedPipelineRunsByRequester -type RepositoryMockGetPaginatedPipelineRunsByRequesterParams struct { - ctx context.Context - params mm_repository.GetPipelineRunsByRequesterParams +// RepositoryMockGetPipelineByIDAdminParams contains parameters of the Repository.GetPipelineByIDAdmin +type RepositoryMockGetPipelineByIDAdminParams struct { + ctx context.Context + id string + isBasicView bool + embedReleases bool } -// RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs contains pointers to parameters of the Repository.GetPaginatedPipelineRunsByRequester -type RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs struct { - ctx *context.Context - params *mm_repository.GetPipelineRunsByRequesterParams -} +// RepositoryMockGetPipelineByIDAdminParamPtrs contains pointers to parameters of the Repository.GetPipelineByIDAdmin +type RepositoryMockGetPipelineByIDAdminParamPtrs struct { + ctx *context.Context + id *string + isBasicView *bool + embedReleases *bool +} -// RepositoryMockGetPaginatedPipelineRunsByRequesterResults contains results of the Repository.GetPaginatedPipelineRunsByRequester -type RepositoryMockGetPaginatedPipelineRunsByRequesterResults struct { - pa1 []datamodel.PipelineRun - i1 int64 +// RepositoryMockGetPipelineByIDAdminResults contains results of the Repository.GetPipelineByIDAdmin +type RepositoryMockGetPipelineByIDAdminResults struct { + pp1 *datamodel.Pipeline err error } -// RepositoryMockGetPaginatedPipelineRunsByRequesterOrigins contains origins of expectations of the Repository.GetPaginatedPipelineRunsByRequester -type RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins struct { - origin string - originCtx string - originParams string +// RepositoryMockGetPipelineByIDAdminOrigins contains origins of expectations of the Repository.GetPipelineByIDAdmin +type RepositoryMockGetPipelineByIDAdminExpectationOrigins struct { + origin string + originCtx string + originId string + originIsBasicView string + originEmbedReleases string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -9607,361 +9802,404 @@ type RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins struct // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Optional() *mRepositoryMockGetPaginatedPipelineRunsByRequester { - mmGetPaginatedPipelineRunsByRequester.optional = true - return mmGetPaginatedPipelineRunsByRequester +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Optional() *mRepositoryMockGetPipelineByIDAdmin { + mmGetPipelineByIDAdmin.optional = true + return mmGetPipelineByIDAdmin } -// Expect sets up expected params for Repository.GetPaginatedPipelineRunsByRequester -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Expect(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) *mRepositoryMockGetPaginatedPipelineRunsByRequester { - if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") +// Expect sets up expected params for Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Expect(ctx context.Context, id string, isBasicView bool, embedReleases bool) *mRepositoryMockGetPipelineByIDAdmin { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { - mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{} + if mmGetPipelineByIDAdmin.defaultExpectation == nil { + mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by ExpectParams functions") + if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by ExpectParams functions") } - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params = &RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params} - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPaginatedPipelineRunsByRequester.expectations { - if minimock.Equal(e.params, mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params) { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params) + mmGetPipelineByIDAdmin.defaultExpectation.params = &RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases} + mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPipelineByIDAdmin.expectations { + if minimock.Equal(e.params, mmGetPipelineByIDAdmin.defaultExpectation.params) { + mmGetPipelineByIDAdmin.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineByIDAdmin.defaultExpectation.params) } } - return mmGetPaginatedPipelineRunsByRequester + return mmGetPipelineByIDAdmin } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedPipelineRunsByRequester -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedPipelineRunsByRequester { - if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineByIDAdmin { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { - mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{} + if mmGetPipelineByIDAdmin.defaultExpectation == nil { + mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Expect") + if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs{} + if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} } - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsByRequester + return mmGetPipelineByIDAdmin } -// ExpectParamsParam2 sets up expected param params for Repository.GetPaginatedPipelineRunsByRequester -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) ExpectParamsParam2(params mm_repository.GetPipelineRunsByRequesterParams) *mRepositoryMockGetPaginatedPipelineRunsByRequester { - if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") +// ExpectIdParam2 sets up expected param id for Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectIdParam2(id string) *mRepositoryMockGetPipelineByIDAdmin { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { - mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{} + if mmGetPipelineByIDAdmin.defaultExpectation == nil { + mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Expect") + if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByRequesterParamPtrs{} + if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} } - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.paramPtrs.params = ¶ms - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.expectationOrigins.originParams = minimock.CallerInfo(1) + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.id = &id + mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsByRequester + return mmGetPipelineByIDAdmin } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedPipelineRunsByRequester -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Inspect(f func(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams)) *mRepositoryMockGetPaginatedPipelineRunsByRequester { - if mmGetPaginatedPipelineRunsByRequester.mock.inspectFuncGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedPipelineRunsByRequester") +// ExpectIsBasicViewParam3 sets up expected param isBasicView for Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectIsBasicViewParam3(isBasicView bool) *mRepositoryMockGetPipelineByIDAdmin { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - mmGetPaginatedPipelineRunsByRequester.mock.inspectFuncGetPaginatedPipelineRunsByRequester = f + if mmGetPipelineByIDAdmin.defaultExpectation == nil { + mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} + } - return mmGetPaginatedPipelineRunsByRequester + if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") + } + + if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} + } + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.isBasicView = &isBasicView + mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + + return mmGetPipelineByIDAdmin } -// Return sets up results that will be returned by Repository.GetPaginatedPipelineRunsByRequester -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Return(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { - if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") +// ExpectEmbedReleasesParam4 sets up expected param embedReleases for Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectEmbedReleasesParam4(embedReleases bool) *mRepositoryMockGetPipelineByIDAdmin { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil { - mmGetPaginatedPipelineRunsByRequester.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{mock: mmGetPaginatedPipelineRunsByRequester.mock} + if mmGetPipelineByIDAdmin.defaultExpectation == nil { + mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} } - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.results = &RepositoryMockGetPaginatedPipelineRunsByRequesterResults{pa1, i1, err} - mmGetPaginatedPipelineRunsByRequester.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsByRequester.mock + + if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") + } + + if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} + } + mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.embedReleases = &embedReleases + mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originEmbedReleases = minimock.CallerInfo(1) + + return mmGetPipelineByIDAdmin } -// Set uses given function f to mock the Repository.GetPaginatedPipelineRunsByRequester method -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Set(f func(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) (pa1 []datamodel.PipelineRun, i1 int64, err error)) *RepositoryMock { - if mmGetPaginatedPipelineRunsByRequester.defaultExpectation != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedPipelineRunsByRequester method") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Inspect(f func(ctx context.Context, id string, isBasicView bool, embedReleases bool)) *mRepositoryMockGetPipelineByIDAdmin { + if mmGetPipelineByIDAdmin.mock.inspectFuncGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineByIDAdmin") } - if len(mmGetPaginatedPipelineRunsByRequester.expectations) > 0 { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedPipelineRunsByRequester method") + mmGetPipelineByIDAdmin.mock.inspectFuncGetPipelineByIDAdmin = f + + return mmGetPipelineByIDAdmin +} + +// Return sets up results that will be returned by Repository.GetPipelineByIDAdmin +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Return(pp1 *datamodel.Pipeline, err error) *RepositoryMock { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester = f - mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequesterOrigin = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsByRequester.mock + if mmGetPipelineByIDAdmin.defaultExpectation == nil { + mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{mock: mmGetPipelineByIDAdmin.mock} + } + mmGetPipelineByIDAdmin.defaultExpectation.results = &RepositoryMockGetPipelineByIDAdminResults{pp1, err} + mmGetPipelineByIDAdmin.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPipelineByIDAdmin.mock } -// When sets expectation for the Repository.GetPaginatedPipelineRunsByRequester which will trigger the result defined by the following +// Set uses given function f to mock the Repository.GetPipelineByIDAdmin method +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Set(f func(ctx context.Context, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error)) *RepositoryMock { + if mmGetPipelineByIDAdmin.defaultExpectation != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineByIDAdmin method") + } + + if len(mmGetPipelineByIDAdmin.expectations) > 0 { + mmGetPipelineByIDAdmin.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineByIDAdmin method") + } + + mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin = f + mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdminOrigin = minimock.CallerInfo(1) + return mmGetPipelineByIDAdmin.mock +} + +// When sets expectation for the Repository.GetPipelineByIDAdmin which will trigger the result defined by the following // Then helper -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) When(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) *RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation { - if mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByRequester mock is already set by Set") +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) When(ctx context.Context, id string, isBasicView bool, embedReleases bool) *RepositoryMockGetPipelineByIDAdminExpectation { + if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") } - expectation := &RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation{ - mock: mmGetPaginatedPipelineRunsByRequester.mock, - params: &RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params}, - expectationOrigins: RepositoryMockGetPaginatedPipelineRunsByRequesterExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetPipelineByIDAdminExpectation{ + mock: mmGetPipelineByIDAdmin.mock, + params: &RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases}, + expectationOrigins: RepositoryMockGetPipelineByIDAdminExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPaginatedPipelineRunsByRequester.expectations = append(mmGetPaginatedPipelineRunsByRequester.expectations, expectation) + mmGetPipelineByIDAdmin.expectations = append(mmGetPipelineByIDAdmin.expectations, expectation) return expectation } -// Then sets up Repository.GetPaginatedPipelineRunsByRequester return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPaginatedPipelineRunsByRequesterExpectation) Then(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { - e.results = &RepositoryMockGetPaginatedPipelineRunsByRequesterResults{pa1, i1, err} +// Then sets up Repository.GetPipelineByIDAdmin return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPipelineByIDAdminExpectation) Then(pp1 *datamodel.Pipeline, err error) *RepositoryMock { + e.results = &RepositoryMockGetPipelineByIDAdminResults{pp1, err} return e.mock } -// Times sets number of times Repository.GetPaginatedPipelineRunsByRequester should be invoked -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Times(n uint64) *mRepositoryMockGetPaginatedPipelineRunsByRequester { +// Times sets number of times Repository.GetPipelineByIDAdmin should be invoked +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Times(n uint64) *mRepositoryMockGetPipelineByIDAdmin { if n == 0 { - mmGetPaginatedPipelineRunsByRequester.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedPipelineRunsByRequester mock can not be zero") + mmGetPipelineByIDAdmin.mock.t.Fatalf("Times of RepositoryMock.GetPipelineByIDAdmin mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPaginatedPipelineRunsByRequester.expectedInvocations, n) - mmGetPaginatedPipelineRunsByRequester.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsByRequester + mm_atomic.StoreUint64(&mmGetPipelineByIDAdmin.expectedInvocations, n) + mmGetPipelineByIDAdmin.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPipelineByIDAdmin } -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) invocationsDone() bool { - if len(mmGetPaginatedPipelineRunsByRequester.expectations) == 0 && mmGetPaginatedPipelineRunsByRequester.defaultExpectation == nil && mmGetPaginatedPipelineRunsByRequester.mock.funcGetPaginatedPipelineRunsByRequester == nil { +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) invocationsDone() bool { + if len(mmGetPipelineByIDAdmin.expectations) == 0 && mmGetPipelineByIDAdmin.defaultExpectation == nil && mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.mock.afterGetPaginatedPipelineRunsByRequesterCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.mock.afterGetPipelineByIDAdminCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPaginatedPipelineRunsByRequester implements mm_repository.Repository -func (mmGetPaginatedPipelineRunsByRequester *RepositoryMock) GetPaginatedPipelineRunsByRequester(ctx context.Context, params mm_repository.GetPipelineRunsByRequesterParams) (pa1 []datamodel.PipelineRun, i1 int64, err error) { - mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByRequester.beforeGetPaginatedPipelineRunsByRequesterCounter, 1) - defer mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByRequester.afterGetPaginatedPipelineRunsByRequesterCounter, 1) - - mmGetPaginatedPipelineRunsByRequester.t.Helper() +// GetPipelineByIDAdmin implements mm_repository.Repository +func (mmGetPipelineByIDAdmin *RepositoryMock) GetPipelineByIDAdmin(ctx context.Context, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error) { + mm_atomic.AddUint64(&mmGetPipelineByIDAdmin.beforeGetPipelineByIDAdminCounter, 1) + defer mm_atomic.AddUint64(&mmGetPipelineByIDAdmin.afterGetPipelineByIDAdminCounter, 1) - if mmGetPaginatedPipelineRunsByRequester.inspectFuncGetPaginatedPipelineRunsByRequester != nil { - mmGetPaginatedPipelineRunsByRequester.inspectFuncGetPaginatedPipelineRunsByRequester(ctx, params) + mmGetPipelineByIDAdmin.t.Helper() + + if mmGetPipelineByIDAdmin.inspectFuncGetPipelineByIDAdmin != nil { + mmGetPipelineByIDAdmin.inspectFuncGetPipelineByIDAdmin(ctx, id, isBasicView, embedReleases) } - mm_params := RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params} + mm_params := RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases} // Record call args - mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.mutex.Lock() - mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.callArgs = append(mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.callArgs, &mm_params) - mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.mutex.Unlock() + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.mutex.Lock() + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.callArgs = append(mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.callArgs, &mm_params) + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.mutex.Unlock() - for _, e := range mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.expectations { + for _, e := range mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.pa1, e.results.i1, e.results.err + return e.results.pp1, e.results.err } } - if mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.Counter, 1) - mm_want := mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.params - mm_want_ptrs := mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.paramPtrs + if mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.Counter, 1) + mm_want := mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.params + mm_want_ptrs := mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPaginatedPipelineRunsByRequesterParams{ctx, params} + mm_got := RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPaginatedPipelineRunsByRequester.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByRequester got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.params != nil && !minimock.Equal(*mm_want_ptrs.params, mm_got.params) { - mmGetPaginatedPipelineRunsByRequester.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByRequester got unexpected parameter params, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.originParams, *mm_want_ptrs.params, mm_got.params, minimock.Diff(*mm_want_ptrs.params, mm_got.params)) + if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { + mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + } + + if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { + mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) + } + + if mm_want_ptrs.embedReleases != nil && !minimock.Equal(*mm_want_ptrs.embedReleases, mm_got.embedReleases) { + mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter embedReleases, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originEmbedReleases, *mm_want_ptrs.embedReleases, mm_got.embedReleases, minimock.Diff(*mm_want_ptrs.embedReleases, mm_got.embedReleases)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPaginatedPipelineRunsByRequester.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByRequester got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPaginatedPipelineRunsByRequester.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.results + mm_results := mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.results if mm_results == nil { - mmGetPaginatedPipelineRunsByRequester.t.Fatal("No results are set for the RepositoryMock.GetPaginatedPipelineRunsByRequester") + mmGetPipelineByIDAdmin.t.Fatal("No results are set for the RepositoryMock.GetPipelineByIDAdmin") } - return (*mm_results).pa1, (*mm_results).i1, (*mm_results).err + return (*mm_results).pp1, (*mm_results).err } - if mmGetPaginatedPipelineRunsByRequester.funcGetPaginatedPipelineRunsByRequester != nil { - return mmGetPaginatedPipelineRunsByRequester.funcGetPaginatedPipelineRunsByRequester(ctx, params) + if mmGetPipelineByIDAdmin.funcGetPipelineByIDAdmin != nil { + return mmGetPipelineByIDAdmin.funcGetPipelineByIDAdmin(ctx, id, isBasicView, embedReleases) } - mmGetPaginatedPipelineRunsByRequester.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedPipelineRunsByRequester. %v %v", ctx, params) + mmGetPipelineByIDAdmin.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineByIDAdmin. %v %v %v %v", ctx, id, isBasicView, embedReleases) return } -// GetPaginatedPipelineRunsByRequesterAfterCounter returns a count of finished RepositoryMock.GetPaginatedPipelineRunsByRequester invocations -func (mmGetPaginatedPipelineRunsByRequester *RepositoryMock) GetPaginatedPipelineRunsByRequesterAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.afterGetPaginatedPipelineRunsByRequesterCounter) +// GetPipelineByIDAdminAfterCounter returns a count of finished RepositoryMock.GetPipelineByIDAdmin invocations +func (mmGetPipelineByIDAdmin *RepositoryMock) GetPipelineByIDAdminAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.afterGetPipelineByIDAdminCounter) } -// GetPaginatedPipelineRunsByRequesterBeforeCounter returns a count of RepositoryMock.GetPaginatedPipelineRunsByRequester invocations -func (mmGetPaginatedPipelineRunsByRequester *RepositoryMock) GetPaginatedPipelineRunsByRequesterBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByRequester.beforeGetPaginatedPipelineRunsByRequesterCounter) +// GetPipelineByIDAdminBeforeCounter returns a count of RepositoryMock.GetPipelineByIDAdmin invocations +func (mmGetPipelineByIDAdmin *RepositoryMock) GetPipelineByIDAdminBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.beforeGetPipelineByIDAdminCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedPipelineRunsByRequester. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineByIDAdmin. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPaginatedPipelineRunsByRequester *mRepositoryMockGetPaginatedPipelineRunsByRequester) Calls() []*RepositoryMockGetPaginatedPipelineRunsByRequesterParams { - mmGetPaginatedPipelineRunsByRequester.mutex.RLock() +func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Calls() []*RepositoryMockGetPipelineByIDAdminParams { + mmGetPipelineByIDAdmin.mutex.RLock() - argCopy := make([]*RepositoryMockGetPaginatedPipelineRunsByRequesterParams, len(mmGetPaginatedPipelineRunsByRequester.callArgs)) - copy(argCopy, mmGetPaginatedPipelineRunsByRequester.callArgs) + argCopy := make([]*RepositoryMockGetPipelineByIDAdminParams, len(mmGetPipelineByIDAdmin.callArgs)) + copy(argCopy, mmGetPipelineByIDAdmin.callArgs) - mmGetPaginatedPipelineRunsByRequester.mutex.RUnlock() + mmGetPipelineByIDAdmin.mutex.RUnlock() return argCopy } -// MinimockGetPaginatedPipelineRunsByRequesterDone returns true if the count of the GetPaginatedPipelineRunsByRequester invocations corresponds +// MinimockGetPipelineByIDAdminDone returns true if the count of the GetPipelineByIDAdmin invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsByRequesterDone() bool { - if m.GetPaginatedPipelineRunsByRequesterMock.optional { +func (m *RepositoryMock) MinimockGetPipelineByIDAdminDone() bool { + if m.GetPipelineByIDAdminMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPaginatedPipelineRunsByRequesterMock.expectations { + for _, e := range m.GetPipelineByIDAdminMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPaginatedPipelineRunsByRequesterMock.invocationsDone() + return m.GetPipelineByIDAdminMock.invocationsDone() } -// MinimockGetPaginatedPipelineRunsByRequesterInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsByRequesterInspect() { - for _, e := range m.GetPaginatedPipelineRunsByRequesterMock.expectations { +// MinimockGetPipelineByIDAdminInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPipelineByIDAdminInspect() { + for _, e := range m.GetPipelineByIDAdminMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPaginatedPipelineRunsByRequesterCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedPipelineRunsByRequesterCounter) + afterGetPipelineByIDAdminCounter := mm_atomic.LoadUint64(&m.afterGetPipelineByIDAdminCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation != nil && afterGetPaginatedPipelineRunsByRequesterCounter < 1 { - if m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s", m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.returnOrigin) + if m.GetPipelineByIDAdminMock.defaultExpectation != nil && afterGetPipelineByIDAdminCounter < 1 { + if m.GetPipelineByIDAdminMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s", m.GetPipelineByIDAdminMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s with params: %#v", m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedPipelineRunsByRequesterMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s with params: %#v", m.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineByIDAdminMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPaginatedPipelineRunsByRequester != nil && afterGetPaginatedPipelineRunsByRequesterCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s", m.funcGetPaginatedPipelineRunsByRequesterOrigin) + if m.funcGetPipelineByIDAdmin != nil && afterGetPipelineByIDAdminCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s", m.funcGetPipelineByIDAdminOrigin) } - if !m.GetPaginatedPipelineRunsByRequesterMock.invocationsDone() && afterGetPaginatedPipelineRunsByRequesterCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedPipelineRunsByRequester at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPaginatedPipelineRunsByRequesterMock.expectedInvocations), m.GetPaginatedPipelineRunsByRequesterMock.expectedInvocationsOrigin, afterGetPaginatedPipelineRunsByRequesterCounter) + if !m.GetPipelineByIDAdminMock.invocationsDone() && afterGetPipelineByIDAdminCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineByIDAdmin at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPipelineByIDAdminMock.expectedInvocations), m.GetPipelineByIDAdminMock.expectedInvocationsOrigin, afterGetPipelineByIDAdminCounter) } } -type mRepositoryMockGetPaginatedPipelineRunsWithPermissions struct { +type mRepositoryMockGetPipelineByUID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation - expectations []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation + defaultExpectation *RepositoryMockGetPipelineByUIDExpectation + expectations []*RepositoryMockGetPipelineByUIDExpectation - callArgs []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams + callArgs []*RepositoryMockGetPipelineByUIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation specifies expectation struct of the Repository.GetPaginatedPipelineRunsWithPermissions -type RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation struct { +// RepositoryMockGetPipelineByUIDExpectation specifies expectation struct of the Repository.GetPipelineByUID +type RepositoryMockGetPipelineByUIDExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams - paramPtrs *RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs - expectationOrigins RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins - results *RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults + params *RepositoryMockGetPipelineByUIDParams + paramPtrs *RepositoryMockGetPipelineByUIDParamPtrs + expectationOrigins RepositoryMockGetPipelineByUIDExpectationOrigins + results *RepositoryMockGetPipelineByUIDResults returnOrigin string Counter uint64 } -// RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams contains parameters of the Repository.GetPaginatedPipelineRunsWithPermissions -type RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams struct { - ctx context.Context - requesterUID string - pipelineUID string - page int - pageSize int - filter filtering.Filter - order ordering.OrderBy - isOwner bool +// RepositoryMockGetPipelineByUIDParams contains parameters of the Repository.GetPipelineByUID +type RepositoryMockGetPipelineByUIDParams struct { + ctx context.Context + uid uuid.UUID + isBasicView bool + embedReleases bool } -// RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs contains pointers to parameters of the Repository.GetPaginatedPipelineRunsWithPermissions -type RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs struct { - ctx *context.Context - requesterUID *string - pipelineUID *string - page *int - pageSize *int - filter *filtering.Filter - order *ordering.OrderBy - isOwner *bool +// RepositoryMockGetPipelineByUIDParamPtrs contains pointers to parameters of the Repository.GetPipelineByUID +type RepositoryMockGetPipelineByUIDParamPtrs struct { + ctx *context.Context + uid *uuid.UUID + isBasicView *bool + embedReleases *bool } -// RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults contains results of the Repository.GetPaginatedPipelineRunsWithPermissions -type RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults struct { - pa1 []datamodel.PipelineRun - i1 int64 +// RepositoryMockGetPipelineByUIDResults contains results of the Repository.GetPipelineByUID +type RepositoryMockGetPipelineByUIDResults struct { + pp1 *datamodel.Pipeline err error } -// RepositoryMockGetPaginatedPipelineRunsWithPermissionsOrigins contains origins of expectations of the Repository.GetPaginatedPipelineRunsWithPermissions -type RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins struct { - origin string - originCtx string - originRequesterUID string - originPipelineUID string - originPage string - originPageSize string - originFilter string - originOrder string - originIsOwner string +// RepositoryMockGetPipelineByUIDOrigins contains origins of expectations of the Repository.GetPipelineByUID +type RepositoryMockGetPipelineByUIDExpectationOrigins struct { + origin string + originCtx string + originUid string + originIsBasicView string + originEmbedReleases string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -9969,516 +10207,401 @@ type RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins str // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Optional() *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - mmGetPaginatedPipelineRunsWithPermissions.optional = true - return mmGetPaginatedPipelineRunsWithPermissions +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Optional() *mRepositoryMockGetPipelineByUID { + mmGetPipelineByUID.optional = true + return mmGetPipelineByUID } -// Expect sets up expected params for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Expect(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +// Expect sets up expected params for Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Expect(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) *mRepositoryMockGetPipelineByUID { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} + if mmGetPipelineByUID.defaultExpectation == nil { + mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by ExpectParams functions") + if mmGetPipelineByUID.defaultExpectation.paramPtrs != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by ExpectParams functions") } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner} - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPaginatedPipelineRunsWithPermissions.expectations { - if minimock.Equal(e.params, mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params) { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params) + mmGetPipelineByUID.defaultExpectation.params = &RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases} + mmGetPipelineByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPipelineByUID.expectations { + if minimock.Equal(e.params, mmGetPipelineByUID.defaultExpectation.params) { + mmGetPipelineByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineByUID.defaultExpectation.params) } } - return mmGetPaginatedPipelineRunsWithPermissions -} - -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} - } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmGetPaginatedPipelineRunsWithPermissions -} - -// ExpectRequesterUIDParam2 sets up expected param requesterUID for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectRequesterUIDParam2(requesterUID string) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} - } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.requesterUID = &requesterUID - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originRequesterUID = minimock.CallerInfo(1) - - return mmGetPaginatedPipelineRunsWithPermissions -} - -// ExpectPipelineUIDParam3 sets up expected param pipelineUID for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectPipelineUIDParam3(pipelineUID string) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} - } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.pipelineUID = &pipelineUID - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originPipelineUID = minimock.CallerInfo(1) - - return mmGetPaginatedPipelineRunsWithPermissions -} - -// ExpectPageParam4 sets up expected param page for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectPageParam4(page int) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") - } - - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} - } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.page = &page - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originPage = minimock.CallerInfo(1) - - return mmGetPaginatedPipelineRunsWithPermissions + return mmGetPipelineByUID } -// ExpectPageSizeParam5 sets up expected param pageSize for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectPageSizeParam5(pageSize int) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineByUID { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} + if mmGetPipelineByUID.defaultExpectation == nil { + mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") + if mmGetPipelineByUID.defaultExpectation.params != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} + if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { + mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.pageSize = &pageSize - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originPageSize = minimock.CallerInfo(1) + mmGetPipelineByUID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPipelineByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions + return mmGetPipelineByUID } -// ExpectFilterParam6 sets up expected param filter for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectFilterParam6(filter filtering.Filter) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +// ExpectUidParam2 sets up expected param uid for Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockGetPipelineByUID { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} + if mmGetPipelineByUID.defaultExpectation == nil { + mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") + if mmGetPipelineByUID.defaultExpectation.params != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} + if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { + mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.filter = &filter - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originFilter = minimock.CallerInfo(1) + mmGetPipelineByUID.defaultExpectation.paramPtrs.uid = &uid + mmGetPipelineByUID.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions + return mmGetPipelineByUID } -// ExpectOrderParam7 sets up expected param order for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectOrderParam7(order ordering.OrderBy) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +// ExpectIsBasicViewParam3 sets up expected param isBasicView for Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectIsBasicViewParam3(isBasicView bool) *mRepositoryMockGetPipelineByUID { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} + if mmGetPipelineByUID.defaultExpectation == nil { + mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") + if mmGetPipelineByUID.defaultExpectation.params != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} + if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { + mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.order = &order - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originOrder = minimock.CallerInfo(1) + mmGetPipelineByUID.defaultExpectation.paramPtrs.isBasicView = &isBasicView + mmGetPipelineByUID.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions + return mmGetPipelineByUID } -// ExpectIsOwnerParam8 sets up expected param isOwner for Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) ExpectIsOwnerParam8(isOwner bool) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +// ExpectEmbedReleasesParam4 sets up expected param embedReleases for Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectEmbedReleasesParam4(embedReleases bool) *mRepositoryMockGetPipelineByUID { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{} + if mmGetPipelineByUID.defaultExpectation == nil { + mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.params != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Expect") + if mmGetPipelineByUID.defaultExpectation.params != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParamPtrs{} + if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { + mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.paramPtrs.isOwner = &isOwner - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.expectationOrigins.originIsOwner = minimock.CallerInfo(1) + mmGetPipelineByUID.defaultExpectation.paramPtrs.embedReleases = &embedReleases + mmGetPipelineByUID.defaultExpectation.expectationOrigins.originEmbedReleases = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions + return mmGetPipelineByUID } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Inspect(f func(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool)) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { - if mmGetPaginatedPipelineRunsWithPermissions.mock.inspectFuncGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedPipelineRunsWithPermissions") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Inspect(f func(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool)) *mRepositoryMockGetPipelineByUID { + if mmGetPipelineByUID.mock.inspectFuncGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineByUID") } - mmGetPaginatedPipelineRunsWithPermissions.mock.inspectFuncGetPaginatedPipelineRunsWithPermissions = f + mmGetPipelineByUID.mock.inspectFuncGetPipelineByUID = f - return mmGetPaginatedPipelineRunsWithPermissions + return mmGetPipelineByUID } -// Return sets up results that will be returned by Repository.GetPaginatedPipelineRunsWithPermissions -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Return(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +// Return sets up results that will be returned by Repository.GetPipelineByUID +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Return(pp1 *datamodel.Pipeline, err error) *RepositoryMock { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil { - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{mock: mmGetPaginatedPipelineRunsWithPermissions.mock} + if mmGetPipelineByUID.defaultExpectation == nil { + mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{mock: mmGetPipelineByUID.mock} } - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.results = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults{pa1, i1, err} - mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions.mock + mmGetPipelineByUID.defaultExpectation.results = &RepositoryMockGetPipelineByUIDResults{pp1, err} + mmGetPipelineByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPipelineByUID.mock } -// Set uses given function f to mock the Repository.GetPaginatedPipelineRunsWithPermissions method -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Set(f func(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) (pa1 []datamodel.PipelineRun, i1 int64, err error)) *RepositoryMock { - if mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedPipelineRunsWithPermissions method") +// Set uses given function f to mock the Repository.GetPipelineByUID method +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Set(f func(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error)) *RepositoryMock { + if mmGetPipelineByUID.defaultExpectation != nil { + mmGetPipelineByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineByUID method") } - if len(mmGetPaginatedPipelineRunsWithPermissions.expectations) > 0 { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedPipelineRunsWithPermissions method") + if len(mmGetPipelineByUID.expectations) > 0 { + mmGetPipelineByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineByUID method") } - mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions = f - mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissionsOrigin = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions.mock + mmGetPipelineByUID.mock.funcGetPipelineByUID = f + mmGetPipelineByUID.mock.funcGetPipelineByUIDOrigin = minimock.CallerInfo(1) + return mmGetPipelineByUID.mock } -// When sets expectation for the Repository.GetPaginatedPipelineRunsWithPermissions which will trigger the result defined by the following +// When sets expectation for the Repository.GetPipelineByUID which will trigger the result defined by the following // Then helper -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) When(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) *RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation { - if mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock is already set by Set") +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) When(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) *RepositoryMockGetPipelineByUIDExpectation { + if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { + mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") } - expectation := &RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation{ - mock: mmGetPaginatedPipelineRunsWithPermissions.mock, - params: &RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner}, - expectationOrigins: RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetPipelineByUIDExpectation{ + mock: mmGetPipelineByUID.mock, + params: &RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases}, + expectationOrigins: RepositoryMockGetPipelineByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPaginatedPipelineRunsWithPermissions.expectations = append(mmGetPaginatedPipelineRunsWithPermissions.expectations, expectation) + mmGetPipelineByUID.expectations = append(mmGetPipelineByUID.expectations, expectation) return expectation } -// Then sets up Repository.GetPaginatedPipelineRunsWithPermissions return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPaginatedPipelineRunsWithPermissionsExpectation) Then(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock { - e.results = &RepositoryMockGetPaginatedPipelineRunsWithPermissionsResults{pa1, i1, err} +// Then sets up Repository.GetPipelineByUID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPipelineByUIDExpectation) Then(pp1 *datamodel.Pipeline, err error) *RepositoryMock { + e.results = &RepositoryMockGetPipelineByUIDResults{pp1, err} return e.mock } -// Times sets number of times Repository.GetPaginatedPipelineRunsWithPermissions should be invoked -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Times(n uint64) *mRepositoryMockGetPaginatedPipelineRunsWithPermissions { +// Times sets number of times Repository.GetPipelineByUID should be invoked +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Times(n uint64) *mRepositoryMockGetPipelineByUID { if n == 0 { - mmGetPaginatedPipelineRunsWithPermissions.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedPipelineRunsWithPermissions mock can not be zero") + mmGetPipelineByUID.mock.t.Fatalf("Times of RepositoryMock.GetPipelineByUID mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPaginatedPipelineRunsWithPermissions.expectedInvocations, n) - mmGetPaginatedPipelineRunsWithPermissions.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPaginatedPipelineRunsWithPermissions + mm_atomic.StoreUint64(&mmGetPipelineByUID.expectedInvocations, n) + mmGetPipelineByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPipelineByUID } -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) invocationsDone() bool { - if len(mmGetPaginatedPipelineRunsWithPermissions.expectations) == 0 && mmGetPaginatedPipelineRunsWithPermissions.defaultExpectation == nil && mmGetPaginatedPipelineRunsWithPermissions.mock.funcGetPaginatedPipelineRunsWithPermissions == nil { +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) invocationsDone() bool { + if len(mmGetPipelineByUID.expectations) == 0 && mmGetPipelineByUID.defaultExpectation == nil && mmGetPipelineByUID.mock.funcGetPipelineByUID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.mock.afterGetPaginatedPipelineRunsWithPermissionsCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineByUID.mock.afterGetPipelineByUIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineByUID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPaginatedPipelineRunsWithPermissions implements mm_repository.Repository -func (mmGetPaginatedPipelineRunsWithPermissions *RepositoryMock) GetPaginatedPipelineRunsWithPermissions(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) (pa1 []datamodel.PipelineRun, i1 int64, err error) { - mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsWithPermissions.beforeGetPaginatedPipelineRunsWithPermissionsCounter, 1) - defer mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsWithPermissions.afterGetPaginatedPipelineRunsWithPermissionsCounter, 1) +// GetPipelineByUID implements mm_repository.Repository +func (mmGetPipelineByUID *RepositoryMock) GetPipelineByUID(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error) { + mm_atomic.AddUint64(&mmGetPipelineByUID.beforeGetPipelineByUIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetPipelineByUID.afterGetPipelineByUIDCounter, 1) - mmGetPaginatedPipelineRunsWithPermissions.t.Helper() + mmGetPipelineByUID.t.Helper() - if mmGetPaginatedPipelineRunsWithPermissions.inspectFuncGetPaginatedPipelineRunsWithPermissions != nil { - mmGetPaginatedPipelineRunsWithPermissions.inspectFuncGetPaginatedPipelineRunsWithPermissions(ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner) + if mmGetPipelineByUID.inspectFuncGetPipelineByUID != nil { + mmGetPipelineByUID.inspectFuncGetPipelineByUID(ctx, uid, isBasicView, embedReleases) } - mm_params := RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner} + mm_params := RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases} // Record call args - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.mutex.Lock() - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.callArgs = append(mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.callArgs, &mm_params) - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.mutex.Unlock() + mmGetPipelineByUID.GetPipelineByUIDMock.mutex.Lock() + mmGetPipelineByUID.GetPipelineByUIDMock.callArgs = append(mmGetPipelineByUID.GetPipelineByUIDMock.callArgs, &mm_params) + mmGetPipelineByUID.GetPipelineByUIDMock.mutex.Unlock() - for _, e := range mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.expectations { + for _, e := range mmGetPipelineByUID.GetPipelineByUIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.pa1, e.results.i1, e.results.err + return e.results.pp1, e.results.err } } - if mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.Counter, 1) - mm_want := mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.params - mm_want_ptrs := mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.paramPtrs + if mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.params + mm_want_ptrs := mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner} + mm_got := RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.requesterUID != nil && !minimock.Equal(*mm_want_ptrs.requesterUID, mm_got.requesterUID) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter requesterUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originRequesterUID, *mm_want_ptrs.requesterUID, mm_got.requesterUID, minimock.Diff(*mm_want_ptrs.requesterUID, mm_got.requesterUID)) - } - - if mm_want_ptrs.pipelineUID != nil && !minimock.Equal(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter pipelineUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originPipelineUID, *mm_want_ptrs.pipelineUID, mm_got.pipelineUID, minimock.Diff(*mm_want_ptrs.pipelineUID, mm_got.pipelineUID)) - } - - if mm_want_ptrs.page != nil && !minimock.Equal(*mm_want_ptrs.page, mm_got.page) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter page, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originPage, *mm_want_ptrs.page, mm_got.page, minimock.Diff(*mm_want_ptrs.page, mm_got.page)) - } - - if mm_want_ptrs.pageSize != nil && !minimock.Equal(*mm_want_ptrs.pageSize, mm_got.pageSize) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter pageSize, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originPageSize, *mm_want_ptrs.pageSize, mm_got.pageSize, minimock.Diff(*mm_want_ptrs.pageSize, mm_got.pageSize)) + mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.filter != nil && !minimock.Equal(*mm_want_ptrs.filter, mm_got.filter) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter filter, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originFilter, *mm_want_ptrs.filter, mm_got.filter, minimock.Diff(*mm_want_ptrs.filter, mm_got.filter)) + if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { + mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) } - if mm_want_ptrs.order != nil && !minimock.Equal(*mm_want_ptrs.order, mm_got.order) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter order, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originOrder, *mm_want_ptrs.order, mm_got.order, minimock.Diff(*mm_want_ptrs.order, mm_got.order)) + if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { + mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) } - if mm_want_ptrs.isOwner != nil && !minimock.Equal(*mm_want_ptrs.isOwner, mm_got.isOwner) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameter isOwner, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.originIsOwner, *mm_want_ptrs.isOwner, mm_got.isOwner, minimock.Diff(*mm_want_ptrs.isOwner, mm_got.isOwner)) + if mm_want_ptrs.embedReleases != nil && !minimock.Equal(*mm_want_ptrs.embedReleases, mm_got.embedReleases) { + mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter embedReleases, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originEmbedReleases, *mm_want_ptrs.embedReleases, mm_got.embedReleases, minimock.Diff(*mm_want_ptrs.embedReleases, mm_got.embedReleases)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPaginatedPipelineRunsWithPermissions.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsWithPermissions got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPaginatedPipelineRunsWithPermissions.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.results + mm_results := mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.results if mm_results == nil { - mmGetPaginatedPipelineRunsWithPermissions.t.Fatal("No results are set for the RepositoryMock.GetPaginatedPipelineRunsWithPermissions") + mmGetPipelineByUID.t.Fatal("No results are set for the RepositoryMock.GetPipelineByUID") } - return (*mm_results).pa1, (*mm_results).i1, (*mm_results).err + return (*mm_results).pp1, (*mm_results).err } - if mmGetPaginatedPipelineRunsWithPermissions.funcGetPaginatedPipelineRunsWithPermissions != nil { - return mmGetPaginatedPipelineRunsWithPermissions.funcGetPaginatedPipelineRunsWithPermissions(ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner) + if mmGetPipelineByUID.funcGetPipelineByUID != nil { + return mmGetPipelineByUID.funcGetPipelineByUID(ctx, uid, isBasicView, embedReleases) } - mmGetPaginatedPipelineRunsWithPermissions.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions. %v %v %v %v %v %v %v %v", ctx, requesterUID, pipelineUID, page, pageSize, filter, order, isOwner) + mmGetPipelineByUID.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineByUID. %v %v %v %v", ctx, uid, isBasicView, embedReleases) return } -// GetPaginatedPipelineRunsWithPermissionsAfterCounter returns a count of finished RepositoryMock.GetPaginatedPipelineRunsWithPermissions invocations -func (mmGetPaginatedPipelineRunsWithPermissions *RepositoryMock) GetPaginatedPipelineRunsWithPermissionsAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.afterGetPaginatedPipelineRunsWithPermissionsCounter) +// GetPipelineByUIDAfterCounter returns a count of finished RepositoryMock.GetPipelineByUID invocations +func (mmGetPipelineByUID *RepositoryMock) GetPipelineByUIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineByUID.afterGetPipelineByUIDCounter) } -// GetPaginatedPipelineRunsWithPermissionsBeforeCounter returns a count of RepositoryMock.GetPaginatedPipelineRunsWithPermissions invocations -func (mmGetPaginatedPipelineRunsWithPermissions *RepositoryMock) GetPaginatedPipelineRunsWithPermissionsBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsWithPermissions.beforeGetPaginatedPipelineRunsWithPermissionsCounter) +// GetPipelineByUIDBeforeCounter returns a count of RepositoryMock.GetPipelineByUID invocations +func (mmGetPipelineByUID *RepositoryMock) GetPipelineByUIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineByUID.beforeGetPipelineByUIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineByUID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPaginatedPipelineRunsWithPermissions *mRepositoryMockGetPaginatedPipelineRunsWithPermissions) Calls() []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams { - mmGetPaginatedPipelineRunsWithPermissions.mutex.RLock() +func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Calls() []*RepositoryMockGetPipelineByUIDParams { + mmGetPipelineByUID.mutex.RLock() - argCopy := make([]*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams, len(mmGetPaginatedPipelineRunsWithPermissions.callArgs)) - copy(argCopy, mmGetPaginatedPipelineRunsWithPermissions.callArgs) + argCopy := make([]*RepositoryMockGetPipelineByUIDParams, len(mmGetPipelineByUID.callArgs)) + copy(argCopy, mmGetPipelineByUID.callArgs) - mmGetPaginatedPipelineRunsWithPermissions.mutex.RUnlock() + mmGetPipelineByUID.mutex.RUnlock() return argCopy } -// MinimockGetPaginatedPipelineRunsWithPermissionsDone returns true if the count of the GetPaginatedPipelineRunsWithPermissions invocations corresponds +// MinimockGetPipelineByUIDDone returns true if the count of the GetPipelineByUID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsWithPermissionsDone() bool { - if m.GetPaginatedPipelineRunsWithPermissionsMock.optional { +func (m *RepositoryMock) MinimockGetPipelineByUIDDone() bool { + if m.GetPipelineByUIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPaginatedPipelineRunsWithPermissionsMock.expectations { + for _, e := range m.GetPipelineByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPaginatedPipelineRunsWithPermissionsMock.invocationsDone() + return m.GetPipelineByUIDMock.invocationsDone() } -// MinimockGetPaginatedPipelineRunsWithPermissionsInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsWithPermissionsInspect() { - for _, e := range m.GetPaginatedPipelineRunsWithPermissionsMock.expectations { +// MinimockGetPipelineByUIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPipelineByUIDInspect() { + for _, e := range m.GetPipelineByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPaginatedPipelineRunsWithPermissionsCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedPipelineRunsWithPermissionsCounter) + afterGetPipelineByUIDCounter := mm_atomic.LoadUint64(&m.afterGetPipelineByUIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation != nil && afterGetPaginatedPipelineRunsWithPermissionsCounter < 1 { - if m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s", m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.returnOrigin) + if m.GetPipelineByUIDMock.defaultExpectation != nil && afterGetPipelineByUIDCounter < 1 { + if m.GetPipelineByUIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s", m.GetPipelineByUIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s with params: %#v", m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedPipelineRunsWithPermissionsMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s with params: %#v", m.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineByUIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPaginatedPipelineRunsWithPermissions != nil && afterGetPaginatedPipelineRunsWithPermissionsCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s", m.funcGetPaginatedPipelineRunsWithPermissionsOrigin) + if m.funcGetPipelineByUID != nil && afterGetPipelineByUIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s", m.funcGetPipelineByUIDOrigin) } - if !m.GetPaginatedPipelineRunsWithPermissionsMock.invocationsDone() && afterGetPaginatedPipelineRunsWithPermissionsCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedPipelineRunsWithPermissions at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPaginatedPipelineRunsWithPermissionsMock.expectedInvocations), m.GetPaginatedPipelineRunsWithPermissionsMock.expectedInvocationsOrigin, afterGetPaginatedPipelineRunsWithPermissionsCounter) + if !m.GetPipelineByUIDMock.invocationsDone() && afterGetPipelineByUIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineByUID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPipelineByUIDMock.expectedInvocations), m.GetPipelineByUIDMock.expectedInvocationsOrigin, afterGetPipelineByUIDCounter) } } -type mRepositoryMockGetPipelineByIDAdmin struct { +type mRepositoryMockGetPipelineReleaseByUIDAdmin struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPipelineByIDAdminExpectation - expectations []*RepositoryMockGetPipelineByIDAdminExpectation + defaultExpectation *RepositoryMockGetPipelineReleaseByUIDAdminExpectation + expectations []*RepositoryMockGetPipelineReleaseByUIDAdminExpectation - callArgs []*RepositoryMockGetPipelineByIDAdminParams + callArgs []*RepositoryMockGetPipelineReleaseByUIDAdminParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPipelineByIDAdminExpectation specifies expectation struct of the Repository.GetPipelineByIDAdmin -type RepositoryMockGetPipelineByIDAdminExpectation struct { +// RepositoryMockGetPipelineReleaseByUIDAdminExpectation specifies expectation struct of the Repository.GetPipelineReleaseByUIDAdmin +type RepositoryMockGetPipelineReleaseByUIDAdminExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPipelineByIDAdminParams - paramPtrs *RepositoryMockGetPipelineByIDAdminParamPtrs - expectationOrigins RepositoryMockGetPipelineByIDAdminExpectationOrigins - results *RepositoryMockGetPipelineByIDAdminResults + params *RepositoryMockGetPipelineReleaseByUIDAdminParams + paramPtrs *RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs + expectationOrigins RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins + results *RepositoryMockGetPipelineReleaseByUIDAdminResults returnOrigin string Counter uint64 } -// RepositoryMockGetPipelineByIDAdminParams contains parameters of the Repository.GetPipelineByIDAdmin -type RepositoryMockGetPipelineByIDAdminParams struct { - ctx context.Context - id string - isBasicView bool - embedReleases bool +// RepositoryMockGetPipelineReleaseByUIDAdminParams contains parameters of the Repository.GetPipelineReleaseByUIDAdmin +type RepositoryMockGetPipelineReleaseByUIDAdminParams struct { + ctx context.Context + uid uuid.UUID + isBasicView bool } -// RepositoryMockGetPipelineByIDAdminParamPtrs contains pointers to parameters of the Repository.GetPipelineByIDAdmin -type RepositoryMockGetPipelineByIDAdminParamPtrs struct { - ctx *context.Context - id *string - isBasicView *bool - embedReleases *bool +// RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs contains pointers to parameters of the Repository.GetPipelineReleaseByUIDAdmin +type RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs struct { + ctx *context.Context + uid *uuid.UUID + isBasicView *bool } -// RepositoryMockGetPipelineByIDAdminResults contains results of the Repository.GetPipelineByIDAdmin -type RepositoryMockGetPipelineByIDAdminResults struct { - pp1 *datamodel.Pipeline +// RepositoryMockGetPipelineReleaseByUIDAdminResults contains results of the Repository.GetPipelineReleaseByUIDAdmin +type RepositoryMockGetPipelineReleaseByUIDAdminResults struct { + pp1 *datamodel.PipelineRelease err error } -// RepositoryMockGetPipelineByIDAdminOrigins contains origins of expectations of the Repository.GetPipelineByIDAdmin -type RepositoryMockGetPipelineByIDAdminExpectationOrigins struct { - origin string - originCtx string - originId string - originIsBasicView string - originEmbedReleases string +// RepositoryMockGetPipelineReleaseByUIDAdminOrigins contains origins of expectations of the Repository.GetPipelineReleaseByUIDAdmin +type RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins struct { + origin string + originCtx string + originUid string + originIsBasicView string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -10486,404 +10609,370 @@ type RepositoryMockGetPipelineByIDAdminExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Optional() *mRepositoryMockGetPipelineByIDAdmin { - mmGetPipelineByIDAdmin.optional = true - return mmGetPipelineByIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Optional() *mRepositoryMockGetPipelineReleaseByUIDAdmin { + mmGetPipelineReleaseByUIDAdmin.optional = true + return mmGetPipelineReleaseByUIDAdmin } -// Expect sets up expected params for Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Expect(ctx context.Context, id string, isBasicView bool, embedReleases bool) *mRepositoryMockGetPipelineByIDAdmin { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") +// Expect sets up expected params for Repository.GetPipelineReleaseByUIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Expect(ctx context.Context, uid uuid.UUID, isBasicView bool) *mRepositoryMockGetPipelineReleaseByUIDAdmin { + if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") } - if mmGetPipelineByIDAdmin.defaultExpectation == nil { - mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} } - if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by ExpectParams functions") + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by ExpectParams functions") } - mmGetPipelineByIDAdmin.defaultExpectation.params = &RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases} - mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPipelineByIDAdmin.expectations { - if minimock.Equal(e.params, mmGetPipelineByIDAdmin.defaultExpectation.params) { - mmGetPipelineByIDAdmin.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineByIDAdmin.defaultExpectation.params) + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params = &RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView} + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPipelineReleaseByUIDAdmin.expectations { + if minimock.Equal(e.params, mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params) { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params) } } - return mmGetPipelineByIDAdmin -} - -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineByIDAdmin { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") - } - - if mmGetPipelineByIDAdmin.defaultExpectation == nil { - mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} - } - - if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") - } - - if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} - } - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmGetPipelineByIDAdmin + return mmGetPipelineReleaseByUIDAdmin } -// ExpectIdParam2 sets up expected param id for Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectIdParam2(id string) *mRepositoryMockGetPipelineByIDAdmin { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineReleaseByUIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineReleaseByUIDAdmin { + if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") } - if mmGetPipelineByIDAdmin.defaultExpectation == nil { - mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} } - if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Expect") } - if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs{} } - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.id = &id - mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originId = minimock.CallerInfo(1) + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPipelineByIDAdmin + return mmGetPipelineReleaseByUIDAdmin } -// ExpectIsBasicViewParam3 sets up expected param isBasicView for Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectIsBasicViewParam3(isBasicView bool) *mRepositoryMockGetPipelineByIDAdmin { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") +// ExpectUidParam2 sets up expected param uid for Repository.GetPipelineReleaseByUIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockGetPipelineReleaseByUIDAdmin { + if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") } - if mmGetPipelineByIDAdmin.defaultExpectation == nil { - mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} } - if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Expect") } - if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs{} } - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.isBasicView = &isBasicView - mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs.uid = &uid + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - return mmGetPipelineByIDAdmin + return mmGetPipelineReleaseByUIDAdmin } -// ExpectEmbedReleasesParam4 sets up expected param embedReleases for Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) ExpectEmbedReleasesParam4(embedReleases bool) *mRepositoryMockGetPipelineByIDAdmin { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") +// ExpectIsBasicViewParam3 sets up expected param isBasicView for Repository.GetPipelineReleaseByUIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) ExpectIsBasicViewParam3(isBasicView bool) *mRepositoryMockGetPipelineReleaseByUIDAdmin { + if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") } - if mmGetPipelineByIDAdmin.defaultExpectation == nil { - mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} } - if mmGetPipelineByIDAdmin.defaultExpectation.params != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Expect") + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Expect") } - if mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByIDAdminParamPtrs{} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs{} } - mmGetPipelineByIDAdmin.defaultExpectation.paramPtrs.embedReleases = &embedReleases - mmGetPipelineByIDAdmin.defaultExpectation.expectationOrigins.originEmbedReleases = minimock.CallerInfo(1) + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs.isBasicView = &isBasicView + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) - return mmGetPipelineByIDAdmin + return mmGetPipelineReleaseByUIDAdmin } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Inspect(f func(ctx context.Context, id string, isBasicView bool, embedReleases bool)) *mRepositoryMockGetPipelineByIDAdmin { - if mmGetPipelineByIDAdmin.mock.inspectFuncGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineByIDAdmin") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineReleaseByUIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Inspect(f func(ctx context.Context, uid uuid.UUID, isBasicView bool)) *mRepositoryMockGetPipelineReleaseByUIDAdmin { + if mmGetPipelineReleaseByUIDAdmin.mock.inspectFuncGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineReleaseByUIDAdmin") } - mmGetPipelineByIDAdmin.mock.inspectFuncGetPipelineByIDAdmin = f + mmGetPipelineReleaseByUIDAdmin.mock.inspectFuncGetPipelineReleaseByUIDAdmin = f - return mmGetPipelineByIDAdmin + return mmGetPipelineReleaseByUIDAdmin } -// Return sets up results that will be returned by Repository.GetPipelineByIDAdmin -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Return(pp1 *datamodel.Pipeline, err error) *RepositoryMock { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") +// Return sets up results that will be returned by Repository.GetPipelineReleaseByUIDAdmin +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Return(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { + if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") } - if mmGetPipelineByIDAdmin.defaultExpectation == nil { - mmGetPipelineByIDAdmin.defaultExpectation = &RepositoryMockGetPipelineByIDAdminExpectation{mock: mmGetPipelineByIDAdmin.mock} + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { + mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{mock: mmGetPipelineReleaseByUIDAdmin.mock} } - mmGetPipelineByIDAdmin.defaultExpectation.results = &RepositoryMockGetPipelineByIDAdminResults{pp1, err} - mmGetPipelineByIDAdmin.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPipelineByIDAdmin.mock + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.results = &RepositoryMockGetPipelineReleaseByUIDAdminResults{pp1, err} + mmGetPipelineReleaseByUIDAdmin.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPipelineReleaseByUIDAdmin.mock } -// Set uses given function f to mock the Repository.GetPipelineByIDAdmin method -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Set(f func(ctx context.Context, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error)) *RepositoryMock { - if mmGetPipelineByIDAdmin.defaultExpectation != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineByIDAdmin method") +// Set uses given function f to mock the Repository.GetPipelineReleaseByUIDAdmin method +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Set(f func(ctx context.Context, uid uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error)) *RepositoryMock { + if mmGetPipelineReleaseByUIDAdmin.defaultExpectation != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineReleaseByUIDAdmin method") } - if len(mmGetPipelineByIDAdmin.expectations) > 0 { - mmGetPipelineByIDAdmin.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineByIDAdmin method") + if len(mmGetPipelineReleaseByUIDAdmin.expectations) > 0 { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineReleaseByUIDAdmin method") } - mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin = f - mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdminOrigin = minimock.CallerInfo(1) - return mmGetPipelineByIDAdmin.mock + mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin = f + mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdminOrigin = minimock.CallerInfo(1) + return mmGetPipelineReleaseByUIDAdmin.mock } -// When sets expectation for the Repository.GetPipelineByIDAdmin which will trigger the result defined by the following +// When sets expectation for the Repository.GetPipelineReleaseByUIDAdmin which will trigger the result defined by the following // Then helper -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) When(ctx context.Context, id string, isBasicView bool, embedReleases bool) *RepositoryMockGetPipelineByIDAdminExpectation { - if mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineByIDAdmin mock is already set by Set") +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) When(ctx context.Context, uid uuid.UUID, isBasicView bool) *RepositoryMockGetPipelineReleaseByUIDAdminExpectation { + if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") } - expectation := &RepositoryMockGetPipelineByIDAdminExpectation{ - mock: mmGetPipelineByIDAdmin.mock, - params: &RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases}, - expectationOrigins: RepositoryMockGetPipelineByIDAdminExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{ + mock: mmGetPipelineReleaseByUIDAdmin.mock, + params: &RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView}, + expectationOrigins: RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPipelineByIDAdmin.expectations = append(mmGetPipelineByIDAdmin.expectations, expectation) + mmGetPipelineReleaseByUIDAdmin.expectations = append(mmGetPipelineReleaseByUIDAdmin.expectations, expectation) return expectation } -// Then sets up Repository.GetPipelineByIDAdmin return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPipelineByIDAdminExpectation) Then(pp1 *datamodel.Pipeline, err error) *RepositoryMock { - e.results = &RepositoryMockGetPipelineByIDAdminResults{pp1, err} +// Then sets up Repository.GetPipelineReleaseByUIDAdmin return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPipelineReleaseByUIDAdminExpectation) Then(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { + e.results = &RepositoryMockGetPipelineReleaseByUIDAdminResults{pp1, err} return e.mock } -// Times sets number of times Repository.GetPipelineByIDAdmin should be invoked -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Times(n uint64) *mRepositoryMockGetPipelineByIDAdmin { +// Times sets number of times Repository.GetPipelineReleaseByUIDAdmin should be invoked +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Times(n uint64) *mRepositoryMockGetPipelineReleaseByUIDAdmin { if n == 0 { - mmGetPipelineByIDAdmin.mock.t.Fatalf("Times of RepositoryMock.GetPipelineByIDAdmin mock can not be zero") + mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Times of RepositoryMock.GetPipelineReleaseByUIDAdmin mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPipelineByIDAdmin.expectedInvocations, n) - mmGetPipelineByIDAdmin.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPipelineByIDAdmin + mm_atomic.StoreUint64(&mmGetPipelineReleaseByUIDAdmin.expectedInvocations, n) + mmGetPipelineReleaseByUIDAdmin.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPipelineReleaseByUIDAdmin } -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) invocationsDone() bool { - if len(mmGetPipelineByIDAdmin.expectations) == 0 && mmGetPipelineByIDAdmin.defaultExpectation == nil && mmGetPipelineByIDAdmin.mock.funcGetPipelineByIDAdmin == nil { +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) invocationsDone() bool { + if len(mmGetPipelineReleaseByUIDAdmin.expectations) == 0 && mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil && mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.mock.afterGetPipelineByIDAdminCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.mock.afterGetPipelineReleaseByUIDAdminCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPipelineByIDAdmin implements mm_repository.Repository -func (mmGetPipelineByIDAdmin *RepositoryMock) GetPipelineByIDAdmin(ctx context.Context, id string, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error) { - mm_atomic.AddUint64(&mmGetPipelineByIDAdmin.beforeGetPipelineByIDAdminCounter, 1) - defer mm_atomic.AddUint64(&mmGetPipelineByIDAdmin.afterGetPipelineByIDAdminCounter, 1) +// GetPipelineReleaseByUIDAdmin implements mm_repository.Repository +func (mmGetPipelineReleaseByUIDAdmin *RepositoryMock) GetPipelineReleaseByUIDAdmin(ctx context.Context, uid uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error) { + mm_atomic.AddUint64(&mmGetPipelineReleaseByUIDAdmin.beforeGetPipelineReleaseByUIDAdminCounter, 1) + defer mm_atomic.AddUint64(&mmGetPipelineReleaseByUIDAdmin.afterGetPipelineReleaseByUIDAdminCounter, 1) - mmGetPipelineByIDAdmin.t.Helper() + mmGetPipelineReleaseByUIDAdmin.t.Helper() - if mmGetPipelineByIDAdmin.inspectFuncGetPipelineByIDAdmin != nil { - mmGetPipelineByIDAdmin.inspectFuncGetPipelineByIDAdmin(ctx, id, isBasicView, embedReleases) + if mmGetPipelineReleaseByUIDAdmin.inspectFuncGetPipelineReleaseByUIDAdmin != nil { + mmGetPipelineReleaseByUIDAdmin.inspectFuncGetPipelineReleaseByUIDAdmin(ctx, uid, isBasicView) } - mm_params := RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases} + mm_params := RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView} // Record call args - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.mutex.Lock() - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.callArgs = append(mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.callArgs, &mm_params) - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.mutex.Unlock() + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.mutex.Lock() + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.callArgs = append(mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.callArgs, &mm_params) + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.mutex.Unlock() - for _, e := range mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.expectations { + for _, e := range mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.pp1, e.results.err } } - if mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.Counter, 1) - mm_want := mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.params - mm_want_ptrs := mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.paramPtrs + if mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.Counter, 1) + mm_want := mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.params + mm_want_ptrs := mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPipelineByIDAdminParams{ctx, id, isBasicView, embedReleases} + mm_got := RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.id != nil && !minimock.Equal(*mm_want_ptrs.id, mm_got.id) { - mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter id, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originId, *mm_want_ptrs.id, mm_got.id, minimock.Diff(*mm_want_ptrs.id, mm_got.id)) + if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { + mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) } if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { - mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) - } - - if mm_want_ptrs.embedReleases != nil && !minimock.Equal(*mm_want_ptrs.embedReleases, mm_got.embedReleases) { - mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameter embedReleases, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.originEmbedReleases, *mm_want_ptrs.embedReleases, mm_got.embedReleases, minimock.Diff(*mm_want_ptrs.embedReleases, mm_got.embedReleases)) + mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPipelineByIDAdmin.t.Errorf("RepositoryMock.GetPipelineByIDAdmin got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPipelineByIDAdmin.GetPipelineByIDAdminMock.defaultExpectation.results + mm_results := mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.results if mm_results == nil { - mmGetPipelineByIDAdmin.t.Fatal("No results are set for the RepositoryMock.GetPipelineByIDAdmin") + mmGetPipelineReleaseByUIDAdmin.t.Fatal("No results are set for the RepositoryMock.GetPipelineReleaseByUIDAdmin") } return (*mm_results).pp1, (*mm_results).err } - if mmGetPipelineByIDAdmin.funcGetPipelineByIDAdmin != nil { - return mmGetPipelineByIDAdmin.funcGetPipelineByIDAdmin(ctx, id, isBasicView, embedReleases) + if mmGetPipelineReleaseByUIDAdmin.funcGetPipelineReleaseByUIDAdmin != nil { + return mmGetPipelineReleaseByUIDAdmin.funcGetPipelineReleaseByUIDAdmin(ctx, uid, isBasicView) } - mmGetPipelineByIDAdmin.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineByIDAdmin. %v %v %v %v", ctx, id, isBasicView, embedReleases) + mmGetPipelineReleaseByUIDAdmin.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineReleaseByUIDAdmin. %v %v %v", ctx, uid, isBasicView) return } -// GetPipelineByIDAdminAfterCounter returns a count of finished RepositoryMock.GetPipelineByIDAdmin invocations -func (mmGetPipelineByIDAdmin *RepositoryMock) GetPipelineByIDAdminAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.afterGetPipelineByIDAdminCounter) +// GetPipelineReleaseByUIDAdminAfterCounter returns a count of finished RepositoryMock.GetPipelineReleaseByUIDAdmin invocations +func (mmGetPipelineReleaseByUIDAdmin *RepositoryMock) GetPipelineReleaseByUIDAdminAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.afterGetPipelineReleaseByUIDAdminCounter) } -// GetPipelineByIDAdminBeforeCounter returns a count of RepositoryMock.GetPipelineByIDAdmin invocations -func (mmGetPipelineByIDAdmin *RepositoryMock) GetPipelineByIDAdminBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineByIDAdmin.beforeGetPipelineByIDAdminCounter) +// GetPipelineReleaseByUIDAdminBeforeCounter returns a count of RepositoryMock.GetPipelineReleaseByUIDAdmin invocations +func (mmGetPipelineReleaseByUIDAdmin *RepositoryMock) GetPipelineReleaseByUIDAdminBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.beforeGetPipelineReleaseByUIDAdminCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineByIDAdmin. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineReleaseByUIDAdmin. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPipelineByIDAdmin *mRepositoryMockGetPipelineByIDAdmin) Calls() []*RepositoryMockGetPipelineByIDAdminParams { - mmGetPipelineByIDAdmin.mutex.RLock() +func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Calls() []*RepositoryMockGetPipelineReleaseByUIDAdminParams { + mmGetPipelineReleaseByUIDAdmin.mutex.RLock() - argCopy := make([]*RepositoryMockGetPipelineByIDAdminParams, len(mmGetPipelineByIDAdmin.callArgs)) - copy(argCopy, mmGetPipelineByIDAdmin.callArgs) + argCopy := make([]*RepositoryMockGetPipelineReleaseByUIDAdminParams, len(mmGetPipelineReleaseByUIDAdmin.callArgs)) + copy(argCopy, mmGetPipelineReleaseByUIDAdmin.callArgs) - mmGetPipelineByIDAdmin.mutex.RUnlock() + mmGetPipelineReleaseByUIDAdmin.mutex.RUnlock() return argCopy } -// MinimockGetPipelineByIDAdminDone returns true if the count of the GetPipelineByIDAdmin invocations corresponds +// MinimockGetPipelineReleaseByUIDAdminDone returns true if the count of the GetPipelineReleaseByUIDAdmin invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPipelineByIDAdminDone() bool { - if m.GetPipelineByIDAdminMock.optional { +func (m *RepositoryMock) MinimockGetPipelineReleaseByUIDAdminDone() bool { + if m.GetPipelineReleaseByUIDAdminMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPipelineByIDAdminMock.expectations { + for _, e := range m.GetPipelineReleaseByUIDAdminMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPipelineByIDAdminMock.invocationsDone() + return m.GetPipelineReleaseByUIDAdminMock.invocationsDone() } -// MinimockGetPipelineByIDAdminInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPipelineByIDAdminInspect() { - for _, e := range m.GetPipelineByIDAdminMock.expectations { +// MinimockGetPipelineReleaseByUIDAdminInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPipelineReleaseByUIDAdminInspect() { + for _, e := range m.GetPipelineReleaseByUIDAdminMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPipelineByIDAdminCounter := mm_atomic.LoadUint64(&m.afterGetPipelineByIDAdminCounter) + afterGetPipelineReleaseByUIDAdminCounter := mm_atomic.LoadUint64(&m.afterGetPipelineReleaseByUIDAdminCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPipelineByIDAdminMock.defaultExpectation != nil && afterGetPipelineByIDAdminCounter < 1 { - if m.GetPipelineByIDAdminMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s", m.GetPipelineByIDAdminMock.defaultExpectation.returnOrigin) + if m.GetPipelineReleaseByUIDAdminMock.defaultExpectation != nil && afterGetPipelineReleaseByUIDAdminCounter < 1 { + if m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s", m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s with params: %#v", m.GetPipelineByIDAdminMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineByIDAdminMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s with params: %#v", m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPipelineByIDAdmin != nil && afterGetPipelineByIDAdminCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByIDAdmin at\n%s", m.funcGetPipelineByIDAdminOrigin) + if m.funcGetPipelineReleaseByUIDAdmin != nil && afterGetPipelineReleaseByUIDAdminCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s", m.funcGetPipelineReleaseByUIDAdminOrigin) } - if !m.GetPipelineByIDAdminMock.invocationsDone() && afterGetPipelineByIDAdminCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineByIDAdmin at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPipelineByIDAdminMock.expectedInvocations), m.GetPipelineByIDAdminMock.expectedInvocationsOrigin, afterGetPipelineByIDAdminCounter) + if !m.GetPipelineReleaseByUIDAdminMock.invocationsDone() && afterGetPipelineReleaseByUIDAdminCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPipelineReleaseByUIDAdminMock.expectedInvocations), m.GetPipelineReleaseByUIDAdminMock.expectedInvocationsOrigin, afterGetPipelineReleaseByUIDAdminCounter) } } -type mRepositoryMockGetPipelineByUID struct { +type mRepositoryMockGetPipelineRunByUID struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPipelineByUIDExpectation - expectations []*RepositoryMockGetPipelineByUIDExpectation + defaultExpectation *RepositoryMockGetPipelineRunByUIDExpectation + expectations []*RepositoryMockGetPipelineRunByUIDExpectation - callArgs []*RepositoryMockGetPipelineByUIDParams + callArgs []*RepositoryMockGetPipelineRunByUIDParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPipelineByUIDExpectation specifies expectation struct of the Repository.GetPipelineByUID -type RepositoryMockGetPipelineByUIDExpectation struct { +// RepositoryMockGetPipelineRunByUIDExpectation specifies expectation struct of the Repository.GetPipelineRunByUID +type RepositoryMockGetPipelineRunByUIDExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPipelineByUIDParams - paramPtrs *RepositoryMockGetPipelineByUIDParamPtrs - expectationOrigins RepositoryMockGetPipelineByUIDExpectationOrigins - results *RepositoryMockGetPipelineByUIDResults + params *RepositoryMockGetPipelineRunByUIDParams + paramPtrs *RepositoryMockGetPipelineRunByUIDParamPtrs + expectationOrigins RepositoryMockGetPipelineRunByUIDExpectationOrigins + results *RepositoryMockGetPipelineRunByUIDResults returnOrigin string Counter uint64 } -// RepositoryMockGetPipelineByUIDParams contains parameters of the Repository.GetPipelineByUID -type RepositoryMockGetPipelineByUIDParams struct { - ctx context.Context - uid uuid.UUID - isBasicView bool - embedReleases bool +// RepositoryMockGetPipelineRunByUIDParams contains parameters of the Repository.GetPipelineRunByUID +type RepositoryMockGetPipelineRunByUIDParams struct { + ctx context.Context + u1 uuid.UUID } -// RepositoryMockGetPipelineByUIDParamPtrs contains pointers to parameters of the Repository.GetPipelineByUID -type RepositoryMockGetPipelineByUIDParamPtrs struct { - ctx *context.Context - uid *uuid.UUID - isBasicView *bool - embedReleases *bool +// RepositoryMockGetPipelineRunByUIDParamPtrs contains pointers to parameters of the Repository.GetPipelineRunByUID +type RepositoryMockGetPipelineRunByUIDParamPtrs struct { + ctx *context.Context + u1 *uuid.UUID } -// RepositoryMockGetPipelineByUIDResults contains results of the Repository.GetPipelineByUID -type RepositoryMockGetPipelineByUIDResults struct { - pp1 *datamodel.Pipeline +// RepositoryMockGetPipelineRunByUIDResults contains results of the Repository.GetPipelineRunByUID +type RepositoryMockGetPipelineRunByUIDResults struct { + pp1 *datamodel.PipelineRun err error } -// RepositoryMockGetPipelineByUIDOrigins contains origins of expectations of the Repository.GetPipelineByUID -type RepositoryMockGetPipelineByUIDExpectationOrigins struct { - origin string - originCtx string - originUid string - originIsBasicView string - originEmbedReleases string +// RepositoryMockGetPipelineRunByUIDOrigins contains origins of expectations of the Repository.GetPipelineRunByUID +type RepositoryMockGetPipelineRunByUIDExpectationOrigins struct { + origin string + originCtx string + originU1 string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -10891,401 +10980,341 @@ type RepositoryMockGetPipelineByUIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Optional() *mRepositoryMockGetPipelineByUID { - mmGetPipelineByUID.optional = true - return mmGetPipelineByUID +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Optional() *mRepositoryMockGetPipelineRunByUID { + mmGetPipelineRunByUID.optional = true + return mmGetPipelineRunByUID } -// Expect sets up expected params for Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Expect(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) *mRepositoryMockGetPipelineByUID { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") +// Expect sets up expected params for Repository.GetPipelineRunByUID +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Expect(ctx context.Context, u1 uuid.UUID) *mRepositoryMockGetPipelineRunByUID { + if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") } - if mmGetPipelineByUID.defaultExpectation == nil { - mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} + if mmGetPipelineRunByUID.defaultExpectation == nil { + mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{} } - if mmGetPipelineByUID.defaultExpectation.paramPtrs != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by ExpectParams functions") + if mmGetPipelineRunByUID.defaultExpectation.paramPtrs != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by ExpectParams functions") } - mmGetPipelineByUID.defaultExpectation.params = &RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases} - mmGetPipelineByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPipelineByUID.expectations { - if minimock.Equal(e.params, mmGetPipelineByUID.defaultExpectation.params) { - mmGetPipelineByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineByUID.defaultExpectation.params) + mmGetPipelineRunByUID.defaultExpectation.params = &RepositoryMockGetPipelineRunByUIDParams{ctx, u1} + mmGetPipelineRunByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetPipelineRunByUID.expectations { + if minimock.Equal(e.params, mmGetPipelineRunByUID.defaultExpectation.params) { + mmGetPipelineRunByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineRunByUID.defaultExpectation.params) } } - return mmGetPipelineByUID -} - -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineByUID { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") - } - - if mmGetPipelineByUID.defaultExpectation == nil { - mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} - } - - if mmGetPipelineByUID.defaultExpectation.params != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") - } - - if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { - mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} - } - mmGetPipelineByUID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPipelineByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmGetPipelineByUID -} - -// ExpectUidParam2 sets up expected param uid for Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockGetPipelineByUID { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") - } - - if mmGetPipelineByUID.defaultExpectation == nil { - mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} - } - - if mmGetPipelineByUID.defaultExpectation.params != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") - } - - if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { - mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} - } - mmGetPipelineByUID.defaultExpectation.paramPtrs.uid = &uid - mmGetPipelineByUID.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - - return mmGetPipelineByUID + return mmGetPipelineRunByUID } -// ExpectIsBasicViewParam3 sets up expected param isBasicView for Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectIsBasicViewParam3(isBasicView bool) *mRepositoryMockGetPipelineByUID { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineRunByUID +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineRunByUID { + if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") } - if mmGetPipelineByUID.defaultExpectation == nil { - mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} + if mmGetPipelineRunByUID.defaultExpectation == nil { + mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{} } - if mmGetPipelineByUID.defaultExpectation.params != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") + if mmGetPipelineRunByUID.defaultExpectation.params != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Expect") } - if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { - mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} + if mmGetPipelineRunByUID.defaultExpectation.paramPtrs == nil { + mmGetPipelineRunByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineRunByUIDParamPtrs{} } - mmGetPipelineByUID.defaultExpectation.paramPtrs.isBasicView = &isBasicView - mmGetPipelineByUID.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + mmGetPipelineRunByUID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetPipelineRunByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPipelineByUID + return mmGetPipelineRunByUID } -// ExpectEmbedReleasesParam4 sets up expected param embedReleases for Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) ExpectEmbedReleasesParam4(embedReleases bool) *mRepositoryMockGetPipelineByUID { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") +// ExpectU1Param2 sets up expected param u1 for Repository.GetPipelineRunByUID +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) ExpectU1Param2(u1 uuid.UUID) *mRepositoryMockGetPipelineRunByUID { + if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") } - if mmGetPipelineByUID.defaultExpectation == nil { - mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{} + if mmGetPipelineRunByUID.defaultExpectation == nil { + mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{} } - if mmGetPipelineByUID.defaultExpectation.params != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Expect") + if mmGetPipelineRunByUID.defaultExpectation.params != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Expect") } - if mmGetPipelineByUID.defaultExpectation.paramPtrs == nil { - mmGetPipelineByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineByUIDParamPtrs{} + if mmGetPipelineRunByUID.defaultExpectation.paramPtrs == nil { + mmGetPipelineRunByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineRunByUIDParamPtrs{} } - mmGetPipelineByUID.defaultExpectation.paramPtrs.embedReleases = &embedReleases - mmGetPipelineByUID.defaultExpectation.expectationOrigins.originEmbedReleases = minimock.CallerInfo(1) + mmGetPipelineRunByUID.defaultExpectation.paramPtrs.u1 = &u1 + mmGetPipelineRunByUID.defaultExpectation.expectationOrigins.originU1 = minimock.CallerInfo(1) - return mmGetPipelineByUID + return mmGetPipelineRunByUID } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Inspect(f func(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool)) *mRepositoryMockGetPipelineByUID { - if mmGetPipelineByUID.mock.inspectFuncGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineByUID") +// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineRunByUID +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Inspect(f func(ctx context.Context, u1 uuid.UUID)) *mRepositoryMockGetPipelineRunByUID { + if mmGetPipelineRunByUID.mock.inspectFuncGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineRunByUID") } - mmGetPipelineByUID.mock.inspectFuncGetPipelineByUID = f + mmGetPipelineRunByUID.mock.inspectFuncGetPipelineRunByUID = f - return mmGetPipelineByUID + return mmGetPipelineRunByUID } -// Return sets up results that will be returned by Repository.GetPipelineByUID -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Return(pp1 *datamodel.Pipeline, err error) *RepositoryMock { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") +// Return sets up results that will be returned by Repository.GetPipelineRunByUID +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Return(pp1 *datamodel.PipelineRun, err error) *RepositoryMock { + if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") } - if mmGetPipelineByUID.defaultExpectation == nil { - mmGetPipelineByUID.defaultExpectation = &RepositoryMockGetPipelineByUIDExpectation{mock: mmGetPipelineByUID.mock} + if mmGetPipelineRunByUID.defaultExpectation == nil { + mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{mock: mmGetPipelineRunByUID.mock} } - mmGetPipelineByUID.defaultExpectation.results = &RepositoryMockGetPipelineByUIDResults{pp1, err} - mmGetPipelineByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPipelineByUID.mock + mmGetPipelineRunByUID.defaultExpectation.results = &RepositoryMockGetPipelineRunByUIDResults{pp1, err} + mmGetPipelineRunByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetPipelineRunByUID.mock } -// Set uses given function f to mock the Repository.GetPipelineByUID method -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Set(f func(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error)) *RepositoryMock { - if mmGetPipelineByUID.defaultExpectation != nil { - mmGetPipelineByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineByUID method") +// Set uses given function f to mock the Repository.GetPipelineRunByUID method +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Set(f func(ctx context.Context, u1 uuid.UUID) (pp1 *datamodel.PipelineRun, err error)) *RepositoryMock { + if mmGetPipelineRunByUID.defaultExpectation != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineRunByUID method") } - if len(mmGetPipelineByUID.expectations) > 0 { - mmGetPipelineByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineByUID method") + if len(mmGetPipelineRunByUID.expectations) > 0 { + mmGetPipelineRunByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineRunByUID method") } - mmGetPipelineByUID.mock.funcGetPipelineByUID = f - mmGetPipelineByUID.mock.funcGetPipelineByUIDOrigin = minimock.CallerInfo(1) - return mmGetPipelineByUID.mock + mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID = f + mmGetPipelineRunByUID.mock.funcGetPipelineRunByUIDOrigin = minimock.CallerInfo(1) + return mmGetPipelineRunByUID.mock } -// When sets expectation for the Repository.GetPipelineByUID which will trigger the result defined by the following +// When sets expectation for the Repository.GetPipelineRunByUID which will trigger the result defined by the following // Then helper -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) When(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) *RepositoryMockGetPipelineByUIDExpectation { - if mmGetPipelineByUID.mock.funcGetPipelineByUID != nil { - mmGetPipelineByUID.mock.t.Fatalf("RepositoryMock.GetPipelineByUID mock is already set by Set") +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) When(ctx context.Context, u1 uuid.UUID) *RepositoryMockGetPipelineRunByUIDExpectation { + if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") } - expectation := &RepositoryMockGetPipelineByUIDExpectation{ - mock: mmGetPipelineByUID.mock, - params: &RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases}, - expectationOrigins: RepositoryMockGetPipelineByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockGetPipelineRunByUIDExpectation{ + mock: mmGetPipelineRunByUID.mock, + params: &RepositoryMockGetPipelineRunByUIDParams{ctx, u1}, + expectationOrigins: RepositoryMockGetPipelineRunByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPipelineByUID.expectations = append(mmGetPipelineByUID.expectations, expectation) + mmGetPipelineRunByUID.expectations = append(mmGetPipelineRunByUID.expectations, expectation) return expectation } -// Then sets up Repository.GetPipelineByUID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPipelineByUIDExpectation) Then(pp1 *datamodel.Pipeline, err error) *RepositoryMock { - e.results = &RepositoryMockGetPipelineByUIDResults{pp1, err} +// Then sets up Repository.GetPipelineRunByUID return parameters for the expectation previously defined by the When method +func (e *RepositoryMockGetPipelineRunByUIDExpectation) Then(pp1 *datamodel.PipelineRun, err error) *RepositoryMock { + e.results = &RepositoryMockGetPipelineRunByUIDResults{pp1, err} return e.mock } -// Times sets number of times Repository.GetPipelineByUID should be invoked -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Times(n uint64) *mRepositoryMockGetPipelineByUID { +// Times sets number of times Repository.GetPipelineRunByUID should be invoked +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Times(n uint64) *mRepositoryMockGetPipelineRunByUID { if n == 0 { - mmGetPipelineByUID.mock.t.Fatalf("Times of RepositoryMock.GetPipelineByUID mock can not be zero") + mmGetPipelineRunByUID.mock.t.Fatalf("Times of RepositoryMock.GetPipelineRunByUID mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPipelineByUID.expectedInvocations, n) - mmGetPipelineByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPipelineByUID + mm_atomic.StoreUint64(&mmGetPipelineRunByUID.expectedInvocations, n) + mmGetPipelineRunByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetPipelineRunByUID } -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) invocationsDone() bool { - if len(mmGetPipelineByUID.expectations) == 0 && mmGetPipelineByUID.defaultExpectation == nil && mmGetPipelineByUID.mock.funcGetPipelineByUID == nil { +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) invocationsDone() bool { + if len(mmGetPipelineRunByUID.expectations) == 0 && mmGetPipelineRunByUID.defaultExpectation == nil && mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineByUID.mock.afterGetPipelineByUIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineByUID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineRunByUID.mock.afterGetPipelineRunByUIDCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineRunByUID.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPipelineByUID implements mm_repository.Repository -func (mmGetPipelineByUID *RepositoryMock) GetPipelineByUID(ctx context.Context, uid uuid.UUID, isBasicView bool, embedReleases bool) (pp1 *datamodel.Pipeline, err error) { - mm_atomic.AddUint64(&mmGetPipelineByUID.beforeGetPipelineByUIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetPipelineByUID.afterGetPipelineByUIDCounter, 1) +// GetPipelineRunByUID implements mm_repository.Repository +func (mmGetPipelineRunByUID *RepositoryMock) GetPipelineRunByUID(ctx context.Context, u1 uuid.UUID) (pp1 *datamodel.PipelineRun, err error) { + mm_atomic.AddUint64(&mmGetPipelineRunByUID.beforeGetPipelineRunByUIDCounter, 1) + defer mm_atomic.AddUint64(&mmGetPipelineRunByUID.afterGetPipelineRunByUIDCounter, 1) - mmGetPipelineByUID.t.Helper() + mmGetPipelineRunByUID.t.Helper() - if mmGetPipelineByUID.inspectFuncGetPipelineByUID != nil { - mmGetPipelineByUID.inspectFuncGetPipelineByUID(ctx, uid, isBasicView, embedReleases) + if mmGetPipelineRunByUID.inspectFuncGetPipelineRunByUID != nil { + mmGetPipelineRunByUID.inspectFuncGetPipelineRunByUID(ctx, u1) } - mm_params := RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases} + mm_params := RepositoryMockGetPipelineRunByUIDParams{ctx, u1} // Record call args - mmGetPipelineByUID.GetPipelineByUIDMock.mutex.Lock() - mmGetPipelineByUID.GetPipelineByUIDMock.callArgs = append(mmGetPipelineByUID.GetPipelineByUIDMock.callArgs, &mm_params) - mmGetPipelineByUID.GetPipelineByUIDMock.mutex.Unlock() + mmGetPipelineRunByUID.GetPipelineRunByUIDMock.mutex.Lock() + mmGetPipelineRunByUID.GetPipelineRunByUIDMock.callArgs = append(mmGetPipelineRunByUID.GetPipelineRunByUIDMock.callArgs, &mm_params) + mmGetPipelineRunByUID.GetPipelineRunByUIDMock.mutex.Unlock() - for _, e := range mmGetPipelineByUID.GetPipelineByUIDMock.expectations { + for _, e := range mmGetPipelineRunByUID.GetPipelineRunByUIDMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) return e.results.pp1, e.results.err } } - if mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.params - mm_want_ptrs := mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.paramPtrs + if mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.Counter, 1) + mm_want := mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.params + mm_want_ptrs := mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPipelineByUIDParams{ctx, uid, isBasicView, embedReleases} + mm_got := RepositoryMockGetPipelineRunByUIDParams{ctx, u1} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) - } - - if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { - mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) - } - - if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { - mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) + mmGetPipelineRunByUID.t.Errorf("RepositoryMock.GetPipelineRunByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.embedReleases != nil && !minimock.Equal(*mm_want_ptrs.embedReleases, mm_got.embedReleases) { - mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameter embedReleases, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.originEmbedReleases, *mm_want_ptrs.embedReleases, mm_got.embedReleases, minimock.Diff(*mm_want_ptrs.embedReleases, mm_got.embedReleases)) + if mm_want_ptrs.u1 != nil && !minimock.Equal(*mm_want_ptrs.u1, mm_got.u1) { + mmGetPipelineRunByUID.t.Errorf("RepositoryMock.GetPipelineRunByUID got unexpected parameter u1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.originU1, *mm_want_ptrs.u1, mm_got.u1, minimock.Diff(*mm_want_ptrs.u1, mm_got.u1)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPipelineByUID.t.Errorf("RepositoryMock.GetPipelineByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetPipelineRunByUID.t.Errorf("RepositoryMock.GetPipelineRunByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPipelineByUID.GetPipelineByUIDMock.defaultExpectation.results + mm_results := mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.results if mm_results == nil { - mmGetPipelineByUID.t.Fatal("No results are set for the RepositoryMock.GetPipelineByUID") + mmGetPipelineRunByUID.t.Fatal("No results are set for the RepositoryMock.GetPipelineRunByUID") } return (*mm_results).pp1, (*mm_results).err } - if mmGetPipelineByUID.funcGetPipelineByUID != nil { - return mmGetPipelineByUID.funcGetPipelineByUID(ctx, uid, isBasicView, embedReleases) + if mmGetPipelineRunByUID.funcGetPipelineRunByUID != nil { + return mmGetPipelineRunByUID.funcGetPipelineRunByUID(ctx, u1) } - mmGetPipelineByUID.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineByUID. %v %v %v %v", ctx, uid, isBasicView, embedReleases) + mmGetPipelineRunByUID.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineRunByUID. %v %v", ctx, u1) return } -// GetPipelineByUIDAfterCounter returns a count of finished RepositoryMock.GetPipelineByUID invocations -func (mmGetPipelineByUID *RepositoryMock) GetPipelineByUIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineByUID.afterGetPipelineByUIDCounter) +// GetPipelineRunByUIDAfterCounter returns a count of finished RepositoryMock.GetPipelineRunByUID invocations +func (mmGetPipelineRunByUID *RepositoryMock) GetPipelineRunByUIDAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineRunByUID.afterGetPipelineRunByUIDCounter) } -// GetPipelineByUIDBeforeCounter returns a count of RepositoryMock.GetPipelineByUID invocations -func (mmGetPipelineByUID *RepositoryMock) GetPipelineByUIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineByUID.beforeGetPipelineByUIDCounter) +// GetPipelineRunByUIDBeforeCounter returns a count of RepositoryMock.GetPipelineRunByUID invocations +func (mmGetPipelineRunByUID *RepositoryMock) GetPipelineRunByUIDBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetPipelineRunByUID.beforeGetPipelineRunByUIDCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineByUID. +// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineRunByUID. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPipelineByUID *mRepositoryMockGetPipelineByUID) Calls() []*RepositoryMockGetPipelineByUIDParams { - mmGetPipelineByUID.mutex.RLock() +func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Calls() []*RepositoryMockGetPipelineRunByUIDParams { + mmGetPipelineRunByUID.mutex.RLock() - argCopy := make([]*RepositoryMockGetPipelineByUIDParams, len(mmGetPipelineByUID.callArgs)) - copy(argCopy, mmGetPipelineByUID.callArgs) + argCopy := make([]*RepositoryMockGetPipelineRunByUIDParams, len(mmGetPipelineRunByUID.callArgs)) + copy(argCopy, mmGetPipelineRunByUID.callArgs) - mmGetPipelineByUID.mutex.RUnlock() + mmGetPipelineRunByUID.mutex.RUnlock() return argCopy } -// MinimockGetPipelineByUIDDone returns true if the count of the GetPipelineByUID invocations corresponds +// MinimockGetPipelineRunByUIDDone returns true if the count of the GetPipelineRunByUID invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPipelineByUIDDone() bool { - if m.GetPipelineByUIDMock.optional { +func (m *RepositoryMock) MinimockGetPipelineRunByUIDDone() bool { + if m.GetPipelineRunByUIDMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPipelineByUIDMock.expectations { + for _, e := range m.GetPipelineRunByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPipelineByUIDMock.invocationsDone() + return m.GetPipelineRunByUIDMock.invocationsDone() } -// MinimockGetPipelineByUIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPipelineByUIDInspect() { - for _, e := range m.GetPipelineByUIDMock.expectations { +// MinimockGetPipelineRunByUIDInspect logs each unmet expectation +func (m *RepositoryMock) MinimockGetPipelineRunByUIDInspect() { + for _, e := range m.GetPipelineRunByUIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPipelineByUIDCounter := mm_atomic.LoadUint64(&m.afterGetPipelineByUIDCounter) + afterGetPipelineRunByUIDCounter := mm_atomic.LoadUint64(&m.afterGetPipelineRunByUIDCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPipelineByUIDMock.defaultExpectation != nil && afterGetPipelineByUIDCounter < 1 { - if m.GetPipelineByUIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s", m.GetPipelineByUIDMock.defaultExpectation.returnOrigin) + if m.GetPipelineRunByUIDMock.defaultExpectation != nil && afterGetPipelineRunByUIDCounter < 1 { + if m.GetPipelineRunByUIDMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s", m.GetPipelineRunByUIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s with params: %#v", m.GetPipelineByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineByUIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s with params: %#v", m.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineRunByUIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPipelineByUID != nil && afterGetPipelineByUIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineByUID at\n%s", m.funcGetPipelineByUIDOrigin) + if m.funcGetPipelineRunByUID != nil && afterGetPipelineRunByUIDCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s", m.funcGetPipelineRunByUIDOrigin) } - if !m.GetPipelineByUIDMock.invocationsDone() && afterGetPipelineByUIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineByUID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPipelineByUIDMock.expectedInvocations), m.GetPipelineByUIDMock.expectedInvocationsOrigin, afterGetPipelineByUIDCounter) + if !m.GetPipelineRunByUIDMock.invocationsDone() && afterGetPipelineRunByUIDCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineRunByUID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetPipelineRunByUIDMock.expectedInvocations), m.GetPipelineRunByUIDMock.expectedInvocationsOrigin, afterGetPipelineRunByUIDCounter) } } -type mRepositoryMockGetPipelineReleaseByUIDAdmin struct { +type mRepositoryMockIncreasePipelineClones struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPipelineReleaseByUIDAdminExpectation - expectations []*RepositoryMockGetPipelineReleaseByUIDAdminExpectation + defaultExpectation *RepositoryMockIncreasePipelineClonesExpectation + expectations []*RepositoryMockIncreasePipelineClonesExpectation - callArgs []*RepositoryMockGetPipelineReleaseByUIDAdminParams + callArgs []*RepositoryMockIncreasePipelineClonesParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPipelineReleaseByUIDAdminExpectation specifies expectation struct of the Repository.GetPipelineReleaseByUIDAdmin -type RepositoryMockGetPipelineReleaseByUIDAdminExpectation struct { +// RepositoryMockIncreasePipelineClonesExpectation specifies expectation struct of the Repository.IncreasePipelineClones +type RepositoryMockIncreasePipelineClonesExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPipelineReleaseByUIDAdminParams - paramPtrs *RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs - expectationOrigins RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins - results *RepositoryMockGetPipelineReleaseByUIDAdminResults + params *RepositoryMockIncreasePipelineClonesParams + paramPtrs *RepositoryMockIncreasePipelineClonesParamPtrs + expectationOrigins RepositoryMockIncreasePipelineClonesExpectationOrigins + results *RepositoryMockIncreasePipelineClonesResults returnOrigin string Counter uint64 } -// RepositoryMockGetPipelineReleaseByUIDAdminParams contains parameters of the Repository.GetPipelineReleaseByUIDAdmin -type RepositoryMockGetPipelineReleaseByUIDAdminParams struct { - ctx context.Context - uid uuid.UUID - isBasicView bool +// RepositoryMockIncreasePipelineClonesParams contains parameters of the Repository.IncreasePipelineClones +type RepositoryMockIncreasePipelineClonesParams struct { + ctx context.Context + uid uuid.UUID } -// RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs contains pointers to parameters of the Repository.GetPipelineReleaseByUIDAdmin -type RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs struct { - ctx *context.Context - uid *uuid.UUID - isBasicView *bool +// RepositoryMockIncreasePipelineClonesParamPtrs contains pointers to parameters of the Repository.IncreasePipelineClones +type RepositoryMockIncreasePipelineClonesParamPtrs struct { + ctx *context.Context + uid *uuid.UUID } -// RepositoryMockGetPipelineReleaseByUIDAdminResults contains results of the Repository.GetPipelineReleaseByUIDAdmin -type RepositoryMockGetPipelineReleaseByUIDAdminResults struct { - pp1 *datamodel.PipelineRelease +// RepositoryMockIncreasePipelineClonesResults contains results of the Repository.IncreasePipelineClones +type RepositoryMockIncreasePipelineClonesResults struct { err error } -// RepositoryMockGetPipelineReleaseByUIDAdminOrigins contains origins of expectations of the Repository.GetPipelineReleaseByUIDAdmin -type RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins struct { - origin string - originCtx string - originUid string - originIsBasicView string +// RepositoryMockIncreasePipelineClonesOrigins contains origins of expectations of the Repository.IncreasePipelineClones +type RepositoryMockIncreasePipelineClonesExpectationOrigins struct { + origin string + originCtx string + originUid string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -11293,370 +11322,341 @@ type RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Optional() *mRepositoryMockGetPipelineReleaseByUIDAdmin { - mmGetPipelineReleaseByUIDAdmin.optional = true - return mmGetPipelineReleaseByUIDAdmin +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Optional() *mRepositoryMockIncreasePipelineClones { + mmIncreasePipelineClones.optional = true + return mmIncreasePipelineClones } -// Expect sets up expected params for Repository.GetPipelineReleaseByUIDAdmin -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Expect(ctx context.Context, uid uuid.UUID, isBasicView bool) *mRepositoryMockGetPipelineReleaseByUIDAdmin { - if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") +// Expect sets up expected params for Repository.IncreasePipelineClones +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Expect(ctx context.Context, uid uuid.UUID) *mRepositoryMockIncreasePipelineClones { + if mmIncreasePipelineClones.mock.funcIncreasePipelineClones != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Set") } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} + if mmIncreasePipelineClones.defaultExpectation == nil { + mmIncreasePipelineClones.defaultExpectation = &RepositoryMockIncreasePipelineClonesExpectation{} } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by ExpectParams functions") + if mmIncreasePipelineClones.defaultExpectation.paramPtrs != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by ExpectParams functions") } - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params = &RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView} - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPipelineReleaseByUIDAdmin.expectations { - if minimock.Equal(e.params, mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params) { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params) + mmIncreasePipelineClones.defaultExpectation.params = &RepositoryMockIncreasePipelineClonesParams{ctx, uid} + mmIncreasePipelineClones.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmIncreasePipelineClones.expectations { + if minimock.Equal(e.params, mmIncreasePipelineClones.defaultExpectation.params) { + mmIncreasePipelineClones.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmIncreasePipelineClones.defaultExpectation.params) } } - return mmGetPipelineReleaseByUIDAdmin -} - -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineReleaseByUIDAdmin -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineReleaseByUIDAdmin { - if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") - } - - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} - } - - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Expect") - } - - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs{} - } - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - - return mmGetPipelineReleaseByUIDAdmin + return mmIncreasePipelineClones } -// ExpectUidParam2 sets up expected param uid for Repository.GetPipelineReleaseByUIDAdmin -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockGetPipelineReleaseByUIDAdmin { - if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.IncreasePipelineClones +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) ExpectCtxParam1(ctx context.Context) *mRepositoryMockIncreasePipelineClones { + if mmIncreasePipelineClones.mock.funcIncreasePipelineClones != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Set") } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} + if mmIncreasePipelineClones.defaultExpectation == nil { + mmIncreasePipelineClones.defaultExpectation = &RepositoryMockIncreasePipelineClonesExpectation{} } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Expect") + if mmIncreasePipelineClones.defaultExpectation.params != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Expect") } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs{} + if mmIncreasePipelineClones.defaultExpectation.paramPtrs == nil { + mmIncreasePipelineClones.defaultExpectation.paramPtrs = &RepositoryMockIncreasePipelineClonesParamPtrs{} } - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs.uid = &uid - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) + mmIncreasePipelineClones.defaultExpectation.paramPtrs.ctx = &ctx + mmIncreasePipelineClones.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPipelineReleaseByUIDAdmin + return mmIncreasePipelineClones } -// ExpectIsBasicViewParam3 sets up expected param isBasicView for Repository.GetPipelineReleaseByUIDAdmin -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) ExpectIsBasicViewParam3(isBasicView bool) *mRepositoryMockGetPipelineReleaseByUIDAdmin { - if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") +// ExpectUidParam2 sets up expected param uid for Repository.IncreasePipelineClones +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockIncreasePipelineClones { + if mmIncreasePipelineClones.mock.funcIncreasePipelineClones != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Set") } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{} + if mmIncreasePipelineClones.defaultExpectation == nil { + mmIncreasePipelineClones.defaultExpectation = &RepositoryMockIncreasePipelineClonesExpectation{} } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.params != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Expect") + if mmIncreasePipelineClones.defaultExpectation.params != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Expect") } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineReleaseByUIDAdminParamPtrs{} + if mmIncreasePipelineClones.defaultExpectation.paramPtrs == nil { + mmIncreasePipelineClones.defaultExpectation.paramPtrs = &RepositoryMockIncreasePipelineClonesParamPtrs{} } - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.paramPtrs.isBasicView = &isBasicView - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.expectationOrigins.originIsBasicView = minimock.CallerInfo(1) + mmIncreasePipelineClones.defaultExpectation.paramPtrs.uid = &uid + mmIncreasePipelineClones.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - return mmGetPipelineReleaseByUIDAdmin + return mmIncreasePipelineClones } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineReleaseByUIDAdmin -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Inspect(f func(ctx context.Context, uid uuid.UUID, isBasicView bool)) *mRepositoryMockGetPipelineReleaseByUIDAdmin { - if mmGetPipelineReleaseByUIDAdmin.mock.inspectFuncGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineReleaseByUIDAdmin") +// Inspect accepts an inspector function that has same arguments as the Repository.IncreasePipelineClones +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Inspect(f func(ctx context.Context, uid uuid.UUID)) *mRepositoryMockIncreasePipelineClones { + if mmIncreasePipelineClones.mock.inspectFuncIncreasePipelineClones != nil { + mmIncreasePipelineClones.mock.t.Fatalf("Inspect function is already set for RepositoryMock.IncreasePipelineClones") } - mmGetPipelineReleaseByUIDAdmin.mock.inspectFuncGetPipelineReleaseByUIDAdmin = f + mmIncreasePipelineClones.mock.inspectFuncIncreasePipelineClones = f - return mmGetPipelineReleaseByUIDAdmin + return mmIncreasePipelineClones } -// Return sets up results that will be returned by Repository.GetPipelineReleaseByUIDAdmin -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Return(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { - if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") +// Return sets up results that will be returned by Repository.IncreasePipelineClones +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Return(err error) *RepositoryMock { + if mmIncreasePipelineClones.mock.funcIncreasePipelineClones != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Set") } - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil { - mmGetPipelineReleaseByUIDAdmin.defaultExpectation = &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{mock: mmGetPipelineReleaseByUIDAdmin.mock} + if mmIncreasePipelineClones.defaultExpectation == nil { + mmIncreasePipelineClones.defaultExpectation = &RepositoryMockIncreasePipelineClonesExpectation{mock: mmIncreasePipelineClones.mock} } - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.results = &RepositoryMockGetPipelineReleaseByUIDAdminResults{pp1, err} - mmGetPipelineReleaseByUIDAdmin.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPipelineReleaseByUIDAdmin.mock + mmIncreasePipelineClones.defaultExpectation.results = &RepositoryMockIncreasePipelineClonesResults{err} + mmIncreasePipelineClones.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmIncreasePipelineClones.mock } -// Set uses given function f to mock the Repository.GetPipelineReleaseByUIDAdmin method -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Set(f func(ctx context.Context, uid uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error)) *RepositoryMock { - if mmGetPipelineReleaseByUIDAdmin.defaultExpectation != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineReleaseByUIDAdmin method") +// Set uses given function f to mock the Repository.IncreasePipelineClones method +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Set(f func(ctx context.Context, uid uuid.UUID) (err error)) *RepositoryMock { + if mmIncreasePipelineClones.defaultExpectation != nil { + mmIncreasePipelineClones.mock.t.Fatalf("Default expectation is already set for the Repository.IncreasePipelineClones method") } - if len(mmGetPipelineReleaseByUIDAdmin.expectations) > 0 { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineReleaseByUIDAdmin method") + if len(mmIncreasePipelineClones.expectations) > 0 { + mmIncreasePipelineClones.mock.t.Fatalf("Some expectations are already set for the Repository.IncreasePipelineClones method") } - mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin = f - mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdminOrigin = minimock.CallerInfo(1) - return mmGetPipelineReleaseByUIDAdmin.mock + mmIncreasePipelineClones.mock.funcIncreasePipelineClones = f + mmIncreasePipelineClones.mock.funcIncreasePipelineClonesOrigin = minimock.CallerInfo(1) + return mmIncreasePipelineClones.mock } -// When sets expectation for the Repository.GetPipelineReleaseByUIDAdmin which will trigger the result defined by the following +// When sets expectation for the Repository.IncreasePipelineClones which will trigger the result defined by the following // Then helper -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) When(ctx context.Context, uid uuid.UUID, isBasicView bool) *RepositoryMockGetPipelineReleaseByUIDAdminExpectation { - if mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("RepositoryMock.GetPipelineReleaseByUIDAdmin mock is already set by Set") +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) When(ctx context.Context, uid uuid.UUID) *RepositoryMockIncreasePipelineClonesExpectation { + if mmIncreasePipelineClones.mock.funcIncreasePipelineClones != nil { + mmIncreasePipelineClones.mock.t.Fatalf("RepositoryMock.IncreasePipelineClones mock is already set by Set") } - expectation := &RepositoryMockGetPipelineReleaseByUIDAdminExpectation{ - mock: mmGetPipelineReleaseByUIDAdmin.mock, - params: &RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView}, - expectationOrigins: RepositoryMockGetPipelineReleaseByUIDAdminExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockIncreasePipelineClonesExpectation{ + mock: mmIncreasePipelineClones.mock, + params: &RepositoryMockIncreasePipelineClonesParams{ctx, uid}, + expectationOrigins: RepositoryMockIncreasePipelineClonesExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPipelineReleaseByUIDAdmin.expectations = append(mmGetPipelineReleaseByUIDAdmin.expectations, expectation) + mmIncreasePipelineClones.expectations = append(mmIncreasePipelineClones.expectations, expectation) return expectation } -// Then sets up Repository.GetPipelineReleaseByUIDAdmin return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPipelineReleaseByUIDAdminExpectation) Then(pp1 *datamodel.PipelineRelease, err error) *RepositoryMock { - e.results = &RepositoryMockGetPipelineReleaseByUIDAdminResults{pp1, err} +// Then sets up Repository.IncreasePipelineClones return parameters for the expectation previously defined by the When method +func (e *RepositoryMockIncreasePipelineClonesExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockIncreasePipelineClonesResults{err} return e.mock } -// Times sets number of times Repository.GetPipelineReleaseByUIDAdmin should be invoked -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Times(n uint64) *mRepositoryMockGetPipelineReleaseByUIDAdmin { +// Times sets number of times Repository.IncreasePipelineClones should be invoked +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Times(n uint64) *mRepositoryMockIncreasePipelineClones { if n == 0 { - mmGetPipelineReleaseByUIDAdmin.mock.t.Fatalf("Times of RepositoryMock.GetPipelineReleaseByUIDAdmin mock can not be zero") - } - mm_atomic.StoreUint64(&mmGetPipelineReleaseByUIDAdmin.expectedInvocations, n) - mmGetPipelineReleaseByUIDAdmin.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPipelineReleaseByUIDAdmin + mmIncreasePipelineClones.mock.t.Fatalf("Times of RepositoryMock.IncreasePipelineClones mock can not be zero") + } + mm_atomic.StoreUint64(&mmIncreasePipelineClones.expectedInvocations, n) + mmIncreasePipelineClones.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmIncreasePipelineClones } -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) invocationsDone() bool { - if len(mmGetPipelineReleaseByUIDAdmin.expectations) == 0 && mmGetPipelineReleaseByUIDAdmin.defaultExpectation == nil && mmGetPipelineReleaseByUIDAdmin.mock.funcGetPipelineReleaseByUIDAdmin == nil { +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) invocationsDone() bool { + if len(mmIncreasePipelineClones.expectations) == 0 && mmIncreasePipelineClones.defaultExpectation == nil && mmIncreasePipelineClones.mock.funcIncreasePipelineClones == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.mock.afterGetPipelineReleaseByUIDAdminCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmIncreasePipelineClones.mock.afterIncreasePipelineClonesCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmIncreasePipelineClones.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPipelineReleaseByUIDAdmin implements mm_repository.Repository -func (mmGetPipelineReleaseByUIDAdmin *RepositoryMock) GetPipelineReleaseByUIDAdmin(ctx context.Context, uid uuid.UUID, isBasicView bool) (pp1 *datamodel.PipelineRelease, err error) { - mm_atomic.AddUint64(&mmGetPipelineReleaseByUIDAdmin.beforeGetPipelineReleaseByUIDAdminCounter, 1) - defer mm_atomic.AddUint64(&mmGetPipelineReleaseByUIDAdmin.afterGetPipelineReleaseByUIDAdminCounter, 1) +// IncreasePipelineClones implements mm_repository.Repository +func (mmIncreasePipelineClones *RepositoryMock) IncreasePipelineClones(ctx context.Context, uid uuid.UUID) (err error) { + mm_atomic.AddUint64(&mmIncreasePipelineClones.beforeIncreasePipelineClonesCounter, 1) + defer mm_atomic.AddUint64(&mmIncreasePipelineClones.afterIncreasePipelineClonesCounter, 1) - mmGetPipelineReleaseByUIDAdmin.t.Helper() + mmIncreasePipelineClones.t.Helper() - if mmGetPipelineReleaseByUIDAdmin.inspectFuncGetPipelineReleaseByUIDAdmin != nil { - mmGetPipelineReleaseByUIDAdmin.inspectFuncGetPipelineReleaseByUIDAdmin(ctx, uid, isBasicView) + if mmIncreasePipelineClones.inspectFuncIncreasePipelineClones != nil { + mmIncreasePipelineClones.inspectFuncIncreasePipelineClones(ctx, uid) } - mm_params := RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView} + mm_params := RepositoryMockIncreasePipelineClonesParams{ctx, uid} // Record call args - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.mutex.Lock() - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.callArgs = append(mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.callArgs, &mm_params) - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.mutex.Unlock() + mmIncreasePipelineClones.IncreasePipelineClonesMock.mutex.Lock() + mmIncreasePipelineClones.IncreasePipelineClonesMock.callArgs = append(mmIncreasePipelineClones.IncreasePipelineClonesMock.callArgs, &mm_params) + mmIncreasePipelineClones.IncreasePipelineClonesMock.mutex.Unlock() - for _, e := range mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.expectations { + for _, e := range mmIncreasePipelineClones.IncreasePipelineClonesMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.pp1, e.results.err + return e.results.err } } - if mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.Counter, 1) - mm_want := mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.params - mm_want_ptrs := mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.paramPtrs + if mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.Counter, 1) + mm_want := mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.params + mm_want_ptrs := mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPipelineReleaseByUIDAdminParams{ctx, uid, isBasicView} + mm_got := RepositoryMockIncreasePipelineClonesParams{ctx, uid} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmIncreasePipelineClones.t.Errorf("RepositoryMock.IncreasePipelineClones got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { - mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) - } - - if mm_want_ptrs.isBasicView != nil && !minimock.Equal(*mm_want_ptrs.isBasicView, mm_got.isBasicView) { - mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameter isBasicView, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.originIsBasicView, *mm_want_ptrs.isBasicView, mm_got.isBasicView, minimock.Diff(*mm_want_ptrs.isBasicView, mm_got.isBasicView)) + mmIncreasePipelineClones.t.Errorf("RepositoryMock.IncreasePipelineClones got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPipelineReleaseByUIDAdmin.t.Errorf("RepositoryMock.GetPipelineReleaseByUIDAdmin got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmIncreasePipelineClones.t.Errorf("RepositoryMock.IncreasePipelineClones got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPipelineReleaseByUIDAdmin.GetPipelineReleaseByUIDAdminMock.defaultExpectation.results + mm_results := mmIncreasePipelineClones.IncreasePipelineClonesMock.defaultExpectation.results if mm_results == nil { - mmGetPipelineReleaseByUIDAdmin.t.Fatal("No results are set for the RepositoryMock.GetPipelineReleaseByUIDAdmin") + mmIncreasePipelineClones.t.Fatal("No results are set for the RepositoryMock.IncreasePipelineClones") } - return (*mm_results).pp1, (*mm_results).err + return (*mm_results).err } - if mmGetPipelineReleaseByUIDAdmin.funcGetPipelineReleaseByUIDAdmin != nil { - return mmGetPipelineReleaseByUIDAdmin.funcGetPipelineReleaseByUIDAdmin(ctx, uid, isBasicView) + if mmIncreasePipelineClones.funcIncreasePipelineClones != nil { + return mmIncreasePipelineClones.funcIncreasePipelineClones(ctx, uid) } - mmGetPipelineReleaseByUIDAdmin.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineReleaseByUIDAdmin. %v %v %v", ctx, uid, isBasicView) + mmIncreasePipelineClones.t.Fatalf("Unexpected call to RepositoryMock.IncreasePipelineClones. %v %v", ctx, uid) return } -// GetPipelineReleaseByUIDAdminAfterCounter returns a count of finished RepositoryMock.GetPipelineReleaseByUIDAdmin invocations -func (mmGetPipelineReleaseByUIDAdmin *RepositoryMock) GetPipelineReleaseByUIDAdminAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.afterGetPipelineReleaseByUIDAdminCounter) +// IncreasePipelineClonesAfterCounter returns a count of finished RepositoryMock.IncreasePipelineClones invocations +func (mmIncreasePipelineClones *RepositoryMock) IncreasePipelineClonesAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmIncreasePipelineClones.afterIncreasePipelineClonesCounter) } -// GetPipelineReleaseByUIDAdminBeforeCounter returns a count of RepositoryMock.GetPipelineReleaseByUIDAdmin invocations -func (mmGetPipelineReleaseByUIDAdmin *RepositoryMock) GetPipelineReleaseByUIDAdminBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineReleaseByUIDAdmin.beforeGetPipelineReleaseByUIDAdminCounter) +// IncreasePipelineClonesBeforeCounter returns a count of RepositoryMock.IncreasePipelineClones invocations +func (mmIncreasePipelineClones *RepositoryMock) IncreasePipelineClonesBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmIncreasePipelineClones.beforeIncreasePipelineClonesCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineReleaseByUIDAdmin. +// Calls returns a list of arguments used in each call to RepositoryMock.IncreasePipelineClones. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPipelineReleaseByUIDAdmin *mRepositoryMockGetPipelineReleaseByUIDAdmin) Calls() []*RepositoryMockGetPipelineReleaseByUIDAdminParams { - mmGetPipelineReleaseByUIDAdmin.mutex.RLock() +func (mmIncreasePipelineClones *mRepositoryMockIncreasePipelineClones) Calls() []*RepositoryMockIncreasePipelineClonesParams { + mmIncreasePipelineClones.mutex.RLock() - argCopy := make([]*RepositoryMockGetPipelineReleaseByUIDAdminParams, len(mmGetPipelineReleaseByUIDAdmin.callArgs)) - copy(argCopy, mmGetPipelineReleaseByUIDAdmin.callArgs) + argCopy := make([]*RepositoryMockIncreasePipelineClonesParams, len(mmIncreasePipelineClones.callArgs)) + copy(argCopy, mmIncreasePipelineClones.callArgs) - mmGetPipelineReleaseByUIDAdmin.mutex.RUnlock() + mmIncreasePipelineClones.mutex.RUnlock() return argCopy } -// MinimockGetPipelineReleaseByUIDAdminDone returns true if the count of the GetPipelineReleaseByUIDAdmin invocations corresponds +// MinimockIncreasePipelineClonesDone returns true if the count of the IncreasePipelineClones invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPipelineReleaseByUIDAdminDone() bool { - if m.GetPipelineReleaseByUIDAdminMock.optional { +func (m *RepositoryMock) MinimockIncreasePipelineClonesDone() bool { + if m.IncreasePipelineClonesMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPipelineReleaseByUIDAdminMock.expectations { + for _, e := range m.IncreasePipelineClonesMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPipelineReleaseByUIDAdminMock.invocationsDone() + return m.IncreasePipelineClonesMock.invocationsDone() } -// MinimockGetPipelineReleaseByUIDAdminInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPipelineReleaseByUIDAdminInspect() { - for _, e := range m.GetPipelineReleaseByUIDAdminMock.expectations { +// MinimockIncreasePipelineClonesInspect logs each unmet expectation +func (m *RepositoryMock) MinimockIncreasePipelineClonesInspect() { + for _, e := range m.IncreasePipelineClonesMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineClones at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPipelineReleaseByUIDAdminCounter := mm_atomic.LoadUint64(&m.afterGetPipelineReleaseByUIDAdminCounter) + afterIncreasePipelineClonesCounter := mm_atomic.LoadUint64(&m.afterIncreasePipelineClonesCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPipelineReleaseByUIDAdminMock.defaultExpectation != nil && afterGetPipelineReleaseByUIDAdminCounter < 1 { - if m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s", m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.returnOrigin) + if m.IncreasePipelineClonesMock.defaultExpectation != nil && afterIncreasePipelineClonesCounter < 1 { + if m.IncreasePipelineClonesMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineClones at\n%s", m.IncreasePipelineClonesMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s with params: %#v", m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineReleaseByUIDAdminMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineClones at\n%s with params: %#v", m.IncreasePipelineClonesMock.defaultExpectation.expectationOrigins.origin, *m.IncreasePipelineClonesMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPipelineReleaseByUIDAdmin != nil && afterGetPipelineReleaseByUIDAdminCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s", m.funcGetPipelineReleaseByUIDAdminOrigin) + if m.funcIncreasePipelineClones != nil && afterIncreasePipelineClonesCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineClones at\n%s", m.funcIncreasePipelineClonesOrigin) } - if !m.GetPipelineReleaseByUIDAdminMock.invocationsDone() && afterGetPipelineReleaseByUIDAdminCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineReleaseByUIDAdmin at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPipelineReleaseByUIDAdminMock.expectedInvocations), m.GetPipelineReleaseByUIDAdminMock.expectedInvocationsOrigin, afterGetPipelineReleaseByUIDAdminCounter) + if !m.IncreasePipelineClonesMock.invocationsDone() && afterIncreasePipelineClonesCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.IncreasePipelineClones at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.IncreasePipelineClonesMock.expectedInvocations), m.IncreasePipelineClonesMock.expectedInvocationsOrigin, afterIncreasePipelineClonesCounter) } } -type mRepositoryMockGetPipelineRunByUID struct { +type mRepositoryMockIncreasePipelineRuns struct { optional bool mock *RepositoryMock - defaultExpectation *RepositoryMockGetPipelineRunByUIDExpectation - expectations []*RepositoryMockGetPipelineRunByUIDExpectation + defaultExpectation *RepositoryMockIncreasePipelineRunsExpectation + expectations []*RepositoryMockIncreasePipelineRunsExpectation - callArgs []*RepositoryMockGetPipelineRunByUIDParams + callArgs []*RepositoryMockIncreasePipelineRunsParams mutex sync.RWMutex expectedInvocations uint64 expectedInvocationsOrigin string } -// RepositoryMockGetPipelineRunByUIDExpectation specifies expectation struct of the Repository.GetPipelineRunByUID -type RepositoryMockGetPipelineRunByUIDExpectation struct { +// RepositoryMockIncreasePipelineRunsExpectation specifies expectation struct of the Repository.IncreasePipelineRuns +type RepositoryMockIncreasePipelineRunsExpectation struct { mock *RepositoryMock - params *RepositoryMockGetPipelineRunByUIDParams - paramPtrs *RepositoryMockGetPipelineRunByUIDParamPtrs - expectationOrigins RepositoryMockGetPipelineRunByUIDExpectationOrigins - results *RepositoryMockGetPipelineRunByUIDResults + params *RepositoryMockIncreasePipelineRunsParams + paramPtrs *RepositoryMockIncreasePipelineRunsParamPtrs + expectationOrigins RepositoryMockIncreasePipelineRunsExpectationOrigins + results *RepositoryMockIncreasePipelineRunsResults returnOrigin string Counter uint64 } -// RepositoryMockGetPipelineRunByUIDParams contains parameters of the Repository.GetPipelineRunByUID -type RepositoryMockGetPipelineRunByUIDParams struct { +// RepositoryMockIncreasePipelineRunsParams contains parameters of the Repository.IncreasePipelineRuns +type RepositoryMockIncreasePipelineRunsParams struct { ctx context.Context - u1 uuid.UUID + uid uuid.UUID } -// RepositoryMockGetPipelineRunByUIDParamPtrs contains pointers to parameters of the Repository.GetPipelineRunByUID -type RepositoryMockGetPipelineRunByUIDParamPtrs struct { +// RepositoryMockIncreasePipelineRunsParamPtrs contains pointers to parameters of the Repository.IncreasePipelineRuns +type RepositoryMockIncreasePipelineRunsParamPtrs struct { ctx *context.Context - u1 *uuid.UUID + uid *uuid.UUID } -// RepositoryMockGetPipelineRunByUIDResults contains results of the Repository.GetPipelineRunByUID -type RepositoryMockGetPipelineRunByUIDResults struct { - pp1 *datamodel.PipelineRun +// RepositoryMockIncreasePipelineRunsResults contains results of the Repository.IncreasePipelineRuns +type RepositoryMockIncreasePipelineRunsResults struct { err error } -// RepositoryMockGetPipelineRunByUIDOrigins contains origins of expectations of the Repository.GetPipelineRunByUID -type RepositoryMockGetPipelineRunByUIDExpectationOrigins struct { +// RepositoryMockIncreasePipelineRunsOrigins contains origins of expectations of the Repository.IncreasePipelineRuns +type RepositoryMockIncreasePipelineRunsExpectationOrigins struct { origin string originCtx string - originU1 string + originUid string } // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning @@ -11664,292 +11664,292 @@ type RepositoryMockGetPipelineRunByUIDExpectationOrigins struct { // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Optional() *mRepositoryMockGetPipelineRunByUID { - mmGetPipelineRunByUID.optional = true - return mmGetPipelineRunByUID +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Optional() *mRepositoryMockIncreasePipelineRuns { + mmIncreasePipelineRuns.optional = true + return mmIncreasePipelineRuns } -// Expect sets up expected params for Repository.GetPipelineRunByUID -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Expect(ctx context.Context, u1 uuid.UUID) *mRepositoryMockGetPipelineRunByUID { - if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") +// Expect sets up expected params for Repository.IncreasePipelineRuns +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Expect(ctx context.Context, uid uuid.UUID) *mRepositoryMockIncreasePipelineRuns { + if mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Set") } - if mmGetPipelineRunByUID.defaultExpectation == nil { - mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{} + if mmIncreasePipelineRuns.defaultExpectation == nil { + mmIncreasePipelineRuns.defaultExpectation = &RepositoryMockIncreasePipelineRunsExpectation{} } - if mmGetPipelineRunByUID.defaultExpectation.paramPtrs != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by ExpectParams functions") + if mmIncreasePipelineRuns.defaultExpectation.paramPtrs != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by ExpectParams functions") } - mmGetPipelineRunByUID.defaultExpectation.params = &RepositoryMockGetPipelineRunByUIDParams{ctx, u1} - mmGetPipelineRunByUID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) - for _, e := range mmGetPipelineRunByUID.expectations { - if minimock.Equal(e.params, mmGetPipelineRunByUID.defaultExpectation.params) { - mmGetPipelineRunByUID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPipelineRunByUID.defaultExpectation.params) + mmIncreasePipelineRuns.defaultExpectation.params = &RepositoryMockIncreasePipelineRunsParams{ctx, uid} + mmIncreasePipelineRuns.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmIncreasePipelineRuns.expectations { + if minimock.Equal(e.params, mmIncreasePipelineRuns.defaultExpectation.params) { + mmIncreasePipelineRuns.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmIncreasePipelineRuns.defaultExpectation.params) } } - return mmGetPipelineRunByUID + return mmIncreasePipelineRuns } -// ExpectCtxParam1 sets up expected param ctx for Repository.GetPipelineRunByUID -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPipelineRunByUID { - if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") +// ExpectCtxParam1 sets up expected param ctx for Repository.IncreasePipelineRuns +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) ExpectCtxParam1(ctx context.Context) *mRepositoryMockIncreasePipelineRuns { + if mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Set") } - if mmGetPipelineRunByUID.defaultExpectation == nil { - mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{} + if mmIncreasePipelineRuns.defaultExpectation == nil { + mmIncreasePipelineRuns.defaultExpectation = &RepositoryMockIncreasePipelineRunsExpectation{} } - if mmGetPipelineRunByUID.defaultExpectation.params != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Expect") + if mmIncreasePipelineRuns.defaultExpectation.params != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Expect") } - if mmGetPipelineRunByUID.defaultExpectation.paramPtrs == nil { - mmGetPipelineRunByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineRunByUIDParamPtrs{} + if mmIncreasePipelineRuns.defaultExpectation.paramPtrs == nil { + mmIncreasePipelineRuns.defaultExpectation.paramPtrs = &RepositoryMockIncreasePipelineRunsParamPtrs{} } - mmGetPipelineRunByUID.defaultExpectation.paramPtrs.ctx = &ctx - mmGetPipelineRunByUID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + mmIncreasePipelineRuns.defaultExpectation.paramPtrs.ctx = &ctx + mmIncreasePipelineRuns.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) - return mmGetPipelineRunByUID + return mmIncreasePipelineRuns } -// ExpectU1Param2 sets up expected param u1 for Repository.GetPipelineRunByUID -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) ExpectU1Param2(u1 uuid.UUID) *mRepositoryMockGetPipelineRunByUID { - if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") +// ExpectUidParam2 sets up expected param uid for Repository.IncreasePipelineRuns +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) ExpectUidParam2(uid uuid.UUID) *mRepositoryMockIncreasePipelineRuns { + if mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Set") } - if mmGetPipelineRunByUID.defaultExpectation == nil { - mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{} + if mmIncreasePipelineRuns.defaultExpectation == nil { + mmIncreasePipelineRuns.defaultExpectation = &RepositoryMockIncreasePipelineRunsExpectation{} } - if mmGetPipelineRunByUID.defaultExpectation.params != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Expect") + if mmIncreasePipelineRuns.defaultExpectation.params != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Expect") } - if mmGetPipelineRunByUID.defaultExpectation.paramPtrs == nil { - mmGetPipelineRunByUID.defaultExpectation.paramPtrs = &RepositoryMockGetPipelineRunByUIDParamPtrs{} + if mmIncreasePipelineRuns.defaultExpectation.paramPtrs == nil { + mmIncreasePipelineRuns.defaultExpectation.paramPtrs = &RepositoryMockIncreasePipelineRunsParamPtrs{} } - mmGetPipelineRunByUID.defaultExpectation.paramPtrs.u1 = &u1 - mmGetPipelineRunByUID.defaultExpectation.expectationOrigins.originU1 = minimock.CallerInfo(1) + mmIncreasePipelineRuns.defaultExpectation.paramPtrs.uid = &uid + mmIncreasePipelineRuns.defaultExpectation.expectationOrigins.originUid = minimock.CallerInfo(1) - return mmGetPipelineRunByUID + return mmIncreasePipelineRuns } -// Inspect accepts an inspector function that has same arguments as the Repository.GetPipelineRunByUID -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Inspect(f func(ctx context.Context, u1 uuid.UUID)) *mRepositoryMockGetPipelineRunByUID { - if mmGetPipelineRunByUID.mock.inspectFuncGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPipelineRunByUID") +// Inspect accepts an inspector function that has same arguments as the Repository.IncreasePipelineRuns +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Inspect(f func(ctx context.Context, uid uuid.UUID)) *mRepositoryMockIncreasePipelineRuns { + if mmIncreasePipelineRuns.mock.inspectFuncIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("Inspect function is already set for RepositoryMock.IncreasePipelineRuns") } - mmGetPipelineRunByUID.mock.inspectFuncGetPipelineRunByUID = f + mmIncreasePipelineRuns.mock.inspectFuncIncreasePipelineRuns = f - return mmGetPipelineRunByUID + return mmIncreasePipelineRuns } -// Return sets up results that will be returned by Repository.GetPipelineRunByUID -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Return(pp1 *datamodel.PipelineRun, err error) *RepositoryMock { - if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") +// Return sets up results that will be returned by Repository.IncreasePipelineRuns +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Return(err error) *RepositoryMock { + if mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Set") } - if mmGetPipelineRunByUID.defaultExpectation == nil { - mmGetPipelineRunByUID.defaultExpectation = &RepositoryMockGetPipelineRunByUIDExpectation{mock: mmGetPipelineRunByUID.mock} + if mmIncreasePipelineRuns.defaultExpectation == nil { + mmIncreasePipelineRuns.defaultExpectation = &RepositoryMockIncreasePipelineRunsExpectation{mock: mmIncreasePipelineRuns.mock} } - mmGetPipelineRunByUID.defaultExpectation.results = &RepositoryMockGetPipelineRunByUIDResults{pp1, err} - mmGetPipelineRunByUID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) - return mmGetPipelineRunByUID.mock + mmIncreasePipelineRuns.defaultExpectation.results = &RepositoryMockIncreasePipelineRunsResults{err} + mmIncreasePipelineRuns.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmIncreasePipelineRuns.mock } -// Set uses given function f to mock the Repository.GetPipelineRunByUID method -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Set(f func(ctx context.Context, u1 uuid.UUID) (pp1 *datamodel.PipelineRun, err error)) *RepositoryMock { - if mmGetPipelineRunByUID.defaultExpectation != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("Default expectation is already set for the Repository.GetPipelineRunByUID method") +// Set uses given function f to mock the Repository.IncreasePipelineRuns method +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Set(f func(ctx context.Context, uid uuid.UUID) (err error)) *RepositoryMock { + if mmIncreasePipelineRuns.defaultExpectation != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("Default expectation is already set for the Repository.IncreasePipelineRuns method") } - if len(mmGetPipelineRunByUID.expectations) > 0 { - mmGetPipelineRunByUID.mock.t.Fatalf("Some expectations are already set for the Repository.GetPipelineRunByUID method") + if len(mmIncreasePipelineRuns.expectations) > 0 { + mmIncreasePipelineRuns.mock.t.Fatalf("Some expectations are already set for the Repository.IncreasePipelineRuns method") } - mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID = f - mmGetPipelineRunByUID.mock.funcGetPipelineRunByUIDOrigin = minimock.CallerInfo(1) - return mmGetPipelineRunByUID.mock + mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns = f + mmIncreasePipelineRuns.mock.funcIncreasePipelineRunsOrigin = minimock.CallerInfo(1) + return mmIncreasePipelineRuns.mock } -// When sets expectation for the Repository.GetPipelineRunByUID which will trigger the result defined by the following +// When sets expectation for the Repository.IncreasePipelineRuns which will trigger the result defined by the following // Then helper -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) When(ctx context.Context, u1 uuid.UUID) *RepositoryMockGetPipelineRunByUIDExpectation { - if mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.mock.t.Fatalf("RepositoryMock.GetPipelineRunByUID mock is already set by Set") +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) When(ctx context.Context, uid uuid.UUID) *RepositoryMockIncreasePipelineRunsExpectation { + if mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.mock.t.Fatalf("RepositoryMock.IncreasePipelineRuns mock is already set by Set") } - expectation := &RepositoryMockGetPipelineRunByUIDExpectation{ - mock: mmGetPipelineRunByUID.mock, - params: &RepositoryMockGetPipelineRunByUIDParams{ctx, u1}, - expectationOrigins: RepositoryMockGetPipelineRunByUIDExpectationOrigins{origin: minimock.CallerInfo(1)}, + expectation := &RepositoryMockIncreasePipelineRunsExpectation{ + mock: mmIncreasePipelineRuns.mock, + params: &RepositoryMockIncreasePipelineRunsParams{ctx, uid}, + expectationOrigins: RepositoryMockIncreasePipelineRunsExpectationOrigins{origin: minimock.CallerInfo(1)}, } - mmGetPipelineRunByUID.expectations = append(mmGetPipelineRunByUID.expectations, expectation) + mmIncreasePipelineRuns.expectations = append(mmIncreasePipelineRuns.expectations, expectation) return expectation } -// Then sets up Repository.GetPipelineRunByUID return parameters for the expectation previously defined by the When method -func (e *RepositoryMockGetPipelineRunByUIDExpectation) Then(pp1 *datamodel.PipelineRun, err error) *RepositoryMock { - e.results = &RepositoryMockGetPipelineRunByUIDResults{pp1, err} +// Then sets up Repository.IncreasePipelineRuns return parameters for the expectation previously defined by the When method +func (e *RepositoryMockIncreasePipelineRunsExpectation) Then(err error) *RepositoryMock { + e.results = &RepositoryMockIncreasePipelineRunsResults{err} return e.mock } -// Times sets number of times Repository.GetPipelineRunByUID should be invoked -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Times(n uint64) *mRepositoryMockGetPipelineRunByUID { +// Times sets number of times Repository.IncreasePipelineRuns should be invoked +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Times(n uint64) *mRepositoryMockIncreasePipelineRuns { if n == 0 { - mmGetPipelineRunByUID.mock.t.Fatalf("Times of RepositoryMock.GetPipelineRunByUID mock can not be zero") + mmIncreasePipelineRuns.mock.t.Fatalf("Times of RepositoryMock.IncreasePipelineRuns mock can not be zero") } - mm_atomic.StoreUint64(&mmGetPipelineRunByUID.expectedInvocations, n) - mmGetPipelineRunByUID.expectedInvocationsOrigin = minimock.CallerInfo(1) - return mmGetPipelineRunByUID + mm_atomic.StoreUint64(&mmIncreasePipelineRuns.expectedInvocations, n) + mmIncreasePipelineRuns.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmIncreasePipelineRuns } -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) invocationsDone() bool { - if len(mmGetPipelineRunByUID.expectations) == 0 && mmGetPipelineRunByUID.defaultExpectation == nil && mmGetPipelineRunByUID.mock.funcGetPipelineRunByUID == nil { +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) invocationsDone() bool { + if len(mmIncreasePipelineRuns.expectations) == 0 && mmIncreasePipelineRuns.defaultExpectation == nil && mmIncreasePipelineRuns.mock.funcIncreasePipelineRuns == nil { return true } - totalInvocations := mm_atomic.LoadUint64(&mmGetPipelineRunByUID.mock.afterGetPipelineRunByUIDCounter) - expectedInvocations := mm_atomic.LoadUint64(&mmGetPipelineRunByUID.expectedInvocations) + totalInvocations := mm_atomic.LoadUint64(&mmIncreasePipelineRuns.mock.afterIncreasePipelineRunsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmIncreasePipelineRuns.expectedInvocations) return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) } -// GetPipelineRunByUID implements mm_repository.Repository -func (mmGetPipelineRunByUID *RepositoryMock) GetPipelineRunByUID(ctx context.Context, u1 uuid.UUID) (pp1 *datamodel.PipelineRun, err error) { - mm_atomic.AddUint64(&mmGetPipelineRunByUID.beforeGetPipelineRunByUIDCounter, 1) - defer mm_atomic.AddUint64(&mmGetPipelineRunByUID.afterGetPipelineRunByUIDCounter, 1) +// IncreasePipelineRuns implements mm_repository.Repository +func (mmIncreasePipelineRuns *RepositoryMock) IncreasePipelineRuns(ctx context.Context, uid uuid.UUID) (err error) { + mm_atomic.AddUint64(&mmIncreasePipelineRuns.beforeIncreasePipelineRunsCounter, 1) + defer mm_atomic.AddUint64(&mmIncreasePipelineRuns.afterIncreasePipelineRunsCounter, 1) - mmGetPipelineRunByUID.t.Helper() + mmIncreasePipelineRuns.t.Helper() - if mmGetPipelineRunByUID.inspectFuncGetPipelineRunByUID != nil { - mmGetPipelineRunByUID.inspectFuncGetPipelineRunByUID(ctx, u1) + if mmIncreasePipelineRuns.inspectFuncIncreasePipelineRuns != nil { + mmIncreasePipelineRuns.inspectFuncIncreasePipelineRuns(ctx, uid) } - mm_params := RepositoryMockGetPipelineRunByUIDParams{ctx, u1} + mm_params := RepositoryMockIncreasePipelineRunsParams{ctx, uid} // Record call args - mmGetPipelineRunByUID.GetPipelineRunByUIDMock.mutex.Lock() - mmGetPipelineRunByUID.GetPipelineRunByUIDMock.callArgs = append(mmGetPipelineRunByUID.GetPipelineRunByUIDMock.callArgs, &mm_params) - mmGetPipelineRunByUID.GetPipelineRunByUIDMock.mutex.Unlock() + mmIncreasePipelineRuns.IncreasePipelineRunsMock.mutex.Lock() + mmIncreasePipelineRuns.IncreasePipelineRunsMock.callArgs = append(mmIncreasePipelineRuns.IncreasePipelineRunsMock.callArgs, &mm_params) + mmIncreasePipelineRuns.IncreasePipelineRunsMock.mutex.Unlock() - for _, e := range mmGetPipelineRunByUID.GetPipelineRunByUIDMock.expectations { + for _, e := range mmIncreasePipelineRuns.IncreasePipelineRunsMock.expectations { if minimock.Equal(*e.params, mm_params) { mm_atomic.AddUint64(&e.Counter, 1) - return e.results.pp1, e.results.err + return e.results.err } } - if mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation != nil { - mm_atomic.AddUint64(&mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.Counter, 1) - mm_want := mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.params - mm_want_ptrs := mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.paramPtrs + if mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.Counter, 1) + mm_want := mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.params + mm_want_ptrs := mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.paramPtrs - mm_got := RepositoryMockGetPipelineRunByUIDParams{ctx, u1} + mm_got := RepositoryMockIncreasePipelineRunsParams{ctx, uid} if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetPipelineRunByUID.t.Errorf("RepositoryMock.GetPipelineRunByUID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmIncreasePipelineRuns.t.Errorf("RepositoryMock.IncreasePipelineRuns got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } - if mm_want_ptrs.u1 != nil && !minimock.Equal(*mm_want_ptrs.u1, mm_got.u1) { - mmGetPipelineRunByUID.t.Errorf("RepositoryMock.GetPipelineRunByUID got unexpected parameter u1, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.originU1, *mm_want_ptrs.u1, mm_got.u1, minimock.Diff(*mm_want_ptrs.u1, mm_got.u1)) + if mm_want_ptrs.uid != nil && !minimock.Equal(*mm_want_ptrs.uid, mm_got.uid) { + mmIncreasePipelineRuns.t.Errorf("RepositoryMock.IncreasePipelineRuns got unexpected parameter uid, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.expectationOrigins.originUid, *mm_want_ptrs.uid, mm_got.uid, minimock.Diff(*mm_want_ptrs.uid, mm_got.uid)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetPipelineRunByUID.t.Errorf("RepositoryMock.GetPipelineRunByUID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", - mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmIncreasePipelineRuns.t.Errorf("RepositoryMock.IncreasePipelineRuns got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } - mm_results := mmGetPipelineRunByUID.GetPipelineRunByUIDMock.defaultExpectation.results + mm_results := mmIncreasePipelineRuns.IncreasePipelineRunsMock.defaultExpectation.results if mm_results == nil { - mmGetPipelineRunByUID.t.Fatal("No results are set for the RepositoryMock.GetPipelineRunByUID") + mmIncreasePipelineRuns.t.Fatal("No results are set for the RepositoryMock.IncreasePipelineRuns") } - return (*mm_results).pp1, (*mm_results).err + return (*mm_results).err } - if mmGetPipelineRunByUID.funcGetPipelineRunByUID != nil { - return mmGetPipelineRunByUID.funcGetPipelineRunByUID(ctx, u1) + if mmIncreasePipelineRuns.funcIncreasePipelineRuns != nil { + return mmIncreasePipelineRuns.funcIncreasePipelineRuns(ctx, uid) } - mmGetPipelineRunByUID.t.Fatalf("Unexpected call to RepositoryMock.GetPipelineRunByUID. %v %v", ctx, u1) + mmIncreasePipelineRuns.t.Fatalf("Unexpected call to RepositoryMock.IncreasePipelineRuns. %v %v", ctx, uid) return } -// GetPipelineRunByUIDAfterCounter returns a count of finished RepositoryMock.GetPipelineRunByUID invocations -func (mmGetPipelineRunByUID *RepositoryMock) GetPipelineRunByUIDAfterCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineRunByUID.afterGetPipelineRunByUIDCounter) +// IncreasePipelineRunsAfterCounter returns a count of finished RepositoryMock.IncreasePipelineRuns invocations +func (mmIncreasePipelineRuns *RepositoryMock) IncreasePipelineRunsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmIncreasePipelineRuns.afterIncreasePipelineRunsCounter) } -// GetPipelineRunByUIDBeforeCounter returns a count of RepositoryMock.GetPipelineRunByUID invocations -func (mmGetPipelineRunByUID *RepositoryMock) GetPipelineRunByUIDBeforeCounter() uint64 { - return mm_atomic.LoadUint64(&mmGetPipelineRunByUID.beforeGetPipelineRunByUIDCounter) +// IncreasePipelineRunsBeforeCounter returns a count of RepositoryMock.IncreasePipelineRuns invocations +func (mmIncreasePipelineRuns *RepositoryMock) IncreasePipelineRunsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmIncreasePipelineRuns.beforeIncreasePipelineRunsCounter) } -// Calls returns a list of arguments used in each call to RepositoryMock.GetPipelineRunByUID. +// Calls returns a list of arguments used in each call to RepositoryMock.IncreasePipelineRuns. // The list is in the same order as the calls were made (i.e. recent calls have a higher index) -func (mmGetPipelineRunByUID *mRepositoryMockGetPipelineRunByUID) Calls() []*RepositoryMockGetPipelineRunByUIDParams { - mmGetPipelineRunByUID.mutex.RLock() +func (mmIncreasePipelineRuns *mRepositoryMockIncreasePipelineRuns) Calls() []*RepositoryMockIncreasePipelineRunsParams { + mmIncreasePipelineRuns.mutex.RLock() - argCopy := make([]*RepositoryMockGetPipelineRunByUIDParams, len(mmGetPipelineRunByUID.callArgs)) - copy(argCopy, mmGetPipelineRunByUID.callArgs) + argCopy := make([]*RepositoryMockIncreasePipelineRunsParams, len(mmIncreasePipelineRuns.callArgs)) + copy(argCopy, mmIncreasePipelineRuns.callArgs) - mmGetPipelineRunByUID.mutex.RUnlock() + mmIncreasePipelineRuns.mutex.RUnlock() return argCopy } -// MinimockGetPipelineRunByUIDDone returns true if the count of the GetPipelineRunByUID invocations corresponds +// MinimockIncreasePipelineRunsDone returns true if the count of the IncreasePipelineRuns invocations corresponds // the number of defined expectations -func (m *RepositoryMock) MinimockGetPipelineRunByUIDDone() bool { - if m.GetPipelineRunByUIDMock.optional { +func (m *RepositoryMock) MinimockIncreasePipelineRunsDone() bool { + if m.IncreasePipelineRunsMock.optional { // Optional methods provide '0 or more' call count restriction. return true } - for _, e := range m.GetPipelineRunByUIDMock.expectations { + for _, e := range m.IncreasePipelineRunsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { return false } } - return m.GetPipelineRunByUIDMock.invocationsDone() + return m.IncreasePipelineRunsMock.invocationsDone() } -// MinimockGetPipelineRunByUIDInspect logs each unmet expectation -func (m *RepositoryMock) MinimockGetPipelineRunByUIDInspect() { - for _, e := range m.GetPipelineRunByUIDMock.expectations { +// MinimockIncreasePipelineRunsInspect logs each unmet expectation +func (m *RepositoryMock) MinimockIncreasePipelineRunsInspect() { + for _, e := range m.IncreasePipelineRunsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineRuns at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGetPipelineRunByUIDCounter := mm_atomic.LoadUint64(&m.afterGetPipelineRunByUIDCounter) + afterIncreasePipelineRunsCounter := mm_atomic.LoadUint64(&m.afterIncreasePipelineRunsCounter) // if default expectation was set then invocations count should be greater than zero - if m.GetPipelineRunByUIDMock.defaultExpectation != nil && afterGetPipelineRunByUIDCounter < 1 { - if m.GetPipelineRunByUIDMock.defaultExpectation.params == nil { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s", m.GetPipelineRunByUIDMock.defaultExpectation.returnOrigin) + if m.IncreasePipelineRunsMock.defaultExpectation != nil && afterIncreasePipelineRunsCounter < 1 { + if m.IncreasePipelineRunsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineRuns at\n%s", m.IncreasePipelineRunsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s with params: %#v", m.GetPipelineRunByUIDMock.defaultExpectation.expectationOrigins.origin, *m.GetPipelineRunByUIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineRuns at\n%s with params: %#v", m.IncreasePipelineRunsMock.defaultExpectation.expectationOrigins.origin, *m.IncreasePipelineRunsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGetPipelineRunByUID != nil && afterGetPipelineRunByUIDCounter < 1 { - m.t.Errorf("Expected call to RepositoryMock.GetPipelineRunByUID at\n%s", m.funcGetPipelineRunByUIDOrigin) + if m.funcIncreasePipelineRuns != nil && afterIncreasePipelineRunsCounter < 1 { + m.t.Errorf("Expected call to RepositoryMock.IncreasePipelineRuns at\n%s", m.funcIncreasePipelineRunsOrigin) } - if !m.GetPipelineRunByUIDMock.invocationsDone() && afterGetPipelineRunByUIDCounter > 0 { - m.t.Errorf("Expected %d calls to RepositoryMock.GetPipelineRunByUID at\n%s but found %d calls", - mm_atomic.LoadUint64(&m.GetPipelineRunByUIDMock.expectedInvocations), m.GetPipelineRunByUIDMock.expectedInvocationsOrigin, afterGetPipelineRunByUIDCounter) + if !m.IncreasePipelineRunsMock.invocationsDone() && afterIncreasePipelineRunsCounter > 0 { + m.t.Errorf("Expected %d calls to RepositoryMock.IncreasePipelineRuns at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.IncreasePipelineRunsMock.expectedInvocations), m.IncreasePipelineRunsMock.expectedInvocationsOrigin, afterIncreasePipelineRunsCounter) } } @@ -21929,10 +21929,6 @@ func (m *RepositoryMock) MinimockUpsertPipelineRunInspect() { func (m *RepositoryMock) MinimockFinish() { m.finishOnce.Do(func() { if !m.minimockDone() { - m.MinimockAddPipelineClonesInspect() - - m.MinimockAddPipelineRunsInspect() - m.MinimockCheckPinnedUserInspect() m.MinimockCreateNamespaceConnectionInspect() @@ -21989,6 +21985,10 @@ func (m *RepositoryMock) MinimockFinish() { m.MinimockGetPipelineRunByUIDInspect() + m.MinimockIncreasePipelineClonesInspect() + + m.MinimockIncreasePipelineRunsInspect() + m.MinimockListComponentDefinitionUIDsInspect() m.MinimockListIntegrationsInspect() @@ -22061,8 +22061,6 @@ func (m *RepositoryMock) MinimockWait(timeout mm_time.Duration) { func (m *RepositoryMock) minimockDone() bool { done := true return done && - m.MinimockAddPipelineClonesDone() && - m.MinimockAddPipelineRunsDone() && m.MinimockCheckPinnedUserDone() && m.MinimockCreateNamespaceConnectionDone() && m.MinimockCreateNamespacePipelineDone() && @@ -22091,6 +22089,8 @@ func (m *RepositoryMock) minimockDone() bool { m.MinimockGetPipelineByUIDDone() && m.MinimockGetPipelineReleaseByUIDAdminDone() && m.MinimockGetPipelineRunByUIDDone() && + m.MinimockIncreasePipelineClonesDone() && + m.MinimockIncreasePipelineRunsDone() && m.MinimockListComponentDefinitionUIDsDone() && m.MinimockListIntegrationsDone() && m.MinimockListNamespaceConnectionsDone() && diff --git a/pkg/repository/repository.go b/pkg/repository/repository.go index 896299cb1..f048064d7 100644 --- a/pkg/repository/repository.go +++ b/pkg/repository/repository.go @@ -56,8 +56,8 @@ type Repository interface { DeleteNamespacePipelineByID(ctx context.Context, ownerPermalink string, id string) error UpdateNamespacePipelineIDByID(ctx context.Context, ownerPermalink string, id string, newID string) error - AddPipelineRuns(ctx context.Context, uid uuid.UUID) error - AddPipelineClones(ctx context.Context, uid uuid.UUID) error + IncreasePipelineRuns(ctx context.Context, uid uuid.UUID) error + IncreasePipelineClones(ctx context.Context, uid uuid.UUID) error CreateNamespacePipelineRelease(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pipelineRelease *datamodel.PipelineRelease) error ListNamespacePipelineReleases(ctx context.Context, ownerPermalink string, pipelineUID uuid.UUID, pageSize int64, pageToken string, isBasicView bool, filter filtering.Filter, showDeleted bool, returnCount bool) ([]*datamodel.PipelineRelease, int64, string, error) @@ -454,6 +454,23 @@ func (r *repository) getNamespacePipeline(ctx context.Context, where string, whe } pipeline.Releases = pipelineReleases } + pipeline.Recipe = nil + + if pipeline.UseTemplate { + var recipeYAML string + if pipeline.TemplatePipelineReleaseUID.IsNil() { + err := db.Model(&datamodel.Pipeline{}).Where("uid = ?", pipeline.TemplatePipelineUID).Select("recipe_yaml").First(&recipeYAML).Error + if err != nil { + return nil, err + } + } else { + err := db.Model(&datamodel.PipelineRelease{}).Where("uid = ?", pipeline.TemplatePipelineReleaseUID).Select("recipe_yaml").First(&recipeYAML).Error + if err != nil { + return nil, err + } + } + pipeline.RecipeYAML = recipeYAML + } pipeline.Tags = []*datamodel.Tag{} tagDB := r.CheckPinnedUser(ctx, r.db, "tag") @@ -1107,7 +1124,7 @@ func (r *repository) ListPipelineTags(ctx context.Context, pipelineUID uuid.UUID } -func (r *repository) AddPipelineRuns(ctx context.Context, pipelineUID uuid.UUID) error { +func (r *repository) IncreasePipelineRuns(ctx context.Context, pipelineUID uuid.UUID) error { db := r.db.WithContext(ctx) result := db.Model(&datamodel.Pipeline{}). @@ -1123,7 +1140,7 @@ func (r *repository) AddPipelineRuns(ctx context.Context, pipelineUID uuid.UUID) return nil } -func (r *repository) AddPipelineClones(ctx context.Context, pipelineUID uuid.UUID) error { +func (r *repository) IncreasePipelineClones(ctx context.Context, pipelineUID uuid.UUID) error { db := r.db diff --git a/pkg/service/main.go b/pkg/service/main.go index 6e7d9d13b..853a83bcd 100644 --- a/pkg/service/main.go +++ b/pkg/service/main.go @@ -39,7 +39,7 @@ type Service interface { DeleteNamespacePipelineByID(ctx context.Context, ns resource.Namespace, id string) error ValidateNamespacePipelineByID(ctx context.Context, ns resource.Namespace, id string) ([]*pb.ErrPipelineValidation, error) GetNamespacePipelineLatestReleaseUID(ctx context.Context, ns resource.Namespace, id string) (uuid.UUID, error) - CloneNamespacePipeline(ctx context.Context, ns resource.Namespace, id, targetNamespaceID, targetPipelineID, description string, sharing *pb.Sharing) (*pb.Pipeline, error) + CloneNamespacePipeline(ctx context.Context, ns resource.Namespace, id, targetNamespaceID, targetPipelineID, description string, sharing *pb.Sharing, asTemplate bool, templateOverrides *pb.TemplateOverrides) (*pb.Pipeline, error) ListPipelinesAdmin(ctx context.Context, pageSize int32, pageToken string, view pb.Pipeline_View, filter filtering.Filter, showDeleted bool) ([]*pb.Pipeline, int32, string, error) GetPipelineByUIDAdmin(ctx context.Context, uid uuid.UUID, view pb.Pipeline_View) (*pb.Pipeline, error) @@ -51,7 +51,7 @@ type Service interface { DeleteNamespacePipelineReleaseByID(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id string) error RestoreNamespacePipelineReleaseByID(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id string) error UpdateNamespacePipelineReleaseIDByID(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id string, newID string) (*pb.PipelineRelease, error) - CloneNamespacePipelineRelease(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id, targetNamespaceID, targetPipelineID, description string, sharing *pb.Sharing) (*pb.Pipeline, error) + CloneNamespacePipelineRelease(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id, targetNamespaceID, targetPipelineID, description string, sharing *pb.Sharing, asTemplate bool, templateOverrides *pb.TemplateOverrides) (*pb.Pipeline, error) CreateNamespaceSecret(ctx context.Context, ns resource.Namespace, secret *pb.Secret) (*pb.Secret, error) ListNamespaceSecrets(ctx context.Context, ns resource.Namespace, pageSize int32, pageToken string, filter filtering.Filter) ([]*pb.Secret, int32, string, error) diff --git a/pkg/service/pipeline.go b/pkg/service/pipeline.go index fad21311d..c53ce19be 100644 --- a/pkg/service/pipeline.go +++ b/pkg/service/pipeline.go @@ -21,6 +21,7 @@ import ( "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/types/known/anypb" "google.golang.org/protobuf/types/known/structpb" + "gorm.io/datatypes" workflowpb "go.temporal.io/api/workflow/v1" rpcstatus "google.golang.org/genproto/googleapis/rpc/status" @@ -128,6 +129,121 @@ func (s *service) GetPipelineByUID(ctx context.Context, uid uuid.UUID, view pipe return s.converter.ConvertPipelineToPB(ctx, dbPipeline, view, true, true) } +func (s *service) CreateNamespacePipelineWithTemplate(ctx context.Context, ns resource.Namespace, pipelineID string, templatePipelineUID uuid.UUID, templatePipelineReleaseUID uuid.UUID, templateOverrides *pipelinepb.TemplateOverrides) (*pipelinepb.Pipeline, error) { + fmt.Println("3") + if err := s.checkNamespacePermission(ctx, ns); err != nil { + return nil, err + } + + ownerPermalink := ns.Permalink() + + // TODO: optimize ACL model + if ns.NsType == "organizations" { + granted, err := s.aclClient.CheckPermission(ctx, "organization", ns.NsUID, "member") + if err != nil { + return nil, err + } + if !granted { + return nil, errdomain.ErrUnauthorized + } + } else if ns.NsUID != uuid.FromStringOrNil(resource.GetRequestSingleHeader(ctx, constant.HeaderUserUIDKey)) { + return nil, errdomain.ErrUnauthorized + } + fmt.Println("4", templatePipelineUID) + + pbPipeline, err := s.GetPipelineByUID(ctx, templatePipelineUID, pipelinepb.Pipeline_VIEW_BASIC) + if err != nil { + return nil, err + } + fmt.Println("5") + + dbPipeline, err := s.converter.ConvertPipelineToDB(ctx, ns, pbPipeline) + if err != nil { + return nil, err + } + dbPipeline.UID, err = uuid.NewV4() + if err != nil { + return nil, err + } + dbPipeline.ID = pipelineID + dbPipeline.Owner = ns.Permalink() + dbPipeline.Recipe = nil + dbPipeline.UseTemplate = true + dbPipeline.TemplatePipelineUID = templatePipelineUID + dbPipeline.TemplatePipelineReleaseUID = templatePipelineReleaseUID + templateOverridesBytes, err := json.Marshal(templateOverrides) + if err != nil { + return nil, err + } + fmt.Println("6") + dbPipeline.TemplateOverrides = datatypes.JSON(templateOverridesBytes) + dbPipeline.ShareCode = generateShareCode() + fmt.Println("7") + + if err := s.repository.CreateNamespacePipeline(ctx, dbPipeline); err != nil { + return nil, err + } + + fmt.Println("8", ownerPermalink, dbPipeline.ID) + dbCreatedPipeline, err := s.repository.GetNamespacePipelineByID(ctx, ownerPermalink, dbPipeline.ID, false, true) + if err != nil { + return nil, err + } + fmt.Println("8") + + if err := s.configureRunOn(ctx, configureRunOnParams{ + Namespace: ns, + pipelineUID: dbPipeline.UID, + releaseUID: uuid.Nil, + recipe: dbCreatedPipeline.Recipe, + }); err != nil { + return nil, err + } + fmt.Println("9") + ownerType := string(ns.NsType)[0 : len(string(ns.NsType))-1] + ownerUID := ns.NsUID + err = s.aclClient.SetOwner(ctx, "pipeline", dbCreatedPipeline.UID, ownerType, ownerUID) + if err != nil { + return nil, err + } + // TODO: use OpenFGA as single source of truth + err = s.aclClient.SetPipelinePermissionMap(ctx, dbCreatedPipeline) + if err != nil { + return nil, err + } + toCreatedTags := pbPipeline.GetTags() + toBeCreatedTagNames := make([]string, 0, len(toCreatedTags)) + for _, tag := range toCreatedTags { + tag = strings.ToLower(tag) + if !slices.Contains(preserveTags, tag) { + toBeCreatedTagNames = append(toBeCreatedTagNames, tag) + } + } + + fmt.Println("10") + if len(toBeCreatedTagNames) > 0 { + err = s.repository.CreatePipelineTags(ctx, dbCreatedPipeline.UID, toBeCreatedTagNames) + if err != nil { + return nil, err + } + dbCreatedPipeline, err = s.repository.GetNamespacePipelineByID(ctx, ownerPermalink, dbPipeline.ID, false, true) + if err != nil { + return nil, err + } + } + fmt.Println("11") + + pipeline, err := s.converter.ConvertPipelineToPB(ctx, dbCreatedPipeline, pipelinepb.Pipeline_VIEW_FULL, false, true) + if err != nil { + return nil, err + } + pipeline.Permission = &pipelinepb.Permission{ + CanEdit: true, + CanTrigger: true, + } + return pipeline, nil +} + func (s *service) CreateNamespacePipeline(ctx context.Context, ns resource.Namespace, pbPipeline *pipelinepb.Pipeline) (*pipelinepb.Pipeline, error) { if err := s.checkNamespacePermission(ctx, ns); err != nil { @@ -547,6 +663,9 @@ func (s *service) UpdateNamespacePipelineByID(ctx context.Context, ns resource.N if existingPipeline, _ = s.repository.GetNamespacePipelineByID(ctx, ownerPermalink, id, false, false); existingPipeline == nil { return nil, err } + if existingPipeline.UseTemplate { + return nil, errdomain.ErrCanNotUpdatePipelineWithTemplate + } if existingPipeline.ShareCode == "" { dbPipeline.ShareCode = generateShareCode() @@ -711,7 +830,7 @@ func (s *service) generateCloneTargetNamespace(ctx context.Context, targetNamesp return targetNS, nil } -func (s *service) CloneNamespacePipeline(ctx context.Context, ns resource.Namespace, id, targetNamespaceID, targetPipelineID, description string, sharing *pipelinepb.Sharing) (*pipelinepb.Pipeline, error) { +func (s *service) CloneNamespacePipeline(ctx context.Context, ns resource.Namespace, id, targetNamespaceID, targetPipelineID, description string, sharing *pipelinepb.Sharing, asTemplate bool, templateOverrides *pipelinepb.TemplateOverrides) (*pipelinepb.Pipeline, error) { sourcePipeline, err := s.GetNamespacePipelineByID(ctx, ns, id, pipelinepb.Pipeline_VIEW_RECIPE) if err != nil { return nil, err @@ -721,26 +840,36 @@ func (s *service) CloneNamespacePipeline(ctx context.Context, ns resource.Namesp return nil, err } - newPipeline := &pipelinepb.Pipeline{ - Id: targetPipelineID, - Description: &description, - Sharing: sharing, - RawRecipe: sourcePipeline.RawRecipe, - Metadata: sourcePipeline.Metadata, - } + var pipeline *pipelinepb.Pipeline + if asTemplate { + fmt.Println("2") + pipeline, err = s.CreateNamespacePipelineWithTemplate(ctx, targetNS, targetPipelineID, uuid.FromStringOrNil(sourcePipeline.Uid), uuid.Nil, templateOverrides) + if err != nil { + return nil, err + } + } else { - pipeline, err := s.CreateNamespacePipeline(ctx, targetNS, newPipeline) - if err != nil { - return nil, err + newPipeline := &pipelinepb.Pipeline{ + Id: targetPipelineID, + Description: &description, + Sharing: sharing, + RawRecipe: sourcePipeline.RawRecipe, + Metadata: sourcePipeline.Metadata, + } + + pipeline, err = s.CreateNamespacePipeline(ctx, targetNS, newPipeline) + if err != nil { + return nil, err + } } - err = s.repository.AddPipelineClones(ctx, uuid.FromStringOrNil(sourcePipeline.Uid)) + err = s.repository.IncreasePipelineClones(ctx, uuid.FromStringOrNil(sourcePipeline.Uid)) if err != nil { return nil, err } return pipeline, nil } -func (s *service) CloneNamespacePipelineRelease(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id, targetNamespaceID, targetPipelineID, description string, sharing *pipelinepb.Sharing) (*pipelinepb.Pipeline, error) { +func (s *service) CloneNamespacePipelineRelease(ctx context.Context, ns resource.Namespace, pipelineUID uuid.UUID, id, targetNamespaceID, targetPipelineID, description string, sharing *pipelinepb.Sharing, asTemplate bool, templateOverrides *pipelinepb.TemplateOverrides) (*pipelinepb.Pipeline, error) { sourcePipelineRelease, err := s.GetNamespacePipelineReleaseByID(ctx, ns, pipelineUID, id, pipelinepb.Pipeline_VIEW_RECIPE) if err != nil { return nil, err @@ -750,19 +879,28 @@ func (s *service) CloneNamespacePipelineRelease(ctx context.Context, ns resource return nil, err } - newPipeline := &pipelinepb.Pipeline{ - Id: targetPipelineID, - Description: &description, - Sharing: sharing, - RawRecipe: sourcePipelineRelease.RawRecipe, - Metadata: sourcePipelineRelease.Metadata, - } + var pipeline *pipelinepb.Pipeline + if asTemplate { + pipeline, err = s.CreateNamespacePipelineWithTemplate(ctx, targetNS, targetPipelineID, pipelineUID, uuid.FromStringOrNil(sourcePipelineRelease.Uid), templateOverrides) + if err != nil { + return nil, err + } + } else { - pipeline, err := s.CreateNamespacePipeline(ctx, targetNS, newPipeline) - if err != nil { - return nil, err + newPipeline := &pipelinepb.Pipeline{ + Id: targetPipelineID, + Description: &description, + Sharing: sharing, + RawRecipe: sourcePipelineRelease.RawRecipe, + Metadata: sourcePipelineRelease.Metadata, + } + + pipeline, err = s.CreateNamespacePipeline(ctx, targetNS, newPipeline) + if err != nil { + return nil, err + } } - err = s.repository.AddPipelineClones(ctx, pipelineUID) + err = s.repository.IncreasePipelineClones(ctx, pipelineUID) if err != nil { return nil, err } @@ -832,6 +970,10 @@ func (s *service) UpdateNamespacePipelineIDByID(ctx context.Context, ns resource return s.converter.ConvertPipelineToPB(ctx, dbPipeline, pipelinepb.Pipeline_VIEW_FULL, true, true) } +type templateOverrides struct { + ConnectionReferences map[string]string `json:"connectionReferences"` +} + // preTriggerPipeline does the following: // 1. Upload pipeline input data to minio if the data is blob data. // 2. New workflow memory. @@ -853,6 +995,7 @@ func (s *service) preTriggerPipeline( r *datamodel.Recipe, pipelineTriggerID string, pipelineData []*pipelinepb.TriggerData, + templateOverridesJSON datatypes.JSON, expiryRule miniox.ExpiryRule, ) error { batchSize := len(pipelineData) @@ -937,6 +1080,14 @@ func (s *service) preTriggerPipeline( uploadingPipelineData[idx] = make(map[string]any) } + var overrides *templateOverrides + if templateOverridesJSON != nil { + err = json.Unmarshal(templateOverridesJSON, overrides) + if err != nil { + return fmt.Errorf("unmarshalling template overrides: %w", err) + } + } + // TODO(huitang): implement a structpb to format.Value converter for idx, d := range pipelineData { @@ -1442,6 +1593,13 @@ func (s *service) preTriggerPipeline( } connRefs := data.Map{} + + if overrides != nil { + for k, v := range overrides.ConnectionReferences { + connRefs[k] = data.NewString(v) + } + } + for k, v := range d.ConnectionReferences { connRefs[k] = data.NewString(v) } @@ -2022,7 +2180,7 @@ func (s *service) TriggerNamespacePipelineByID(ctx context.Context, ns resource. return nil, nil, fmt.Errorf("accessing expiry rule: %w", err) } - err = s.preTriggerPipeline(ctx, requester, dbPipeline.Recipe, pipelineTriggerID, data, expiryRule) + err = s.preTriggerPipeline(ctx, requester, dbPipeline.Recipe, pipelineTriggerID, data, dbPipeline.TemplateOverrides, expiryRule) if err != nil { return nil, nil, err } @@ -2079,7 +2237,7 @@ func (s *service) TriggerAsyncNamespacePipelineByID(ctx context.Context, ns reso return nil, fmt.Errorf("accessing expiry rule: %w", err) } - err = s.preTriggerPipeline(ctx, requester, dbPipeline.Recipe, pipelineTriggerID, data, expiryRule) + err = s.preTriggerPipeline(ctx, requester, dbPipeline.Recipe, pipelineTriggerID, data, dbPipeline.TemplateOverrides, expiryRule) if err != nil { return nil, err } @@ -2140,7 +2298,8 @@ func (s *service) TriggerNamespacePipelineReleaseByID(ctx context.Context, ns re return nil, nil, fmt.Errorf("accessing expiry rule: %w", err) } - err = s.preTriggerPipeline(ctx, requester, dbPipelineRelease.Recipe, pipelineTriggerID, data, expiryRule) + // TODO: add template overrides for pipeline release + err = s.preTriggerPipeline(ctx, requester, dbPipelineRelease.Recipe, pipelineTriggerID, data, nil, expiryRule) if err != nil { return nil, nil, err } @@ -2204,7 +2363,8 @@ func (s *service) TriggerAsyncNamespacePipelineReleaseByID(ctx context.Context, return nil, fmt.Errorf("accessing expiry rule: %w", err) } - err = s.preTriggerPipeline(ctx, requester, dbPipelineRelease.Recipe, pipelineTriggerID, data, expiryRule) + // TODO: add template overrides for pipeline release + err = s.preTriggerPipeline(ctx, requester, dbPipelineRelease.Recipe, pipelineTriggerID, data, nil, expiryRule) if err != nil { return nil, err } diff --git a/pkg/worker/workflow.go b/pkg/worker/workflow.go index f70dc7da0..9ad2e8746 100644 --- a/pkg/worker/workflow.go +++ b/pkg/worker/workflow.go @@ -1394,7 +1394,7 @@ func (w *worker) IncreasePipelineTriggerCountActivity(ctx context.Context, sv re l = l.With(zap.Reflect("systemVariables", sv)) l.Info("IncreasePipelineTriggerCountActivity started") - if err := w.repository.AddPipelineRuns(ctx, sv.PipelineUID); err != nil { + if err := w.repository.IncreasePipelineRuns(ctx, sv.PipelineUID); err != nil { l.With(zap.Error(err)).Error("Couldn't update number of pipeline runs.") }