Migrate to mockery v3 (#5547)

.mockery.yaml

@@ -1,2 +1,22 @@
 ---
-disable-version-string: true
+all: true
+dir: '{{.InterfaceDir}}/mocks'
+filename: mock_{{.InterfaceName}}.go
+pkgname: mocks
+recursive: true
+packages:
+  go.woodpecker-ci.org/woodpecker/v3/pipeline/rpc:
+    config:
+      recursive: false
+  go.woodpecker-ci.org/woodpecker/v3/server/forge:
+  go.woodpecker-ci.org/woodpecker/v3/server/queue:
+  go.woodpecker-ci.org/woodpecker/v3/server/services:
+    config:
+      exclude-subpkg-regex:
+        - types
+  go.woodpecker-ci.org/woodpecker/v3/server/services/config:
+  go.woodpecker-ci.org/woodpecker/v3/server/services/environment:
+  go.woodpecker-ci.org/woodpecker/v3/server/services/registry:
+  go.woodpecker-ci.org/woodpecker/v3/server/services/secret:
+  go.woodpecker-ci.org/woodpecker/v3/server/store:
+  go.woodpecker-ci.org/woodpecker/v3/woodpecker-go/woodpecker:

Makefile

@@ -119,10 +119,11 @@ clean-all: clean ## Clean all artifacts
 
 .PHONY: generate
 generate: install-tools generate-openapi ## Run all code generations
+	mockery
 	CGO_ENABLED=0 go generate ./...
 
 generate-openapi: install-tools ## Run openapi code generation and format it
-	go run github.com/swaggo/swag/cmd/swag fmt
+	go run github.com/swaggo/swag/cmd/swag fmt --exclude pipeline/rpc/proto
 	CGO_ENABLED=0 go generate cmd/server/openapi.go
 
 generate-license-header: install-tools
@@ -144,7 +145,7 @@ install-tools: ## Install development tools
 		go install github.com/google/addlicense@latest; \
 	fi ; \
 	hash mockery > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go install github.com/vektra/mockery/v2@latest; \
+		go install github.com/vektra/mockery/v3@latest; \
 	fi ; \
 	hash protoc-gen-go > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
 		go install google.golang.org/protobuf/cmd/protoc-gen-go@latest; \

cli/pipeline/list_test.go

@@ -65,7 +65,7 @@ func TestPipelineList(t *testing.T) {
 
 	for _, tt := range testtases {
 		t.Run(tt.name, func(t *testing.T) {
-			mockClient := mocks.NewClient(t)
+			mockClient := mocks.NewMockClient(t)
 			mockClient.On("PipelineList", mock.Anything, mock.Anything).Return(func(_ int64, opt woodpecker.PipelineListOptions) ([]*woodpecker.Pipeline, error) {
 				if tt.pipelineErr != nil {
 					return nil, tt.pipelineErr

cli/pipeline/purge_test.go

@@ -76,7 +76,7 @@ func TestPipelinePurge(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			mockClient := mocks.NewClient(t)
+			mockClient := mocks.NewMockClient(t)
 			mockClient.On("RepoLookup", mock.Anything).Maybe().Return(&woodpecker.Repo{ID: tt.repoID}, nil)
 
 			mockClient.On("PipelineList", mock.Anything, mock.Anything).Return(func(_ int64, opt woodpecker.PipelineListOptions) ([]*woodpecker.Pipeline, error) {

cli/repo/repo_show_test.go

@@ -48,7 +48,7 @@ func TestRepoShow(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			mockClient := mocks.NewClient(t)
+			mockClient := mocks.NewMockClient(t)
 			mockClient.On("Repo", tt.repoID).Return(tt.mockRepo, tt.mockError).Maybe()
 			mockClient.On("RepoLookup", "owner/repo").Return(tt.mockRepo, nil).Maybe()
 

flake.nix

@@ -37,7 +37,7 @@
               glibc.static
               gofumpt
               golangci-lint
-              go-mockery_2
+              go-mockery
               protobuf
               sqlite
               go-swag # for generate-openapi

pipeline/log/line_writer_test.go

@@ -26,7 +26,7 @@ import (
 )
 
 func TestLineWriter(t *testing.T) {
-	peer := mocks.NewPeer(t)
+	peer := mocks.NewMockPeer(t)
 	peer.On("EnqueueLog", mock.Anything)
 
 	secrets := []string{"world"}

pipeline/rpc/mocks/mock_Peer.go

@@ -0,0 +1,680 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	"context"
+
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/pipeline/rpc"
+)
+
+// NewMockPeer creates a new instance of MockPeer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockPeer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockPeer {
+	mock := &MockPeer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockPeer is an autogenerated mock type for the Peer type
+type MockPeer struct {
+	mock.Mock
+}
+
+type MockPeer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockPeer) EXPECT() *MockPeer_Expecter {
+	return &MockPeer_Expecter{mock: &_m.Mock}
+}
+
+// Done provides a mock function for the type MockPeer
+func (_mock *MockPeer) Done(c context.Context, workflowID string, state rpc.WorkflowState) error {
+	ret := _mock.Called(c, workflowID, state)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Done")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, rpc.WorkflowState) error); ok {
+		r0 = returnFunc(c, workflowID, state)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
+type MockPeer_Done_Call struct {
+	*mock.Call
+}
+
+// Done is a helper method to define mock.On call
+//   - c context.Context
+//   - workflowID string
+//   - state rpc.WorkflowState
+func (_e *MockPeer_Expecter) Done(c interface{}, workflowID interface{}, state interface{}) *MockPeer_Done_Call {
+	return &MockPeer_Done_Call{Call: _e.mock.On("Done", c, workflowID, state)}
+}
+
+func (_c *MockPeer_Done_Call) Run(run func(c context.Context, workflowID string, state rpc.WorkflowState)) *MockPeer_Done_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 rpc.WorkflowState
+		if args[2] != nil {
+			arg2 = args[2].(rpc.WorkflowState)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Done_Call) Return(err error) *MockPeer_Done_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_Done_Call) RunAndReturn(run func(c context.Context, workflowID string, state rpc.WorkflowState) error) *MockPeer_Done_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// EnqueueLog provides a mock function for the type MockPeer
+func (_mock *MockPeer) EnqueueLog(logEntry *rpc.LogEntry) {
+	_mock.Called(logEntry)
+	return
+}
+
+// MockPeer_EnqueueLog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueLog'
+type MockPeer_EnqueueLog_Call struct {
+	*mock.Call
+}
+
+// EnqueueLog is a helper method to define mock.On call
+//   - logEntry *rpc.LogEntry
+func (_e *MockPeer_Expecter) EnqueueLog(logEntry interface{}) *MockPeer_EnqueueLog_Call {
+	return &MockPeer_EnqueueLog_Call{Call: _e.mock.On("EnqueueLog", logEntry)}
+}
+
+func (_c *MockPeer_EnqueueLog_Call) Run(run func(logEntry *rpc.LogEntry)) *MockPeer_EnqueueLog_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *rpc.LogEntry
+		if args[0] != nil {
+			arg0 = args[0].(*rpc.LogEntry)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_EnqueueLog_Call) Return() *MockPeer_EnqueueLog_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockPeer_EnqueueLog_Call) RunAndReturn(run func(logEntry *rpc.LogEntry)) *MockPeer_EnqueueLog_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Extend provides a mock function for the type MockPeer
+func (_mock *MockPeer) Extend(c context.Context, workflowID string) error {
+	ret := _mock.Called(c, workflowID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Extend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
+		r0 = returnFunc(c, workflowID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_Extend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extend'
+type MockPeer_Extend_Call struct {
+	*mock.Call
+}
+
+// Extend is a helper method to define mock.On call
+//   - c context.Context
+//   - workflowID string
+func (_e *MockPeer_Expecter) Extend(c interface{}, workflowID interface{}) *MockPeer_Extend_Call {
+	return &MockPeer_Extend_Call{Call: _e.mock.On("Extend", c, workflowID)}
+}
+
+func (_c *MockPeer_Extend_Call) Run(run func(c context.Context, workflowID string)) *MockPeer_Extend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Extend_Call) Return(err error) *MockPeer_Extend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_Extend_Call) RunAndReturn(run func(c context.Context, workflowID string) error) *MockPeer_Extend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Init provides a mock function for the type MockPeer
+func (_mock *MockPeer) Init(c context.Context, workflowID string, state rpc.WorkflowState) error {
+	ret := _mock.Called(c, workflowID, state)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Init")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, rpc.WorkflowState) error); ok {
+		r0 = returnFunc(c, workflowID, state)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
+type MockPeer_Init_Call struct {
+	*mock.Call
+}
+
+// Init is a helper method to define mock.On call
+//   - c context.Context
+//   - workflowID string
+//   - state rpc.WorkflowState
+func (_e *MockPeer_Expecter) Init(c interface{}, workflowID interface{}, state interface{}) *MockPeer_Init_Call {
+	return &MockPeer_Init_Call{Call: _e.mock.On("Init", c, workflowID, state)}
+}
+
+func (_c *MockPeer_Init_Call) Run(run func(c context.Context, workflowID string, state rpc.WorkflowState)) *MockPeer_Init_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 rpc.WorkflowState
+		if args[2] != nil {
+			arg2 = args[2].(rpc.WorkflowState)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Init_Call) Return(err error) *MockPeer_Init_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_Init_Call) RunAndReturn(run func(c context.Context, workflowID string, state rpc.WorkflowState) error) *MockPeer_Init_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Next provides a mock function for the type MockPeer
+func (_mock *MockPeer) Next(c context.Context, f rpc.Filter) (*rpc.Workflow, error) {
+	ret := _mock.Called(c, f)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Next")
+	}
+
+	var r0 *rpc.Workflow
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, rpc.Filter) (*rpc.Workflow, error)); ok {
+		return returnFunc(c, f)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, rpc.Filter) *rpc.Workflow); ok {
+		r0 = returnFunc(c, f)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*rpc.Workflow)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, rpc.Filter) error); ok {
+		r1 = returnFunc(c, f)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockPeer_Next_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Next'
+type MockPeer_Next_Call struct {
+	*mock.Call
+}
+
+// Next is a helper method to define mock.On call
+//   - c context.Context
+//   - f rpc.Filter
+func (_e *MockPeer_Expecter) Next(c interface{}, f interface{}) *MockPeer_Next_Call {
+	return &MockPeer_Next_Call{Call: _e.mock.On("Next", c, f)}
+}
+
+func (_c *MockPeer_Next_Call) Run(run func(c context.Context, f rpc.Filter)) *MockPeer_Next_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 rpc.Filter
+		if args[1] != nil {
+			arg1 = args[1].(rpc.Filter)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Next_Call) Return(workflow *rpc.Workflow, err error) *MockPeer_Next_Call {
+	_c.Call.Return(workflow, err)
+	return _c
+}
+
+func (_c *MockPeer_Next_Call) RunAndReturn(run func(c context.Context, f rpc.Filter) (*rpc.Workflow, error)) *MockPeer_Next_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegisterAgent provides a mock function for the type MockPeer
+func (_mock *MockPeer) RegisterAgent(ctx context.Context, info rpc.AgentInfo) (int64, error) {
+	ret := _mock.Called(ctx, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegisterAgent")
+	}
+
+	var r0 int64
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, rpc.AgentInfo) (int64, error)); ok {
+		return returnFunc(ctx, info)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, rpc.AgentInfo) int64); ok {
+		r0 = returnFunc(ctx, info)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, rpc.AgentInfo) error); ok {
+		r1 = returnFunc(ctx, info)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockPeer_RegisterAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAgent'
+type MockPeer_RegisterAgent_Call struct {
+	*mock.Call
+}
+
+// RegisterAgent is a helper method to define mock.On call
+//   - ctx context.Context
+//   - info rpc.AgentInfo
+func (_e *MockPeer_Expecter) RegisterAgent(ctx interface{}, info interface{}) *MockPeer_RegisterAgent_Call {
+	return &MockPeer_RegisterAgent_Call{Call: _e.mock.On("RegisterAgent", ctx, info)}
+}
+
+func (_c *MockPeer_RegisterAgent_Call) Run(run func(ctx context.Context, info rpc.AgentInfo)) *MockPeer_RegisterAgent_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 rpc.AgentInfo
+		if args[1] != nil {
+			arg1 = args[1].(rpc.AgentInfo)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_RegisterAgent_Call) Return(n int64, err error) *MockPeer_RegisterAgent_Call {
+	_c.Call.Return(n, err)
+	return _c
+}
+
+func (_c *MockPeer_RegisterAgent_Call) RunAndReturn(run func(ctx context.Context, info rpc.AgentInfo) (int64, error)) *MockPeer_RegisterAgent_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReportHealth provides a mock function for the type MockPeer
+func (_mock *MockPeer) ReportHealth(c context.Context) error {
+	ret := _mock.Called(c)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReportHealth")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
+		r0 = returnFunc(c)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_ReportHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportHealth'
+type MockPeer_ReportHealth_Call struct {
+	*mock.Call
+}
+
+// ReportHealth is a helper method to define mock.On call
+//   - c context.Context
+func (_e *MockPeer_Expecter) ReportHealth(c interface{}) *MockPeer_ReportHealth_Call {
+	return &MockPeer_ReportHealth_Call{Call: _e.mock.On("ReportHealth", c)}
+}
+
+func (_c *MockPeer_ReportHealth_Call) Run(run func(c context.Context)) *MockPeer_ReportHealth_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_ReportHealth_Call) Return(err error) *MockPeer_ReportHealth_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_ReportHealth_Call) RunAndReturn(run func(c context.Context) error) *MockPeer_ReportHealth_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UnregisterAgent provides a mock function for the type MockPeer
+func (_mock *MockPeer) UnregisterAgent(ctx context.Context) error {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UnregisterAgent")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_UnregisterAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnregisterAgent'
+type MockPeer_UnregisterAgent_Call struct {
+	*mock.Call
+}
+
+// UnregisterAgent is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockPeer_Expecter) UnregisterAgent(ctx interface{}) *MockPeer_UnregisterAgent_Call {
+	return &MockPeer_UnregisterAgent_Call{Call: _e.mock.On("UnregisterAgent", ctx)}
+}
+
+func (_c *MockPeer_UnregisterAgent_Call) Run(run func(ctx context.Context)) *MockPeer_UnregisterAgent_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_UnregisterAgent_Call) Return(err error) *MockPeer_UnregisterAgent_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_UnregisterAgent_Call) RunAndReturn(run func(ctx context.Context) error) *MockPeer_UnregisterAgent_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Update provides a mock function for the type MockPeer
+func (_mock *MockPeer) Update(c context.Context, workflowID string, state rpc.StepState) error {
+	ret := _mock.Called(c, workflowID, state)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, rpc.StepState) error); ok {
+		r0 = returnFunc(c, workflowID, state)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
+type MockPeer_Update_Call struct {
+	*mock.Call
+}
+
+// Update is a helper method to define mock.On call
+//   - c context.Context
+//   - workflowID string
+//   - state rpc.StepState
+func (_e *MockPeer_Expecter) Update(c interface{}, workflowID interface{}, state interface{}) *MockPeer_Update_Call {
+	return &MockPeer_Update_Call{Call: _e.mock.On("Update", c, workflowID, state)}
+}
+
+func (_c *MockPeer_Update_Call) Run(run func(c context.Context, workflowID string, state rpc.StepState)) *MockPeer_Update_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 rpc.StepState
+		if args[2] != nil {
+			arg2 = args[2].(rpc.StepState)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Update_Call) Return(err error) *MockPeer_Update_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_Update_Call) RunAndReturn(run func(c context.Context, workflowID string, state rpc.StepState) error) *MockPeer_Update_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Version provides a mock function for the type MockPeer
+func (_mock *MockPeer) Version(c context.Context) (*rpc.Version, error) {
+	ret := _mock.Called(c)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Version")
+	}
+
+	var r0 *rpc.Version
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (*rpc.Version, error)); ok {
+		return returnFunc(c)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) *rpc.Version); ok {
+		r0 = returnFunc(c)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*rpc.Version)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(c)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockPeer_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
+type MockPeer_Version_Call struct {
+	*mock.Call
+}
+
+// Version is a helper method to define mock.On call
+//   - c context.Context
+func (_e *MockPeer_Expecter) Version(c interface{}) *MockPeer_Version_Call {
+	return &MockPeer_Version_Call{Call: _e.mock.On("Version", c)}
+}
+
+func (_c *MockPeer_Version_Call) Run(run func(c context.Context)) *MockPeer_Version_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Version_Call) Return(version *rpc.Version, err error) *MockPeer_Version_Call {
+	_c.Call.Return(version, err)
+	return _c
+}
+
+func (_c *MockPeer_Version_Call) RunAndReturn(run func(c context.Context) (*rpc.Version, error)) *MockPeer_Version_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Wait provides a mock function for the type MockPeer
+func (_mock *MockPeer) Wait(c context.Context, workflowID string) error {
+	ret := _mock.Called(c, workflowID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Wait")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
+		r0 = returnFunc(c, workflowID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockPeer_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait'
+type MockPeer_Wait_Call struct {
+	*mock.Call
+}
+
+// Wait is a helper method to define mock.On call
+//   - c context.Context
+//   - workflowID string
+func (_e *MockPeer_Expecter) Wait(c interface{}, workflowID interface{}) *MockPeer_Wait_Call {
+	return &MockPeer_Wait_Call{Call: _e.mock.On("Wait", c, workflowID)}
+}
+
+func (_c *MockPeer_Wait_Call) Run(run func(c context.Context, workflowID string)) *MockPeer_Wait_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockPeer_Wait_Call) Return(err error) *MockPeer_Wait_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockPeer_Wait_Call) RunAndReturn(run func(c context.Context, workflowID string) error) *MockPeer_Wait_Call {
+	_c.Call.Return(run)
+	return _c
+}

pipeline/rpc/mocks/peer.go

@@ -1,251 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-//go:build test
-// +build test
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	rpc "go.woodpecker-ci.org/woodpecker/v3/pipeline/rpc"
-)
-
-// Peer is an autogenerated mock type for the Peer type
-type Peer struct {
-	mock.Mock
-}
-
-// Done provides a mock function with given fields: c, workflowID, state
-func (_m *Peer) Done(c context.Context, workflowID string, state rpc.WorkflowState) error {
-	ret := _m.Called(c, workflowID, state)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Done")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, rpc.WorkflowState) error); ok {
-		r0 = rf(c, workflowID, state)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// EnqueueLog provides a mock function with given fields: logEntry
-func (_m *Peer) EnqueueLog(logEntry *rpc.LogEntry) {
-	_m.Called(logEntry)
-}
-
-// Extend provides a mock function with given fields: c, workflowID
-func (_m *Peer) Extend(c context.Context, workflowID string) error {
-	ret := _m.Called(c, workflowID)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Extend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
-		r0 = rf(c, workflowID)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Init provides a mock function with given fields: c, workflowID, state
-func (_m *Peer) Init(c context.Context, workflowID string, state rpc.WorkflowState) error {
-	ret := _m.Called(c, workflowID, state)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Init")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, rpc.WorkflowState) error); ok {
-		r0 = rf(c, workflowID, state)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Next provides a mock function with given fields: c, f
-func (_m *Peer) Next(c context.Context, f rpc.Filter) (*rpc.Workflow, error) {
-	ret := _m.Called(c, f)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Next")
-	}
-
-	var r0 *rpc.Workflow
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, rpc.Filter) (*rpc.Workflow, error)); ok {
-		return rf(c, f)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, rpc.Filter) *rpc.Workflow); ok {
-		r0 = rf(c, f)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*rpc.Workflow)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, rpc.Filter) error); ok {
-		r1 = rf(c, f)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterAgent provides a mock function with given fields: ctx, info
-func (_m *Peer) RegisterAgent(ctx context.Context, info rpc.AgentInfo) (int64, error) {
-	ret := _m.Called(ctx, info)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegisterAgent")
-	}
-
-	var r0 int64
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, rpc.AgentInfo) (int64, error)); ok {
-		return rf(ctx, info)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, rpc.AgentInfo) int64); ok {
-		r0 = rf(ctx, info)
-	} else {
-		r0 = ret.Get(0).(int64)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, rpc.AgentInfo) error); ok {
-		r1 = rf(ctx, info)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ReportHealth provides a mock function with given fields: c
-func (_m *Peer) ReportHealth(c context.Context) error {
-	ret := _m.Called(c)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ReportHealth")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(c)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// UnregisterAgent provides a mock function with given fields: ctx
-func (_m *Peer) UnregisterAgent(ctx context.Context) error {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UnregisterAgent")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(ctx)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Update provides a mock function with given fields: c, workflowID, state
-func (_m *Peer) Update(c context.Context, workflowID string, state rpc.StepState) error {
-	ret := _m.Called(c, workflowID, state)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Update")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, rpc.StepState) error); ok {
-		r0 = rf(c, workflowID, state)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Version provides a mock function with given fields: c
-func (_m *Peer) Version(c context.Context) (*rpc.Version, error) {
-	ret := _m.Called(c)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Version")
-	}
-
-	var r0 *rpc.Version
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (*rpc.Version, error)); ok {
-		return rf(c)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) *rpc.Version); ok {
-		r0 = rf(c)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*rpc.Version)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(c)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Wait provides a mock function with given fields: c, workflowID
-func (_m *Peer) Wait(c context.Context, workflowID string) error {
-	ret := _m.Called(c, workflowID)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Wait")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
-		r0 = rf(c, workflowID)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// NewPeer creates a new instance of Peer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewPeer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Peer {
-	mock := &Peer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

pipeline/rpc/peer.go

@@ -66,8 +66,6 @@ type (
 	}
 )
 
-//go:generate mockery --name Peer --output mocks --case underscore --note "+build test"
-
 // Peer defines a peer-to-peer connection.
 type Peer interface {
 	// Version returns the server- & grpc-version

pipeline/rpc/proto/woodpecker.pb.go

@@ -22,12 +22,11 @@
 package proto
 
 import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
 	unsafe "unsafe"
-
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
 const (

pipeline/rpc/proto/woodpecker_grpc.pb.go

@@ -23,7 +23,6 @@ package proto
 
 import (
 	context "context"
-
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"

server/api/agent_test.go

@@ -29,7 +29,7 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
 	"go.woodpecker-ci.org/woodpecker/v3/server/queue"
 	queue_mocks "go.woodpecker-ci.org/woodpecker/v3/server/queue/mocks"
-	mocks_manager "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
+	manager_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
 	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/store/types"
 )
@@ -47,7 +47,7 @@ func TestGetAgents(t *testing.T) {
 	t.Run("should get agents", func(t *testing.T) {
 		agents := []*model.Agent{fakeAgent}
 
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentList", mock.Anything).Return(agents, nil)
 
 		w := httptest.NewRecorder()
@@ -71,7 +71,7 @@ func TestGetAgent(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
 	t.Run("should get agent", func(t *testing.T) {
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentFind", int64(1)).Return(fakeAgent, nil)
 
 		w := httptest.NewRecorder()
@@ -103,7 +103,7 @@ func TestGetAgent(t *testing.T) {
 	})
 
 	t.Run("should return not found for non-existent agent", func(t *testing.T) {
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentFind", int64(2)).Return((*model.Agent)(nil), types.RecordNotExist)
 
 		w := httptest.NewRecorder()
@@ -122,14 +122,11 @@ func TestPatchAgent(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
 	t.Run("should update agent", func(t *testing.T) {
-		updatedAgent := *fakeAgent
-		updatedAgent.Name = "updated-agent"
-
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentFind", int64(1)).Return(fakeAgent, nil)
 		mockStore.On("AgentUpdate", mock.AnythingOfType("*model.Agent")).Return(nil)
 
-		mockManager := mocks_manager.NewManager(t)
+		mockManager := manager_mocks.NewMockManager(t)
 		server.Config.Services.Manager = mockManager
 
 		w := httptest.NewRecorder()
@@ -158,11 +155,10 @@ func TestPostAgent(t *testing.T) {
 
 	t.Run("should create agent", func(t *testing.T) {
 		newAgent := &model.Agent{
-			Name:       "new-agent",
-			NoSchedule: false,
+			Name: "new-agent",
 		}
 
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentCreate", mock.AnythingOfType("*model.Agent")).Return(nil)
 
 		w := httptest.NewRecorder()
@@ -190,14 +186,14 @@ func TestDeleteAgent(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
 	t.Run("should delete agent", func(t *testing.T) {
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentFind", int64(1)).Return(fakeAgent, nil)
 		mockStore.On("AgentDelete", mock.AnythingOfType("*model.Agent")).Return(nil)
 
-		mockManager := mocks_manager.NewManager(t)
+		mockManager := manager_mocks.NewMockManager(t)
 		server.Config.Services.Manager = mockManager
 
-		mockQueue := queue_mocks.NewQueue(t)
+		mockQueue := queue_mocks.NewMockQueue(t)
 		mockQueue.On("Info", mock.Anything).Return(queue.InfoT{})
 		mockQueue.On("KickAgentWorkers", int64(1)).Return()
 		server.Config.Services.Queue = mockQueue
@@ -217,13 +213,13 @@ func TestDeleteAgent(t *testing.T) {
 	})
 
 	t.Run("should not delete agent with running tasks", func(t *testing.T) {
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentFind", int64(1)).Return(fakeAgent, nil)
 
-		mockManager := mocks_manager.NewManager(t)
+		mockManager := manager_mocks.NewMockManager(t)
 		server.Config.Services.Manager = mockManager
 
-		mockQueue := queue_mocks.NewQueue(t)
+		mockQueue := queue_mocks.NewMockQueue(t)
 		mockQueue.On("Info", mock.Anything).Return(queue.InfoT{
 			Running: []*model.Task{{AgentID: 1}},
 		})
@@ -247,7 +243,7 @@ func TestPostOrgAgent(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
 	t.Run("create org agent should succeed", func(t *testing.T) {
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("AgentCreate", mock.AnythingOfType("*model.Agent")).Return(nil)
 
 		w := httptest.NewRecorder()

server/api/hook_test.go

@@ -13,26 +13,26 @@ import (
 
 	"go.woodpecker-ci.org/woodpecker/v3/server"
 	"go.woodpecker-ci.org/woodpecker/v3/server/api"
-	mocks_forge "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
+	forge_mocks "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
-	mocks_config_service "go.woodpecker-ci.org/woodpecker/v3/server/services/config/mocks"
-	mocks_services "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
+	config_service_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/config/mocks"
+	services_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/services/permissions"
-	mocks_registry_service "go.woodpecker-ci.org/woodpecker/v3/server/services/registry/mocks"
-	mocks_secret_service "go.woodpecker-ci.org/woodpecker/v3/server/services/secret/mocks"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	registry_service_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/registry/mocks"
+	secret_service_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/secret/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/shared/token"
 )
 
 func TestHook(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
-	_manager := mocks_services.NewManager(t)
-	_forge := mocks_forge.NewForge(t)
-	_store := mocks_store.NewStore(t)
-	_configService := mocks_config_service.NewService(t)
-	_secretService := mocks_secret_service.NewService(t)
-	_registryService := mocks_registry_service.NewService(t)
+	_manager := services_mocks.NewMockManager(t)
+	_forge := forge_mocks.NewMockForge(t)
+	_store := store_mocks.NewMockStore(t)
+	_configService := config_service_mocks.NewMockService(t)
+	_secretService := secret_service_mocks.NewMockService(t)
+	_registryService := registry_service_mocks.NewMockService(t)
 	server.Config.Services.Manager = _manager
 	server.Config.Permissions.Open = true
 	server.Config.Permissions.Orgs = permissions.NewOrgs(nil)

server/api/login_test.go

@@ -15,12 +15,12 @@ import (
 
 	"go.woodpecker-ci.org/woodpecker/v3/server"
 	"go.woodpecker-ci.org/woodpecker/v3/server/api"
-	mocks_forge "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
+	forge_mocks "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
 	forge_types "go.woodpecker-ci.org/woodpecker/v3/server/forge/types"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
-	mocks_services "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
+	services_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/services/permissions"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/store/types"
 	"go.woodpecker-ci.org/woodpecker/v3/shared/token"
 )
@@ -70,8 +70,8 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should fail if the state is wrong", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -103,9 +103,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should redirect to forge login page", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -139,9 +139,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should register a new user", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -173,9 +173,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should login an existing user", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -205,9 +205,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should deny a new user if registration is closed", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = false
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -233,9 +233,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should deny a user with missing org access", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs([]string{"org1"})
@@ -265,9 +265,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should create an user org if it does not exists", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -299,9 +299,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should link an user org if it has the same name as the user", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)
@@ -333,9 +333,9 @@ func TestHandleAuth(t *testing.T) {
 	})
 
 	t.Run("should update an user org if the user name was changed", func(t *testing.T) {
-		_manager := mocks_services.NewManager(t)
-		_forge := mocks_forge.NewForge(t)
-		_store := mocks_store.NewStore(t)
+		_manager := services_mocks.NewMockManager(t)
+		_forge := forge_mocks.NewMockForge(t)
+		_store := store_mocks.NewMockStore(t)
 		server.Config.Services.Manager = _manager
 		server.Config.Permissions.Open = true
 		server.Config.Permissions.Orgs = permissions.NewOrgs(nil)

server/api/pipeline_test.go

@@ -28,7 +28,7 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server"
 	forge_mocks "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
-	mocks_manager "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
+	manager_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
 	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/store/types"
 )
@@ -45,7 +45,7 @@ func TestGetPipelines(t *testing.T) {
 	t.Run("should get pipelines", func(t *testing.T) {
 		pipelines := []*model.Pipeline{fakePipeline}
 
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("GetPipelineList", mock.Anything, mock.Anything, mock.Anything).Return(pipelines, nil)
 
 		w := httptest.NewRecorder()
@@ -70,7 +70,7 @@ func TestGetPipelines(t *testing.T) {
 	t.Run("should parse pipeline filter", func(t *testing.T) {
 		pipelines := []*model.Pipeline{fakePipeline}
 
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("GetPipelineList", mock.Anything, mock.Anything, mock.Anything).Return(pipelines, nil)
 
 		c, _ := gin.CreateTestContext(httptest.NewRecorder())
@@ -85,7 +85,7 @@ func TestGetPipelines(t *testing.T) {
 	t.Run("should parse pipeline filter with tz offset", func(t *testing.T) {
 		pipelines := []*model.Pipeline{fakePipeline}
 
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("GetPipelineList", mock.Anything, mock.Anything, mock.Anything).Return(pipelines, nil)
 
 		c, _ := gin.CreateTestContext(httptest.NewRecorder())
@@ -99,7 +99,7 @@ func TestGetPipelines(t *testing.T) {
 
 	t.Run("should filter pipelines by events", func(t *testing.T) {
 		pipelines := []*model.Pipeline{fakePipeline}
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("GetPipelineList", mock.Anything, mock.Anything, mock.Anything).Return(pipelines, nil)
 
 		w := httptest.NewRecorder()
@@ -120,7 +120,7 @@ func TestDeletePipeline(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
 	t.Run("should delete pipeline", func(t *testing.T) {
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("GetPipelineNumber", mock.Anything, mock.Anything).Return(fakePipeline, nil)
 		mockStore.On("DeletePipeline", mock.Anything).Return(nil)
 
@@ -147,7 +147,7 @@ func TestDeletePipeline(t *testing.T) {
 		fakePipeline := *fakePipeline
 		fakePipeline.Status = model.StatusPending
 
-		mockStore := store_mocks.NewStore(t)
+		mockStore := store_mocks.NewMockStore(t)
 		mockStore.On("GetPipelineNumber", mock.Anything, mock.Anything).Return(&fakePipeline, nil)
 
 		c, _ := gin.CreateTestContext(httptest.NewRecorder())
@@ -173,15 +173,15 @@ func TestGetPipelineMetadata(t *testing.T) {
 
 	fakeRepo := &model.Repo{ID: 1}
 
-	mockForge := forge_mocks.NewForge(t)
+	mockForge := forge_mocks.NewMockForge(t)
 	mockForge.On("Name").Return("mock")
 	mockForge.On("URL").Return("https://codeberg.org")
 
-	mockManager := mocks_manager.NewManager(t)
+	mockManager := manager_mocks.NewMockManager(t)
 	mockManager.On("ForgeFromRepo", fakeRepo).Return(mockForge, nil)
 	server.Config.Services.Manager = mockManager
 
-	mockStore := store_mocks.NewStore(t)
+	mockStore := store_mocks.NewMockStore(t)
 	mockStore.On("GetPipelineNumber", mock.Anything, int64(2)).Return(fakePipeline, nil)
 	mockStore.On("GetPipelineLastBefore", mock.Anything, mock.Anything, int64(2)).Return(prevPipeline, nil)
 
@@ -218,7 +218,7 @@ func TestGetPipelineMetadata(t *testing.T) {
 		})
 
 		t.Run("should return not found for non-existent pipeline", func(t *testing.T) {
-			mockStore := store_mocks.NewStore(t)
+			mockStore := store_mocks.NewMockStore(t)
 			mockStore.On("GetPipelineNumber", mock.Anything, int64(3)).Return((*model.Pipeline)(nil), types.RecordNotExist)
 
 			w := httptest.NewRecorder()

server/cron/cron_test.go

@@ -22,16 +22,16 @@ import (
 	"github.com/stretchr/testify/mock"
 
 	"go.woodpecker-ci.org/woodpecker/v3/server"
-	mocks_forge "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
+	forge_mocks "go.woodpecker-ci.org/woodpecker/v3/server/forge/mocks"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
-	mocks_manager "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	manager_mocks "go.woodpecker-ci.org/woodpecker/v3/server/services/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 )
 
 func TestCreatePipeline(t *testing.T) {
-	_manager := mocks_manager.NewManager(t)
-	_forge := mocks_forge.NewForge(t)
-	store := mocks_store.NewStore(t)
+	_manager := manager_mocks.NewMockManager(t)
+	_forge := forge_mocks.NewMockForge(t)
+	store := store_mocks.NewMockStore(t)
 	ctx := t.Context()
 
 	creator := &model.User{

server/forge/bitbucket/bitbucket_test.go

@@ -30,7 +30,7 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server/forge/types"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
 	"go.woodpecker-ci.org/woodpecker/v3/server/store"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 )
 
 func TestNew(t *testing.T) {
@@ -206,7 +206,7 @@ func TestBitbucket(t *testing.T) {
 	req.Header = http.Header{}
 	req.Header.Set(hookEvent, hookPush)
 
-	mockStore := mocks_store.NewStore(t)
+	mockStore := store_mocks.NewMockStore(t)
 	ctx = store.InjectToContext(ctx, mockStore)
 	mockStore.On("GetUser", mock.Anything).Return(fakeUser, nil)
 	mockStore.On("GetRepoForgeID", mock.Anything).Return(fakeRepoFromHook, nil)

server/forge/forge.go

@@ -15,8 +15,6 @@
 
 package forge
 
-//go:generate mockery --name Forge --output mocks --case underscore --note "+build test"
-
 import (
 	"context"
 	"net/http"

server/forge/forgejo/forgejo_test.go

@@ -27,7 +27,7 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server/forge/forgejo/fixtures"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
 	"go.woodpecker-ci.org/woodpecker/v3/server/store"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 )
 
 func TestNew(t *testing.T) {
@@ -51,7 +51,7 @@ func Test_forgejo(t *testing.T) {
 		SkipVerify: true,
 	})
 
-	mockStore := mocks_store.NewStore(t)
+	mockStore := store_mocks.NewMockStore(t)
 	ctx := store.InjectToContext(t.Context(), mockStore)
 
 	t.Run("netrc with user token", func(t *testing.T) {

server/forge/gitea/gitea_test.go

@@ -28,7 +28,7 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server/forge/gitea/fixtures"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
 	"go.woodpecker-ci.org/woodpecker/v3/server/store"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 )
 
 func TestNew(t *testing.T) {
@@ -52,7 +52,7 @@ func Test_gitea(t *testing.T) {
 		SkipVerify: true,
 	})
 
-	mockStore := mocks_store.NewStore(t)
+	mockStore := store_mocks.NewMockStore(t)
 	ctx := store.InjectToContext(t.Context(), mockStore)
 
 	t.Run("netrc with user token", func(t *testing.T) {

server/forge/mocks/forge.go

@@ -1,561 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-//go:build test
-// +build test
-
-package mocks
-
-import (
-	context "context"
-
-	http "net/http"
-
-	mock "github.com/stretchr/testify/mock"
-
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-
-	types "go.woodpecker-ci.org/woodpecker/v3/server/forge/types"
-)
-
-// Forge is an autogenerated mock type for the Forge type
-type Forge struct {
-	mock.Mock
-}
-
-// Activate provides a mock function with given fields: ctx, u, r, link
-func (_m *Forge) Activate(ctx context.Context, u *model.User, r *model.Repo, link string) error {
-	ret := _m.Called(ctx, u, r, link)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Activate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, string) error); ok {
-		r0 = rf(ctx, u, r, link)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Auth provides a mock function with given fields: ctx, token, secret
-func (_m *Forge) Auth(ctx context.Context, token string, secret string) (string, error) {
-	ret := _m.Called(ctx, token, secret)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Auth")
-	}
-
-	var r0 string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
-		return rf(ctx, token, secret)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
-		r0 = rf(ctx, token, secret)
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
-		r1 = rf(ctx, token, secret)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// BranchHead provides a mock function with given fields: ctx, u, r, branch
-func (_m *Forge) BranchHead(ctx context.Context, u *model.User, r *model.Repo, branch string) (*model.Commit, error) {
-	ret := _m.Called(ctx, u, r, branch)
-
-	if len(ret) == 0 {
-		panic("no return value specified for BranchHead")
-	}
-
-	var r0 *model.Commit
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, string) (*model.Commit, error)); ok {
-		return rf(ctx, u, r, branch)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, string) *model.Commit); ok {
-		r0 = rf(ctx, u, r, branch)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Commit)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, *model.Repo, string) error); ok {
-		r1 = rf(ctx, u, r, branch)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Branches provides a mock function with given fields: ctx, u, r, p
-func (_m *Forge) Branches(ctx context.Context, u *model.User, r *model.Repo, p *model.ListOptions) ([]string, error) {
-	ret := _m.Called(ctx, u, r, p)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Branches")
-	}
-
-	var r0 []string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.ListOptions) ([]string, error)); ok {
-		return rf(ctx, u, r, p)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.ListOptions) []string); ok {
-		r0 = rf(ctx, u, r, p)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]string)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, *model.Repo, *model.ListOptions) error); ok {
-		r1 = rf(ctx, u, r, p)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Deactivate provides a mock function with given fields: ctx, u, r, link
-func (_m *Forge) Deactivate(ctx context.Context, u *model.User, r *model.Repo, link string) error {
-	ret := _m.Called(ctx, u, r, link)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Deactivate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, string) error); ok {
-		r0 = rf(ctx, u, r, link)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Dir provides a mock function with given fields: ctx, u, r, b, f
-func (_m *Forge) Dir(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, f string) ([]*types.FileMeta, error) {
-	ret := _m.Called(ctx, u, r, b, f)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Dir")
-	}
-
-	var r0 []*types.FileMeta
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, string) ([]*types.FileMeta, error)); ok {
-		return rf(ctx, u, r, b, f)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, string) []*types.FileMeta); ok {
-		r0 = rf(ctx, u, r, b, f)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*types.FileMeta)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, string) error); ok {
-		r1 = rf(ctx, u, r, b, f)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// File provides a mock function with given fields: ctx, u, r, b, f
-func (_m *Forge) File(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, f string) ([]byte, error) {
-	ret := _m.Called(ctx, u, r, b, f)
-
-	if len(ret) == 0 {
-		panic("no return value specified for File")
-	}
-
-	var r0 []byte
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, string) ([]byte, error)); ok {
-		return rf(ctx, u, r, b, f)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, string) []byte); ok {
-		r0 = rf(ctx, u, r, b, f)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]byte)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, string) error); ok {
-		r1 = rf(ctx, u, r, b, f)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Hook provides a mock function with given fields: ctx, r
-func (_m *Forge) Hook(ctx context.Context, r *http.Request) (*model.Repo, *model.Pipeline, error) {
-	ret := _m.Called(ctx, r)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Hook")
-	}
-
-	var r0 *model.Repo
-	var r1 *model.Pipeline
-	var r2 error
-	if rf, ok := ret.Get(0).(func(context.Context, *http.Request) (*model.Repo, *model.Pipeline, error)); ok {
-		return rf(ctx, r)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *http.Request) *model.Repo); ok {
-		r0 = rf(ctx, r)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Repo)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *http.Request) *model.Pipeline); ok {
-		r1 = rf(ctx, r)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.Pipeline)
-		}
-	}
-
-	if rf, ok := ret.Get(2).(func(context.Context, *http.Request) error); ok {
-		r2 = rf(ctx, r)
-	} else {
-		r2 = ret.Error(2)
-	}
-
-	return r0, r1, r2
-}
-
-// Login provides a mock function with given fields: ctx, r
-func (_m *Forge) Login(ctx context.Context, r *types.OAuthRequest) (*model.User, string, error) {
-	ret := _m.Called(ctx, r)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Login")
-	}
-
-	var r0 *model.User
-	var r1 string
-	var r2 error
-	if rf, ok := ret.Get(0).(func(context.Context, *types.OAuthRequest) (*model.User, string, error)); ok {
-		return rf(ctx, r)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *types.OAuthRequest) *model.User); ok {
-		r0 = rf(ctx, r)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.User)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *types.OAuthRequest) string); ok {
-		r1 = rf(ctx, r)
-	} else {
-		r1 = ret.Get(1).(string)
-	}
-
-	if rf, ok := ret.Get(2).(func(context.Context, *types.OAuthRequest) error); ok {
-		r2 = rf(ctx, r)
-	} else {
-		r2 = ret.Error(2)
-	}
-
-	return r0, r1, r2
-}
-
-// Name provides a mock function with no fields
-func (_m *Forge) Name() string {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Name")
-	}
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// Netrc provides a mock function with given fields: u, r
-func (_m *Forge) Netrc(u *model.User, r *model.Repo) (*model.Netrc, error) {
-	ret := _m.Called(u, r)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Netrc")
-	}
-
-	var r0 *model.Netrc
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) (*model.Netrc, error)); ok {
-		return rf(u, r)
-	}
-	if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) *model.Netrc); ok {
-		r0 = rf(u, r)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Netrc)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.User, *model.Repo) error); ok {
-		r1 = rf(u, r)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Org provides a mock function with given fields: ctx, u, org
-func (_m *Forge) Org(ctx context.Context, u *model.User, org string) (*model.Org, error) {
-	ret := _m.Called(ctx, u, org)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Org")
-	}
-
-	var r0 *model.Org
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, string) (*model.Org, error)); ok {
-		return rf(ctx, u, org)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, string) *model.Org); ok {
-		r0 = rf(ctx, u, org)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Org)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, string) error); ok {
-		r1 = rf(ctx, u, org)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// OrgMembership provides a mock function with given fields: ctx, u, org
-func (_m *Forge) OrgMembership(ctx context.Context, u *model.User, org string) (*model.OrgPerm, error) {
-	ret := _m.Called(ctx, u, org)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgMembership")
-	}
-
-	var r0 *model.OrgPerm
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, string) (*model.OrgPerm, error)); ok {
-		return rf(ctx, u, org)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, string) *model.OrgPerm); ok {
-		r0 = rf(ctx, u, org)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.OrgPerm)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, string) error); ok {
-		r1 = rf(ctx, u, org)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PullRequests provides a mock function with given fields: ctx, u, r, p
-func (_m *Forge) PullRequests(ctx context.Context, u *model.User, r *model.Repo, p *model.ListOptions) ([]*model.PullRequest, error) {
-	ret := _m.Called(ctx, u, r, p)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PullRequests")
-	}
-
-	var r0 []*model.PullRequest
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.ListOptions) ([]*model.PullRequest, error)); ok {
-		return rf(ctx, u, r, p)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.ListOptions) []*model.PullRequest); ok {
-		r0 = rf(ctx, u, r, p)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.PullRequest)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, *model.Repo, *model.ListOptions) error); ok {
-		r1 = rf(ctx, u, r, p)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Repo provides a mock function with given fields: ctx, u, remoteID, owner, name
-func (_m *Forge) Repo(ctx context.Context, u *model.User, remoteID model.ForgeRemoteID, owner string, name string) (*model.Repo, error) {
-	ret := _m.Called(ctx, u, remoteID, owner, name)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Repo")
-	}
-
-	var r0 *model.Repo
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, model.ForgeRemoteID, string, string) (*model.Repo, error)); ok {
-		return rf(ctx, u, remoteID, owner, name)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, model.ForgeRemoteID, string, string) *model.Repo); ok {
-		r0 = rf(ctx, u, remoteID, owner, name)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Repo)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User, model.ForgeRemoteID, string, string) error); ok {
-		r1 = rf(ctx, u, remoteID, owner, name)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Repos provides a mock function with given fields: ctx, u
-func (_m *Forge) Repos(ctx context.Context, u *model.User) ([]*model.Repo, error) {
-	ret := _m.Called(ctx, u)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Repos")
-	}
-
-	var r0 []*model.Repo
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User) ([]*model.Repo, error)); ok {
-		return rf(ctx, u)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User) []*model.Repo); ok {
-		r0 = rf(ctx, u)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Repo)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User) error); ok {
-		r1 = rf(ctx, u)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Status provides a mock function with given fields: ctx, u, r, b, p
-func (_m *Forge) Status(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, p *model.Workflow) error {
-	ret := _m.Called(ctx, u, r, b, p)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Status")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User, *model.Repo, *model.Pipeline, *model.Workflow) error); ok {
-		r0 = rf(ctx, u, r, b, p)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Teams provides a mock function with given fields: ctx, u
-func (_m *Forge) Teams(ctx context.Context, u *model.User) ([]*model.Team, error) {
-	ret := _m.Called(ctx, u)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Teams")
-	}
-
-	var r0 []*model.Team
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User) ([]*model.Team, error)); ok {
-		return rf(ctx, u)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *model.User) []*model.Team); ok {
-		r0 = rf(ctx, u)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Team)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *model.User) error); ok {
-		r1 = rf(ctx, u)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// URL provides a mock function with no fields
-func (_m *Forge) URL() string {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for URL")
-	}
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// NewForge creates a new instance of Forge. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewForge(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Forge {
-	mock := &Forge{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/forge/mocks/mock_Refresher.go

@@ -0,0 +1,105 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	"context"
+
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockRefresher creates a new instance of MockRefresher. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockRefresher(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockRefresher {
+	mock := &MockRefresher{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockRefresher is an autogenerated mock type for the Refresher type
+type MockRefresher struct {
+	mock.Mock
+}
+
+type MockRefresher_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockRefresher) EXPECT() *MockRefresher_Expecter {
+	return &MockRefresher_Expecter{mock: &_m.Mock}
+}
+
+// Refresh provides a mock function for the type MockRefresher
+func (_mock *MockRefresher) Refresh(context1 context.Context, user *model.User) (bool, error) {
+	ret := _mock.Called(context1, user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Refresh")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *model.User) (bool, error)); ok {
+		return returnFunc(context1, user)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *model.User) bool); ok {
+		r0 = returnFunc(context1, user)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *model.User) error); ok {
+		r1 = returnFunc(context1, user)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockRefresher_Refresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Refresh'
+type MockRefresher_Refresh_Call struct {
+	*mock.Call
+}
+
+// Refresh is a helper method to define mock.On call
+//   - context1 context.Context
+//   - user *model.User
+func (_e *MockRefresher_Expecter) Refresh(context1 interface{}, user interface{}) *MockRefresher_Refresh_Call {
+	return &MockRefresher_Refresh_Call{Call: _e.mock.On("Refresh", context1, user)}
+}
+
+func (_c *MockRefresher_Refresh_Call) Run(run func(context1 context.Context, user *model.User)) *MockRefresher_Refresh_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *model.User
+		if args[1] != nil {
+			arg1 = args[1].(*model.User)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockRefresher_Refresh_Call) Return(b bool, err error) *MockRefresher_Refresh_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *MockRefresher_Refresh_Call) RunAndReturn(run func(context1 context.Context, user *model.User) (bool, error)) *MockRefresher_Refresh_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/grpc/rpc_test.go

@@ -24,12 +24,12 @@ import (
 
 	"go.woodpecker-ci.org/woodpecker/v3/pipeline/rpc"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 )
 
 func TestRegisterAgent(t *testing.T) {
 	t.Run("When existing agent Name is empty it should update Name with hostname from metadata", func(t *testing.T) {
-		store := mocks_store.NewStore(t)
+		store := store_mocks.NewMockStore(t)
 		storeAgent := new(model.Agent)
 		storeAgent.ID = 1337
 		updatedAgent := model.Agent{
@@ -70,7 +70,7 @@ func TestRegisterAgent(t *testing.T) {
 	})
 
 	t.Run("When existing agent hostname is present it should not update the hostname", func(t *testing.T) {
-		store := mocks_store.NewStore(t)
+		store := store_mocks.NewMockStore(t)
 		storeAgent := new(model.Agent)
 		storeAgent.ID = 1337
 		storeAgent.Name = "originalHostname"
@@ -117,7 +117,7 @@ func TestUpdateAgentLastWork(t *testing.T) {
 		agent := model.Agent{
 			LastWork: 0,
 		}
-		store := mocks_store.NewStore(t)
+		store := store_mocks.NewMockStore(t)
 		rpc := RPC{
 			store: store,
 		}
@@ -134,7 +134,7 @@ func TestUpdateAgentLastWork(t *testing.T) {
 		agent := model.Agent{
 			LastWork: lastWork,
 		}
-		store := mocks_store.NewStore(t)
+		store := store_mocks.NewMockStore(t)
 		rpc := RPC{
 			store: store,
 		}

server/pipeline/pipeline_status_test.go

@@ -29,7 +29,7 @@ import (
 )
 
 func mockStorePipeline(t *testing.T) store.Store {
-	s := mocks.NewStore(t)
+	s := mocks.NewMockStore(t)
 	s.On("UpdatePipeline", mock.Anything).Return(nil)
 	return s
 }

server/pipeline/step_status_test.go

@@ -30,7 +30,7 @@ import (
 )
 
 func mockStoreStep(t *testing.T) store.Store {
-	s := mocks.NewStore(t)
+	s := mocks.NewMockStore(t)
 	s.On("StepUpdate", mock.Anything).Return(nil)
 	return s
 }

server/pipeline/stepbuilder/metadata_test.go

@@ -25,7 +25,7 @@ import (
 )
 
 func TestMetadataFromStruct(t *testing.T) {
-	forge := mocks.NewForge(t)
+	forge := mocks.NewMockForge(t)
 	forge.On("Name").Return("gitea")
 	forge.On("URL").Return("https://gitea.com")
 

server/pipeline/stepbuilder/stepBuilder_test.go

@@ -625,7 +625,7 @@ func TestSanitizePath(t *testing.T) {
 }
 
 func getMockForge(t *testing.T) forge.Forge {
-	forge := mocks.NewForge(t)
+	forge := mocks.NewMockForge(t)
 	forge.On("Name").Return("mock")
 	forge.On("URL").Return("https://codeberg.org")
 	return forge

server/queue/mocks/mock_Queue.go

@@ -0,0 +1,694 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	"context"
+
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+	"go.woodpecker-ci.org/woodpecker/v3/server/queue"
+)
+
+// NewMockQueue creates a new instance of MockQueue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockQueue(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockQueue {
+	mock := &MockQueue{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockQueue is an autogenerated mock type for the Queue type
+type MockQueue struct {
+	mock.Mock
+}
+
+type MockQueue_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockQueue) EXPECT() *MockQueue_Expecter {
+	return &MockQueue_Expecter{mock: &_m.Mock}
+}
+
+// Done provides a mock function for the type MockQueue
+func (_mock *MockQueue) Done(c context.Context, id string, exitStatus model.StatusValue) error {
+	ret := _mock.Called(c, id, exitStatus)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Done")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, model.StatusValue) error); ok {
+		r0 = returnFunc(c, id, exitStatus)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
+type MockQueue_Done_Call struct {
+	*mock.Call
+}
+
+// Done is a helper method to define mock.On call
+//   - c context.Context
+//   - id string
+//   - exitStatus model.StatusValue
+func (_e *MockQueue_Expecter) Done(c interface{}, id interface{}, exitStatus interface{}) *MockQueue_Done_Call {
+	return &MockQueue_Done_Call{Call: _e.mock.On("Done", c, id, exitStatus)}
+}
+
+func (_c *MockQueue_Done_Call) Run(run func(c context.Context, id string, exitStatus model.StatusValue)) *MockQueue_Done_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 model.StatusValue
+		if args[2] != nil {
+			arg2 = args[2].(model.StatusValue)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_Done_Call) Return(err error) *MockQueue_Done_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockQueue_Done_Call) RunAndReturn(run func(c context.Context, id string, exitStatus model.StatusValue) error) *MockQueue_Done_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Error provides a mock function for the type MockQueue
+func (_mock *MockQueue) Error(c context.Context, id string, err error) error {
+	ret := _mock.Called(c, id, err)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Error")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, error) error); ok {
+		r0 = returnFunc(c, id, err)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error'
+type MockQueue_Error_Call struct {
+	*mock.Call
+}
+
+// Error is a helper method to define mock.On call
+//   - c context.Context
+//   - id string
+//   - err error
+func (_e *MockQueue_Expecter) Error(c interface{}, id interface{}, err interface{}) *MockQueue_Error_Call {
+	return &MockQueue_Error_Call{Call: _e.mock.On("Error", c, id, err)}
+}
+
+func (_c *MockQueue_Error_Call) Run(run func(c context.Context, id string, err error)) *MockQueue_Error_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 error
+		if args[2] != nil {
+			arg2 = args[2].(error)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_Error_Call) Return(err1 error) *MockQueue_Error_Call {
+	_c.Call.Return(err1)
+	return _c
+}
+
+func (_c *MockQueue_Error_Call) RunAndReturn(run func(c context.Context, id string, err error) error) *MockQueue_Error_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ErrorAtOnce provides a mock function for the type MockQueue
+func (_mock *MockQueue) ErrorAtOnce(c context.Context, ids []string, err error) error {
+	ret := _mock.Called(c, ids, err)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ErrorAtOnce")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, error) error); ok {
+		r0 = returnFunc(c, ids, err)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_ErrorAtOnce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ErrorAtOnce'
+type MockQueue_ErrorAtOnce_Call struct {
+	*mock.Call
+}
+
+// ErrorAtOnce is a helper method to define mock.On call
+//   - c context.Context
+//   - ids []string
+//   - err error
+func (_e *MockQueue_Expecter) ErrorAtOnce(c interface{}, ids interface{}, err interface{}) *MockQueue_ErrorAtOnce_Call {
+	return &MockQueue_ErrorAtOnce_Call{Call: _e.mock.On("ErrorAtOnce", c, ids, err)}
+}
+
+func (_c *MockQueue_ErrorAtOnce_Call) Run(run func(c context.Context, ids []string, err error)) *MockQueue_ErrorAtOnce_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 []string
+		if args[1] != nil {
+			arg1 = args[1].([]string)
+		}
+		var arg2 error
+		if args[2] != nil {
+			arg2 = args[2].(error)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_ErrorAtOnce_Call) Return(err1 error) *MockQueue_ErrorAtOnce_Call {
+	_c.Call.Return(err1)
+	return _c
+}
+
+func (_c *MockQueue_ErrorAtOnce_Call) RunAndReturn(run func(c context.Context, ids []string, err error) error) *MockQueue_ErrorAtOnce_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// EvictAtOnce provides a mock function for the type MockQueue
+func (_mock *MockQueue) EvictAtOnce(c context.Context, ids []string) error {
+	ret := _mock.Called(c, ids)
+
+	if len(ret) == 0 {
+		panic("no return value specified for EvictAtOnce")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []string) error); ok {
+		r0 = returnFunc(c, ids)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_EvictAtOnce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvictAtOnce'
+type MockQueue_EvictAtOnce_Call struct {
+	*mock.Call
+}
+
+// EvictAtOnce is a helper method to define mock.On call
+//   - c context.Context
+//   - ids []string
+func (_e *MockQueue_Expecter) EvictAtOnce(c interface{}, ids interface{}) *MockQueue_EvictAtOnce_Call {
+	return &MockQueue_EvictAtOnce_Call{Call: _e.mock.On("EvictAtOnce", c, ids)}
+}
+
+func (_c *MockQueue_EvictAtOnce_Call) Run(run func(c context.Context, ids []string)) *MockQueue_EvictAtOnce_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 []string
+		if args[1] != nil {
+			arg1 = args[1].([]string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_EvictAtOnce_Call) Return(err error) *MockQueue_EvictAtOnce_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockQueue_EvictAtOnce_Call) RunAndReturn(run func(c context.Context, ids []string) error) *MockQueue_EvictAtOnce_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Extend provides a mock function for the type MockQueue
+func (_mock *MockQueue) Extend(c context.Context, agentID int64, workflowID string) error {
+	ret := _mock.Called(c, agentID, workflowID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Extend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string) error); ok {
+		r0 = returnFunc(c, agentID, workflowID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_Extend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extend'
+type MockQueue_Extend_Call struct {
+	*mock.Call
+}
+
+// Extend is a helper method to define mock.On call
+//   - c context.Context
+//   - agentID int64
+//   - workflowID string
+func (_e *MockQueue_Expecter) Extend(c interface{}, agentID interface{}, workflowID interface{}) *MockQueue_Extend_Call {
+	return &MockQueue_Extend_Call{Call: _e.mock.On("Extend", c, agentID, workflowID)}
+}
+
+func (_c *MockQueue_Extend_Call) Run(run func(c context.Context, agentID int64, workflowID string)) *MockQueue_Extend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 int64
+		if args[1] != nil {
+			arg1 = args[1].(int64)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_Extend_Call) Return(err error) *MockQueue_Extend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockQueue_Extend_Call) RunAndReturn(run func(c context.Context, agentID int64, workflowID string) error) *MockQueue_Extend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Info provides a mock function for the type MockQueue
+func (_mock *MockQueue) Info(c context.Context) queue.InfoT {
+	ret := _mock.Called(c)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Info")
+	}
+
+	var r0 queue.InfoT
+	if returnFunc, ok := ret.Get(0).(func(context.Context) queue.InfoT); ok {
+		r0 = returnFunc(c)
+	} else {
+		r0 = ret.Get(0).(queue.InfoT)
+	}
+	return r0
+}
+
+// MockQueue_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
+type MockQueue_Info_Call struct {
+	*mock.Call
+}
+
+// Info is a helper method to define mock.On call
+//   - c context.Context
+func (_e *MockQueue_Expecter) Info(c interface{}) *MockQueue_Info_Call {
+	return &MockQueue_Info_Call{Call: _e.mock.On("Info", c)}
+}
+
+func (_c *MockQueue_Info_Call) Run(run func(c context.Context)) *MockQueue_Info_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_Info_Call) Return(infoT queue.InfoT) *MockQueue_Info_Call {
+	_c.Call.Return(infoT)
+	return _c
+}
+
+func (_c *MockQueue_Info_Call) RunAndReturn(run func(c context.Context) queue.InfoT) *MockQueue_Info_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// KickAgentWorkers provides a mock function for the type MockQueue
+func (_mock *MockQueue) KickAgentWorkers(agentID int64) {
+	_mock.Called(agentID)
+	return
+}
+
+// MockQueue_KickAgentWorkers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'KickAgentWorkers'
+type MockQueue_KickAgentWorkers_Call struct {
+	*mock.Call
+}
+
+// KickAgentWorkers is a helper method to define mock.On call
+//   - agentID int64
+func (_e *MockQueue_Expecter) KickAgentWorkers(agentID interface{}) *MockQueue_KickAgentWorkers_Call {
+	return &MockQueue_KickAgentWorkers_Call{Call: _e.mock.On("KickAgentWorkers", agentID)}
+}
+
+func (_c *MockQueue_KickAgentWorkers_Call) Run(run func(agentID int64)) *MockQueue_KickAgentWorkers_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_KickAgentWorkers_Call) Return() *MockQueue_KickAgentWorkers_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockQueue_KickAgentWorkers_Call) RunAndReturn(run func(agentID int64)) *MockQueue_KickAgentWorkers_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Pause provides a mock function for the type MockQueue
+func (_mock *MockQueue) Pause() {
+	_mock.Called()
+	return
+}
+
+// MockQueue_Pause_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pause'
+type MockQueue_Pause_Call struct {
+	*mock.Call
+}
+
+// Pause is a helper method to define mock.On call
+func (_e *MockQueue_Expecter) Pause() *MockQueue_Pause_Call {
+	return &MockQueue_Pause_Call{Call: _e.mock.On("Pause")}
+}
+
+func (_c *MockQueue_Pause_Call) Run(run func()) *MockQueue_Pause_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockQueue_Pause_Call) Return() *MockQueue_Pause_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockQueue_Pause_Call) RunAndReturn(run func()) *MockQueue_Pause_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Poll provides a mock function for the type MockQueue
+func (_mock *MockQueue) Poll(c context.Context, agentID int64, f queue.FilterFn) (*model.Task, error) {
+	ret := _mock.Called(c, agentID, f)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Poll")
+	}
+
+	var r0 *model.Task
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, queue.FilterFn) (*model.Task, error)); ok {
+		return returnFunc(c, agentID, f)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, queue.FilterFn) *model.Task); ok {
+		r0 = returnFunc(c, agentID, f)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Task)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, queue.FilterFn) error); ok {
+		r1 = returnFunc(c, agentID, f)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockQueue_Poll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Poll'
+type MockQueue_Poll_Call struct {
+	*mock.Call
+}
+
+// Poll is a helper method to define mock.On call
+//   - c context.Context
+//   - agentID int64
+//   - f queue.FilterFn
+func (_e *MockQueue_Expecter) Poll(c interface{}, agentID interface{}, f interface{}) *MockQueue_Poll_Call {
+	return &MockQueue_Poll_Call{Call: _e.mock.On("Poll", c, agentID, f)}
+}
+
+func (_c *MockQueue_Poll_Call) Run(run func(c context.Context, agentID int64, f queue.FilterFn)) *MockQueue_Poll_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 int64
+		if args[1] != nil {
+			arg1 = args[1].(int64)
+		}
+		var arg2 queue.FilterFn
+		if args[2] != nil {
+			arg2 = args[2].(queue.FilterFn)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_Poll_Call) Return(task *model.Task, err error) *MockQueue_Poll_Call {
+	_c.Call.Return(task, err)
+	return _c
+}
+
+func (_c *MockQueue_Poll_Call) RunAndReturn(run func(c context.Context, agentID int64, f queue.FilterFn) (*model.Task, error)) *MockQueue_Poll_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PushAtOnce provides a mock function for the type MockQueue
+func (_mock *MockQueue) PushAtOnce(c context.Context, tasks []*model.Task) error {
+	ret := _mock.Called(c, tasks)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PushAtOnce")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []*model.Task) error); ok {
+		r0 = returnFunc(c, tasks)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_PushAtOnce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PushAtOnce'
+type MockQueue_PushAtOnce_Call struct {
+	*mock.Call
+}
+
+// PushAtOnce is a helper method to define mock.On call
+//   - c context.Context
+//   - tasks []*model.Task
+func (_e *MockQueue_Expecter) PushAtOnce(c interface{}, tasks interface{}) *MockQueue_PushAtOnce_Call {
+	return &MockQueue_PushAtOnce_Call{Call: _e.mock.On("PushAtOnce", c, tasks)}
+}
+
+func (_c *MockQueue_PushAtOnce_Call) Run(run func(c context.Context, tasks []*model.Task)) *MockQueue_PushAtOnce_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 []*model.Task
+		if args[1] != nil {
+			arg1 = args[1].([]*model.Task)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_PushAtOnce_Call) Return(err error) *MockQueue_PushAtOnce_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockQueue_PushAtOnce_Call) RunAndReturn(run func(c context.Context, tasks []*model.Task) error) *MockQueue_PushAtOnce_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Resume provides a mock function for the type MockQueue
+func (_mock *MockQueue) Resume() {
+	_mock.Called()
+	return
+}
+
+// MockQueue_Resume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resume'
+type MockQueue_Resume_Call struct {
+	*mock.Call
+}
+
+// Resume is a helper method to define mock.On call
+func (_e *MockQueue_Expecter) Resume() *MockQueue_Resume_Call {
+	return &MockQueue_Resume_Call{Call: _e.mock.On("Resume")}
+}
+
+func (_c *MockQueue_Resume_Call) Run(run func()) *MockQueue_Resume_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockQueue_Resume_Call) Return() *MockQueue_Resume_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockQueue_Resume_Call) RunAndReturn(run func()) *MockQueue_Resume_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Wait provides a mock function for the type MockQueue
+func (_mock *MockQueue) Wait(c context.Context, id string) error {
+	ret := _mock.Called(c, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Wait")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
+		r0 = returnFunc(c, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockQueue_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait'
+type MockQueue_Wait_Call struct {
+	*mock.Call
+}
+
+// Wait is a helper method to define mock.On call
+//   - c context.Context
+//   - id string
+func (_e *MockQueue_Expecter) Wait(c interface{}, id interface{}) *MockQueue_Wait_Call {
+	return &MockQueue_Wait_Call{Call: _e.mock.On("Wait", c, id)}
+}
+
+func (_c *MockQueue_Wait_Call) Run(run func(c context.Context, id string)) *MockQueue_Wait_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockQueue_Wait_Call) Return(err error) *MockQueue_Wait_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockQueue_Wait_Call) RunAndReturn(run func(c context.Context, id string) error) *MockQueue_Wait_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/queue/mocks/queue.go

@@ -1,223 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-//go:build test
-// +build test
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-
-	queue "go.woodpecker-ci.org/woodpecker/v3/server/queue"
-)
-
-// Queue is an autogenerated mock type for the Queue type
-type Queue struct {
-	mock.Mock
-}
-
-// Done provides a mock function with given fields: c, id, exitStatus
-func (_m *Queue) Done(c context.Context, id string, exitStatus model.StatusValue) error {
-	ret := _m.Called(c, id, exitStatus)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Done")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, model.StatusValue) error); ok {
-		r0 = rf(c, id, exitStatus)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Error provides a mock function with given fields: c, id, err
-func (_m *Queue) Error(c context.Context, id string, err error) error {
-	ret := _m.Called(c, id, err)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Error")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, error) error); ok {
-		r0 = rf(c, id, err)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ErrorAtOnce provides a mock function with given fields: c, ids, err
-func (_m *Queue) ErrorAtOnce(c context.Context, ids []string, err error) error {
-	ret := _m.Called(c, ids, err)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ErrorAtOnce")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, []string, error) error); ok {
-		r0 = rf(c, ids, err)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// EvictAtOnce provides a mock function with given fields: c, ids
-func (_m *Queue) EvictAtOnce(c context.Context, ids []string) error {
-	ret := _m.Called(c, ids)
-
-	if len(ret) == 0 {
-		panic("no return value specified for EvictAtOnce")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, []string) error); ok {
-		r0 = rf(c, ids)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Extend provides a mock function with given fields: c, agentID, workflowID
-func (_m *Queue) Extend(c context.Context, agentID int64, workflowID string) error {
-	ret := _m.Called(c, agentID, workflowID)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Extend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok {
-		r0 = rf(c, agentID, workflowID)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Info provides a mock function with given fields: c
-func (_m *Queue) Info(c context.Context) queue.InfoT {
-	ret := _m.Called(c)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Info")
-	}
-
-	var r0 queue.InfoT
-	if rf, ok := ret.Get(0).(func(context.Context) queue.InfoT); ok {
-		r0 = rf(c)
-	} else {
-		r0 = ret.Get(0).(queue.InfoT)
-	}
-
-	return r0
-}
-
-// KickAgentWorkers provides a mock function with given fields: agentID
-func (_m *Queue) KickAgentWorkers(agentID int64) {
-	_m.Called(agentID)
-}
-
-// Pause provides a mock function with no fields
-func (_m *Queue) Pause() {
-	_m.Called()
-}
-
-// Poll provides a mock function with given fields: c, agentID, f
-func (_m *Queue) Poll(c context.Context, agentID int64, f queue.FilterFn) (*model.Task, error) {
-	ret := _m.Called(c, agentID, f)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Poll")
-	}
-
-	var r0 *model.Task
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, int64, queue.FilterFn) (*model.Task, error)); ok {
-		return rf(c, agentID, f)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, int64, queue.FilterFn) *model.Task); ok {
-		r0 = rf(c, agentID, f)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Task)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, int64, queue.FilterFn) error); ok {
-		r1 = rf(c, agentID, f)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PushAtOnce provides a mock function with given fields: c, tasks
-func (_m *Queue) PushAtOnce(c context.Context, tasks []*model.Task) error {
-	ret := _m.Called(c, tasks)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PushAtOnce")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, []*model.Task) error); ok {
-		r0 = rf(c, tasks)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Resume provides a mock function with no fields
-func (_m *Queue) Resume() {
-	_m.Called()
-}
-
-// Wait provides a mock function with given fields: c, id
-func (_m *Queue) Wait(c context.Context, id string) error {
-	ret := _m.Called(c, id)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Wait")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
-		r0 = rf(c, id)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// NewQueue creates a new instance of Queue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewQueue(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Queue {
-	mock := &Queue{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/queue/queue.go

@@ -72,8 +72,6 @@ func (t *InfoT) String() string {
 // The int return value represents the matching score (higher is better).
 type FilterFn func(*model.Task) (bool, int)
 
-//go:generate mockery --name Queue --output mocks --case underscore --note "+build test"
-
 // Queue defines a task queue for scheduling tasks among
 // a pool of workers.
 type Queue interface {

server/services/config/combined_test.go

@@ -191,7 +191,7 @@ func TestFetchFromConfigService(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			repo := &model.Repo{Owner: "laszlocph", Name: tt.name, Config: tt.repoConfig} // Using test name as repo name to provide different responses in mock server
 
-			f := new(mocks.Forge)
+			f := new(mocks.MockForge)
 			dirs := map[string][]*forge_types.FileMeta{}
 			for _, file := range tt.files {
 				f.On("File", mock.Anything, mock.Anything, mock.Anything, mock.Anything, file.name).Return(file.data, nil)

server/services/config/forge_test.go

@@ -283,7 +283,7 @@ func TestFetch(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			repo := &model.Repo{Owner: "laszlocph", Name: "multipipeline", Config: tt.repoConfig}
 
-			f := new(mocks.Forge)
+			f := new(mocks.MockForge)
 			dirs := map[string][]*forge_types.FileMeta{}
 			for _, file := range tt.files {
 				f.On("File", mock.Anything, mock.Anything, mock.Anything, mock.Anything, file.name).Once().Return(file.data, nil)

server/services/config/mocks/mock_Service.go

@@ -0,0 +1,139 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	"context"
+
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/forge"
+	"go.woodpecker-ci.org/woodpecker/v3/server/forge/types"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockService {
+	mock := &MockService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockService is an autogenerated mock type for the Service type
+type MockService struct {
+	mock.Mock
+}
+
+type MockService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockService) EXPECT() *MockService_Expecter {
+	return &MockService_Expecter{mock: &_m.Mock}
+}
+
+// Fetch provides a mock function for the type MockService
+func (_mock *MockService) Fetch(ctx context.Context, forge1 forge.Forge, user *model.User, repo *model.Repo, pipeline *model.Pipeline, oldConfigData []*types.FileMeta, restart bool) ([]*types.FileMeta, error) {
+	ret := _mock.Called(ctx, forge1, user, repo, pipeline, oldConfigData, restart)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Fetch")
+	}
+
+	var r0 []*types.FileMeta
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, forge.Forge, *model.User, *model.Repo, *model.Pipeline, []*types.FileMeta, bool) ([]*types.FileMeta, error)); ok {
+		return returnFunc(ctx, forge1, user, repo, pipeline, oldConfigData, restart)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, forge.Forge, *model.User, *model.Repo, *model.Pipeline, []*types.FileMeta, bool) []*types.FileMeta); ok {
+		r0 = returnFunc(ctx, forge1, user, repo, pipeline, oldConfigData, restart)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*types.FileMeta)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, forge.Forge, *model.User, *model.Repo, *model.Pipeline, []*types.FileMeta, bool) error); ok {
+		r1 = returnFunc(ctx, forge1, user, repo, pipeline, oldConfigData, restart)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_Fetch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fetch'
+type MockService_Fetch_Call struct {
+	*mock.Call
+}
+
+// Fetch is a helper method to define mock.On call
+//   - ctx context.Context
+//   - forge1 forge.Forge
+//   - user *model.User
+//   - repo *model.Repo
+//   - pipeline *model.Pipeline
+//   - oldConfigData []*types.FileMeta
+//   - restart bool
+func (_e *MockService_Expecter) Fetch(ctx interface{}, forge1 interface{}, user interface{}, repo interface{}, pipeline interface{}, oldConfigData interface{}, restart interface{}) *MockService_Fetch_Call {
+	return &MockService_Fetch_Call{Call: _e.mock.On("Fetch", ctx, forge1, user, repo, pipeline, oldConfigData, restart)}
+}
+
+func (_c *MockService_Fetch_Call) Run(run func(ctx context.Context, forge1 forge.Forge, user *model.User, repo *model.Repo, pipeline *model.Pipeline, oldConfigData []*types.FileMeta, restart bool)) *MockService_Fetch_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 forge.Forge
+		if args[1] != nil {
+			arg1 = args[1].(forge.Forge)
+		}
+		var arg2 *model.User
+		if args[2] != nil {
+			arg2 = args[2].(*model.User)
+		}
+		var arg3 *model.Repo
+		if args[3] != nil {
+			arg3 = args[3].(*model.Repo)
+		}
+		var arg4 *model.Pipeline
+		if args[4] != nil {
+			arg4 = args[4].(*model.Pipeline)
+		}
+		var arg5 []*types.FileMeta
+		if args[5] != nil {
+			arg5 = args[5].([]*types.FileMeta)
+		}
+		var arg6 bool
+		if args[6] != nil {
+			arg6 = args[6].(bool)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_Fetch_Call) Return(configData []*types.FileMeta, err error) *MockService_Fetch_Call {
+	_c.Call.Return(configData, err)
+	return _c
+}
+
+func (_c *MockService_Fetch_Call) RunAndReturn(run func(ctx context.Context, forge1 forge.Forge, user *model.User, repo *model.Repo, pipeline *model.Pipeline, oldConfigData []*types.FileMeta, restart bool) ([]*types.FileMeta, error)) *MockService_Fetch_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/config/mocks/service.go

@@ -1,63 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	forge "go.woodpecker-ci.org/woodpecker/v3/server/forge"
-
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-
-	types "go.woodpecker-ci.org/woodpecker/v3/server/forge/types"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-// Fetch provides a mock function with given fields: ctx, _a1, user, repo, pipeline, oldConfigData, restart
-func (_m *Service) Fetch(ctx context.Context, _a1 forge.Forge, user *model.User, repo *model.Repo, pipeline *model.Pipeline, oldConfigData []*types.FileMeta, restart bool) ([]*types.FileMeta, error) {
-	ret := _m.Called(ctx, _a1, user, repo, pipeline, oldConfigData, restart)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Fetch")
-	}
-
-	var r0 []*types.FileMeta
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, forge.Forge, *model.User, *model.Repo, *model.Pipeline, []*types.FileMeta, bool) ([]*types.FileMeta, error)); ok {
-		return rf(ctx, _a1, user, repo, pipeline, oldConfigData, restart)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, forge.Forge, *model.User, *model.Repo, *model.Pipeline, []*types.FileMeta, bool) []*types.FileMeta); ok {
-		r0 = rf(ctx, _a1, user, repo, pipeline, oldConfigData, restart)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*types.FileMeta)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, forge.Forge, *model.User, *model.Repo, *model.Pipeline, []*types.FileMeta, bool) error); ok {
-		r1 = rf(ctx, _a1, user, repo, pipeline, oldConfigData, restart)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/services/config/service.go

@@ -22,8 +22,6 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
 )
 
-//go:generate mockery --name Service --output mocks --case underscore
-
 type Service interface {
 	Fetch(ctx context.Context, forge forge.Forge, user *model.User, repo *model.Repo, pipeline *model.Pipeline, oldConfigData []*types.FileMeta, restart bool) (configData []*types.FileMeta, err error)
 }

server/services/environment/mocks/mock_Service.go

@@ -0,0 +1,99 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockService {
+	mock := &MockService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockService is an autogenerated mock type for the Service type
+type MockService struct {
+	mock.Mock
+}
+
+type MockService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockService) EXPECT() *MockService_Expecter {
+	return &MockService_Expecter{mock: &_m.Mock}
+}
+
+// EnvironList provides a mock function for the type MockService
+func (_mock *MockService) EnvironList(repo *model.Repo) ([]*model.Environ, error) {
+	ret := _mock.Called(repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for EnvironList")
+	}
+
+	var r0 []*model.Environ
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) ([]*model.Environ, error)); ok {
+		return returnFunc(repo)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) []*model.Environ); ok {
+		r0 = returnFunc(repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Environ)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo) error); ok {
+		r1 = returnFunc(repo)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_EnvironList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnvironList'
+type MockService_EnvironList_Call struct {
+	*mock.Call
+}
+
+// EnvironList is a helper method to define mock.On call
+//   - repo *model.Repo
+func (_e *MockService_Expecter) EnvironList(repo interface{}) *MockService_EnvironList_Call {
+	return &MockService_EnvironList_Call{Call: _e.mock.On("EnvironList", repo)}
+}
+
+func (_c *MockService_EnvironList_Call) Run(run func(repo *model.Repo)) *MockService_EnvironList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_EnvironList_Call) Return(environs []*model.Environ, err error) *MockService_EnvironList_Call {
+	_c.Call.Return(environs, err)
+	return _c
+}
+
+func (_c *MockService_EnvironList_Call) RunAndReturn(run func(repo *model.Repo) ([]*model.Environ, error)) *MockService_EnvironList_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/environment/mocks/service.go

@@ -1,57 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	mock "github.com/stretchr/testify/mock"
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-// EnvironList provides a mock function with given fields: _a0
-func (_m *Service) EnvironList(_a0 *model.Repo) ([]*model.Environ, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for EnvironList")
-	}
-
-	var r0 []*model.Environ
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo) ([]*model.Environ, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo) []*model.Environ); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Environ)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/services/environment/service.go

@@ -16,8 +16,6 @@ package environment
 
 import "go.woodpecker-ci.org/woodpecker/v3/server/model"
 
-//go:generate mockery --name Service --output mocks --case underscore
-
 // Service defines a service for managing environment variables.
 type Service interface {
 	EnvironList(*model.Repo) ([]*model.Environ, error)

server/services/log/mocks/mock_Service.go

@@ -0,0 +1,207 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockService {
+	mock := &MockService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockService is an autogenerated mock type for the Service type
+type MockService struct {
+	mock.Mock
+}
+
+type MockService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockService) EXPECT() *MockService_Expecter {
+	return &MockService_Expecter{mock: &_m.Mock}
+}
+
+// LogAppend provides a mock function for the type MockService
+func (_mock *MockService) LogAppend(step *model.Step, logEntries []*model.LogEntry) error {
+	ret := _mock.Called(step, logEntries)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogAppend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Step, []*model.LogEntry) error); ok {
+		r0 = returnFunc(step, logEntries)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_LogAppend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LogAppend'
+type MockService_LogAppend_Call struct {
+	*mock.Call
+}
+
+// LogAppend is a helper method to define mock.On call
+//   - step *model.Step
+//   - logEntries []*model.LogEntry
+func (_e *MockService_Expecter) LogAppend(step interface{}, logEntries interface{}) *MockService_LogAppend_Call {
+	return &MockService_LogAppend_Call{Call: _e.mock.On("LogAppend", step, logEntries)}
+}
+
+func (_c *MockService_LogAppend_Call) Run(run func(step *model.Step, logEntries []*model.LogEntry)) *MockService_LogAppend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Step
+		if args[0] != nil {
+			arg0 = args[0].(*model.Step)
+		}
+		var arg1 []*model.LogEntry
+		if args[1] != nil {
+			arg1 = args[1].([]*model.LogEntry)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_LogAppend_Call) Return(err error) *MockService_LogAppend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_LogAppend_Call) RunAndReturn(run func(step *model.Step, logEntries []*model.LogEntry) error) *MockService_LogAppend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// LogDelete provides a mock function for the type MockService
+func (_mock *MockService) LogDelete(step *model.Step) error {
+	ret := _mock.Called(step)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Step) error); ok {
+		r0 = returnFunc(step)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_LogDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LogDelete'
+type MockService_LogDelete_Call struct {
+	*mock.Call
+}
+
+// LogDelete is a helper method to define mock.On call
+//   - step *model.Step
+func (_e *MockService_Expecter) LogDelete(step interface{}) *MockService_LogDelete_Call {
+	return &MockService_LogDelete_Call{Call: _e.mock.On("LogDelete", step)}
+}
+
+func (_c *MockService_LogDelete_Call) Run(run func(step *model.Step)) *MockService_LogDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Step
+		if args[0] != nil {
+			arg0 = args[0].(*model.Step)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_LogDelete_Call) Return(err error) *MockService_LogDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_LogDelete_Call) RunAndReturn(run func(step *model.Step) error) *MockService_LogDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// LogFind provides a mock function for the type MockService
+func (_mock *MockService) LogFind(step *model.Step) ([]*model.LogEntry, error) {
+	ret := _mock.Called(step)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogFind")
+	}
+
+	var r0 []*model.LogEntry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Step) ([]*model.LogEntry, error)); ok {
+		return returnFunc(step)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Step) []*model.LogEntry); ok {
+		r0 = returnFunc(step)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.LogEntry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Step) error); ok {
+		r1 = returnFunc(step)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_LogFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LogFind'
+type MockService_LogFind_Call struct {
+	*mock.Call
+}
+
+// LogFind is a helper method to define mock.On call
+//   - step *model.Step
+func (_e *MockService_Expecter) LogFind(step interface{}) *MockService_LogFind_Call {
+	return &MockService_LogFind_Call{Call: _e.mock.On("LogFind", step)}
+}
+
+func (_c *MockService_LogFind_Call) Run(run func(step *model.Step)) *MockService_LogFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Step
+		if args[0] != nil {
+			arg0 = args[0].(*model.Step)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_LogFind_Call) Return(logEntrys []*model.LogEntry, err error) *MockService_LogFind_Call {
+	_c.Call.Return(logEntrys, err)
+	return _c
+}
+
+func (_c *MockService_LogFind_Call) RunAndReturn(run func(step *model.Step) ([]*model.LogEntry, error)) *MockService_LogFind_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/manager.go

@@ -30,8 +30,6 @@ import (
 	"go.woodpecker-ci.org/woodpecker/v3/server/store"
 )
 
-//go:generate mockery --name Manager --output mocks --case underscore --note "+build test"
-
 const forgeCacheTTL = 10 * time.Minute
 
 type SetupForge func(forge *model.Forge) (forge.Forge, error)

server/services/mocks/manager.go

@@ -1,273 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-//go:build test
-// +build test
-
-package mocks
-
-import (
-	crypto "crypto"
-
-	config "go.woodpecker-ci.org/woodpecker/v3/server/services/config"
-
-	environment "go.woodpecker-ci.org/woodpecker/v3/server/services/environment"
-
-	forge "go.woodpecker-ci.org/woodpecker/v3/server/forge"
-
-	mock "github.com/stretchr/testify/mock"
-
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-
-	registry "go.woodpecker-ci.org/woodpecker/v3/server/services/registry"
-
-	secret "go.woodpecker-ci.org/woodpecker/v3/server/services/secret"
-)
-
-// Manager is an autogenerated mock type for the Manager type
-type Manager struct {
-	mock.Mock
-}
-
-// ConfigServiceFromRepo provides a mock function with given fields: repo
-func (_m *Manager) ConfigServiceFromRepo(repo *model.Repo) config.Service {
-	ret := _m.Called(repo)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ConfigServiceFromRepo")
-	}
-
-	var r0 config.Service
-	if rf, ok := ret.Get(0).(func(*model.Repo) config.Service); ok {
-		r0 = rf(repo)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(config.Service)
-		}
-	}
-
-	return r0
-}
-
-// EnvironmentService provides a mock function with no fields
-func (_m *Manager) EnvironmentService() environment.Service {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for EnvironmentService")
-	}
-
-	var r0 environment.Service
-	if rf, ok := ret.Get(0).(func() environment.Service); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(environment.Service)
-		}
-	}
-
-	return r0
-}
-
-// ForgeByID provides a mock function with given fields: forgeID
-func (_m *Manager) ForgeByID(forgeID int64) (forge.Forge, error) {
-	ret := _m.Called(forgeID)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ForgeByID")
-	}
-
-	var r0 forge.Forge
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int64) (forge.Forge, error)); ok {
-		return rf(forgeID)
-	}
-	if rf, ok := ret.Get(0).(func(int64) forge.Forge); ok {
-		r0 = rf(forgeID)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(forge.Forge)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(int64) error); ok {
-		r1 = rf(forgeID)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ForgeFromRepo provides a mock function with given fields: repo
-func (_m *Manager) ForgeFromRepo(repo *model.Repo) (forge.Forge, error) {
-	ret := _m.Called(repo)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ForgeFromRepo")
-	}
-
-	var r0 forge.Forge
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo) (forge.Forge, error)); ok {
-		return rf(repo)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo) forge.Forge); ok {
-		r0 = rf(repo)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(forge.Forge)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo) error); ok {
-		r1 = rf(repo)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ForgeFromUser provides a mock function with given fields: user
-func (_m *Manager) ForgeFromUser(user *model.User) (forge.Forge, error) {
-	ret := _m.Called(user)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ForgeFromUser")
-	}
-
-	var r0 forge.Forge
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.User) (forge.Forge, error)); ok {
-		return rf(user)
-	}
-	if rf, ok := ret.Get(0).(func(*model.User) forge.Forge); ok {
-		r0 = rf(user)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(forge.Forge)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.User) error); ok {
-		r1 = rf(user)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegistryService provides a mock function with no fields
-func (_m *Manager) RegistryService() registry.Service {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryService")
-	}
-
-	var r0 registry.Service
-	if rf, ok := ret.Get(0).(func() registry.Service); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(registry.Service)
-		}
-	}
-
-	return r0
-}
-
-// RegistryServiceFromRepo provides a mock function with given fields: repo
-func (_m *Manager) RegistryServiceFromRepo(repo *model.Repo) registry.Service {
-	ret := _m.Called(repo)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryServiceFromRepo")
-	}
-
-	var r0 registry.Service
-	if rf, ok := ret.Get(0).(func(*model.Repo) registry.Service); ok {
-		r0 = rf(repo)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(registry.Service)
-		}
-	}
-
-	return r0
-}
-
-// SecretService provides a mock function with no fields
-func (_m *Manager) SecretService() secret.Service {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretService")
-	}
-
-	var r0 secret.Service
-	if rf, ok := ret.Get(0).(func() secret.Service); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(secret.Service)
-		}
-	}
-
-	return r0
-}
-
-// SecretServiceFromRepo provides a mock function with given fields: repo
-func (_m *Manager) SecretServiceFromRepo(repo *model.Repo) secret.Service {
-	ret := _m.Called(repo)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretServiceFromRepo")
-	}
-
-	var r0 secret.Service
-	if rf, ok := ret.Get(0).(func(*model.Repo) secret.Service); ok {
-		r0 = rf(repo)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(secret.Service)
-		}
-	}
-
-	return r0
-}
-
-// SignaturePublicKey provides a mock function with no fields
-func (_m *Manager) SignaturePublicKey() crypto.PublicKey {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for SignaturePublicKey")
-	}
-
-	var r0 crypto.PublicKey
-	if rf, ok := ret.Get(0).(func() crypto.PublicKey); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(crypto.PublicKey)
-		}
-	}
-
-	return r0
-}
-
-// NewManager creates a new instance of Manager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewManager(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Manager {
-	mock := &Manager{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/services/mocks/mock_Manager.go

@@ -0,0 +1,573 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	"crypto"
+
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/forge"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+	"go.woodpecker-ci.org/woodpecker/v3/server/services/config"
+	"go.woodpecker-ci.org/woodpecker/v3/server/services/environment"
+	"go.woodpecker-ci.org/woodpecker/v3/server/services/registry"
+	"go.woodpecker-ci.org/woodpecker/v3/server/services/secret"
+)
+
+// NewMockManager creates a new instance of MockManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockManager(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockManager {
+	mock := &MockManager{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockManager is an autogenerated mock type for the Manager type
+type MockManager struct {
+	mock.Mock
+}
+
+type MockManager_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockManager) EXPECT() *MockManager_Expecter {
+	return &MockManager_Expecter{mock: &_m.Mock}
+}
+
+// ConfigServiceFromRepo provides a mock function for the type MockManager
+func (_mock *MockManager) ConfigServiceFromRepo(repo *model.Repo) config.Service {
+	ret := _mock.Called(repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConfigServiceFromRepo")
+	}
+
+	var r0 config.Service
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) config.Service); ok {
+		r0 = returnFunc(repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(config.Service)
+		}
+	}
+	return r0
+}
+
+// MockManager_ConfigServiceFromRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigServiceFromRepo'
+type MockManager_ConfigServiceFromRepo_Call struct {
+	*mock.Call
+}
+
+// ConfigServiceFromRepo is a helper method to define mock.On call
+//   - repo *model.Repo
+func (_e *MockManager_Expecter) ConfigServiceFromRepo(repo interface{}) *MockManager_ConfigServiceFromRepo_Call {
+	return &MockManager_ConfigServiceFromRepo_Call{Call: _e.mock.On("ConfigServiceFromRepo", repo)}
+}
+
+func (_c *MockManager_ConfigServiceFromRepo_Call) Run(run func(repo *model.Repo)) *MockManager_ConfigServiceFromRepo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockManager_ConfigServiceFromRepo_Call) Return(service config.Service) *MockManager_ConfigServiceFromRepo_Call {
+	_c.Call.Return(service)
+	return _c
+}
+
+func (_c *MockManager_ConfigServiceFromRepo_Call) RunAndReturn(run func(repo *model.Repo) config.Service) *MockManager_ConfigServiceFromRepo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// EnvironmentService provides a mock function for the type MockManager
+func (_mock *MockManager) EnvironmentService() environment.Service {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for EnvironmentService")
+	}
+
+	var r0 environment.Service
+	if returnFunc, ok := ret.Get(0).(func() environment.Service); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(environment.Service)
+		}
+	}
+	return r0
+}
+
+// MockManager_EnvironmentService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnvironmentService'
+type MockManager_EnvironmentService_Call struct {
+	*mock.Call
+}
+
+// EnvironmentService is a helper method to define mock.On call
+func (_e *MockManager_Expecter) EnvironmentService() *MockManager_EnvironmentService_Call {
+	return &MockManager_EnvironmentService_Call{Call: _e.mock.On("EnvironmentService")}
+}
+
+func (_c *MockManager_EnvironmentService_Call) Run(run func()) *MockManager_EnvironmentService_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockManager_EnvironmentService_Call) Return(service environment.Service) *MockManager_EnvironmentService_Call {
+	_c.Call.Return(service)
+	return _c
+}
+
+func (_c *MockManager_EnvironmentService_Call) RunAndReturn(run func() environment.Service) *MockManager_EnvironmentService_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ForgeByID provides a mock function for the type MockManager
+func (_mock *MockManager) ForgeByID(forgeID int64) (forge.Forge, error) {
+	ret := _mock.Called(forgeID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeByID")
+	}
+
+	var r0 forge.Forge
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int64) (forge.Forge, error)); ok {
+		return returnFunc(forgeID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int64) forge.Forge); ok {
+		r0 = returnFunc(forgeID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(forge.Forge)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = returnFunc(forgeID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockManager_ForgeByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForgeByID'
+type MockManager_ForgeByID_Call struct {
+	*mock.Call
+}
+
+// ForgeByID is a helper method to define mock.On call
+//   - forgeID int64
+func (_e *MockManager_Expecter) ForgeByID(forgeID interface{}) *MockManager_ForgeByID_Call {
+	return &MockManager_ForgeByID_Call{Call: _e.mock.On("ForgeByID", forgeID)}
+}
+
+func (_c *MockManager_ForgeByID_Call) Run(run func(forgeID int64)) *MockManager_ForgeByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockManager_ForgeByID_Call) Return(forge1 forge.Forge, err error) *MockManager_ForgeByID_Call {
+	_c.Call.Return(forge1, err)
+	return _c
+}
+
+func (_c *MockManager_ForgeByID_Call) RunAndReturn(run func(forgeID int64) (forge.Forge, error)) *MockManager_ForgeByID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ForgeFromRepo provides a mock function for the type MockManager
+func (_mock *MockManager) ForgeFromRepo(repo *model.Repo) (forge.Forge, error) {
+	ret := _mock.Called(repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeFromRepo")
+	}
+
+	var r0 forge.Forge
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) (forge.Forge, error)); ok {
+		return returnFunc(repo)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) forge.Forge); ok {
+		r0 = returnFunc(repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(forge.Forge)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo) error); ok {
+		r1 = returnFunc(repo)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockManager_ForgeFromRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForgeFromRepo'
+type MockManager_ForgeFromRepo_Call struct {
+	*mock.Call
+}
+
+// ForgeFromRepo is a helper method to define mock.On call
+//   - repo *model.Repo
+func (_e *MockManager_Expecter) ForgeFromRepo(repo interface{}) *MockManager_ForgeFromRepo_Call {
+	return &MockManager_ForgeFromRepo_Call{Call: _e.mock.On("ForgeFromRepo", repo)}
+}
+
+func (_c *MockManager_ForgeFromRepo_Call) Run(run func(repo *model.Repo)) *MockManager_ForgeFromRepo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockManager_ForgeFromRepo_Call) Return(forge1 forge.Forge, err error) *MockManager_ForgeFromRepo_Call {
+	_c.Call.Return(forge1, err)
+	return _c
+}
+
+func (_c *MockManager_ForgeFromRepo_Call) RunAndReturn(run func(repo *model.Repo) (forge.Forge, error)) *MockManager_ForgeFromRepo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ForgeFromUser provides a mock function for the type MockManager
+func (_mock *MockManager) ForgeFromUser(user *model.User) (forge.Forge, error) {
+	ret := _mock.Called(user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeFromUser")
+	}
+
+	var r0 forge.Forge
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.User) (forge.Forge, error)); ok {
+		return returnFunc(user)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.User) forge.Forge); ok {
+		r0 = returnFunc(user)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(forge.Forge)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.User) error); ok {
+		r1 = returnFunc(user)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockManager_ForgeFromUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForgeFromUser'
+type MockManager_ForgeFromUser_Call struct {
+	*mock.Call
+}
+
+// ForgeFromUser is a helper method to define mock.On call
+//   - user *model.User
+func (_e *MockManager_Expecter) ForgeFromUser(user interface{}) *MockManager_ForgeFromUser_Call {
+	return &MockManager_ForgeFromUser_Call{Call: _e.mock.On("ForgeFromUser", user)}
+}
+
+func (_c *MockManager_ForgeFromUser_Call) Run(run func(user *model.User)) *MockManager_ForgeFromUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.User
+		if args[0] != nil {
+			arg0 = args[0].(*model.User)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockManager_ForgeFromUser_Call) Return(forge1 forge.Forge, err error) *MockManager_ForgeFromUser_Call {
+	_c.Call.Return(forge1, err)
+	return _c
+}
+
+func (_c *MockManager_ForgeFromUser_Call) RunAndReturn(run func(user *model.User) (forge.Forge, error)) *MockManager_ForgeFromUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryService provides a mock function for the type MockManager
+func (_mock *MockManager) RegistryService() registry.Service {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryService")
+	}
+
+	var r0 registry.Service
+	if returnFunc, ok := ret.Get(0).(func() registry.Service); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(registry.Service)
+		}
+	}
+	return r0
+}
+
+// MockManager_RegistryService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryService'
+type MockManager_RegistryService_Call struct {
+	*mock.Call
+}
+
+// RegistryService is a helper method to define mock.On call
+func (_e *MockManager_Expecter) RegistryService() *MockManager_RegistryService_Call {
+	return &MockManager_RegistryService_Call{Call: _e.mock.On("RegistryService")}
+}
+
+func (_c *MockManager_RegistryService_Call) Run(run func()) *MockManager_RegistryService_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockManager_RegistryService_Call) Return(service registry.Service) *MockManager_RegistryService_Call {
+	_c.Call.Return(service)
+	return _c
+}
+
+func (_c *MockManager_RegistryService_Call) RunAndReturn(run func() registry.Service) *MockManager_RegistryService_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryServiceFromRepo provides a mock function for the type MockManager
+func (_mock *MockManager) RegistryServiceFromRepo(repo *model.Repo) registry.Service {
+	ret := _mock.Called(repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryServiceFromRepo")
+	}
+
+	var r0 registry.Service
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) registry.Service); ok {
+		r0 = returnFunc(repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(registry.Service)
+		}
+	}
+	return r0
+}
+
+// MockManager_RegistryServiceFromRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryServiceFromRepo'
+type MockManager_RegistryServiceFromRepo_Call struct {
+	*mock.Call
+}
+
+// RegistryServiceFromRepo is a helper method to define mock.On call
+//   - repo *model.Repo
+func (_e *MockManager_Expecter) RegistryServiceFromRepo(repo interface{}) *MockManager_RegistryServiceFromRepo_Call {
+	return &MockManager_RegistryServiceFromRepo_Call{Call: _e.mock.On("RegistryServiceFromRepo", repo)}
+}
+
+func (_c *MockManager_RegistryServiceFromRepo_Call) Run(run func(repo *model.Repo)) *MockManager_RegistryServiceFromRepo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockManager_RegistryServiceFromRepo_Call) Return(service registry.Service) *MockManager_RegistryServiceFromRepo_Call {
+	_c.Call.Return(service)
+	return _c
+}
+
+func (_c *MockManager_RegistryServiceFromRepo_Call) RunAndReturn(run func(repo *model.Repo) registry.Service) *MockManager_RegistryServiceFromRepo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretService provides a mock function for the type MockManager
+func (_mock *MockManager) SecretService() secret.Service {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretService")
+	}
+
+	var r0 secret.Service
+	if returnFunc, ok := ret.Get(0).(func() secret.Service); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(secret.Service)
+		}
+	}
+	return r0
+}
+
+// MockManager_SecretService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretService'
+type MockManager_SecretService_Call struct {
+	*mock.Call
+}
+
+// SecretService is a helper method to define mock.On call
+func (_e *MockManager_Expecter) SecretService() *MockManager_SecretService_Call {
+	return &MockManager_SecretService_Call{Call: _e.mock.On("SecretService")}
+}
+
+func (_c *MockManager_SecretService_Call) Run(run func()) *MockManager_SecretService_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockManager_SecretService_Call) Return(service secret.Service) *MockManager_SecretService_Call {
+	_c.Call.Return(service)
+	return _c
+}
+
+func (_c *MockManager_SecretService_Call) RunAndReturn(run func() secret.Service) *MockManager_SecretService_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretServiceFromRepo provides a mock function for the type MockManager
+func (_mock *MockManager) SecretServiceFromRepo(repo *model.Repo) secret.Service {
+	ret := _mock.Called(repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretServiceFromRepo")
+	}
+
+	var r0 secret.Service
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo) secret.Service); ok {
+		r0 = returnFunc(repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(secret.Service)
+		}
+	}
+	return r0
+}
+
+// MockManager_SecretServiceFromRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretServiceFromRepo'
+type MockManager_SecretServiceFromRepo_Call struct {
+	*mock.Call
+}
+
+// SecretServiceFromRepo is a helper method to define mock.On call
+//   - repo *model.Repo
+func (_e *MockManager_Expecter) SecretServiceFromRepo(repo interface{}) *MockManager_SecretServiceFromRepo_Call {
+	return &MockManager_SecretServiceFromRepo_Call{Call: _e.mock.On("SecretServiceFromRepo", repo)}
+}
+
+func (_c *MockManager_SecretServiceFromRepo_Call) Run(run func(repo *model.Repo)) *MockManager_SecretServiceFromRepo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockManager_SecretServiceFromRepo_Call) Return(service secret.Service) *MockManager_SecretServiceFromRepo_Call {
+	_c.Call.Return(service)
+	return _c
+}
+
+func (_c *MockManager_SecretServiceFromRepo_Call) RunAndReturn(run func(repo *model.Repo) secret.Service) *MockManager_SecretServiceFromRepo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SignaturePublicKey provides a mock function for the type MockManager
+func (_mock *MockManager) SignaturePublicKey() crypto.PublicKey {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for SignaturePublicKey")
+	}
+
+	var r0 crypto.PublicKey
+	if returnFunc, ok := ret.Get(0).(func() crypto.PublicKey); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(crypto.PublicKey)
+		}
+	}
+	return r0
+}
+
+// MockManager_SignaturePublicKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignaturePublicKey'
+type MockManager_SignaturePublicKey_Call struct {
+	*mock.Call
+}
+
+// SignaturePublicKey is a helper method to define mock.On call
+func (_e *MockManager_Expecter) SignaturePublicKey() *MockManager_SignaturePublicKey_Call {
+	return &MockManager_SignaturePublicKey_Call{Call: _e.mock.On("SignaturePublicKey")}
+}
+
+func (_c *MockManager_SignaturePublicKey_Call) Run(run func()) *MockManager_SignaturePublicKey_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockManager_SignaturePublicKey_Call) Return(publicKey crypto.PublicKey) *MockManager_SignaturePublicKey_Call {
+	_c.Call.Return(publicKey)
+	return _c
+}
+
+func (_c *MockManager_SignaturePublicKey_Call) RunAndReturn(run func() crypto.PublicKey) *MockManager_SignaturePublicKey_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/registry/mocks/mock_ReadOnlyService.go

@@ -0,0 +1,161 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockReadOnlyService creates a new instance of MockReadOnlyService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockReadOnlyService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockReadOnlyService {
+	mock := &MockReadOnlyService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockReadOnlyService is an autogenerated mock type for the ReadOnlyService type
+type MockReadOnlyService struct {
+	mock.Mock
+}
+
+type MockReadOnlyService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockReadOnlyService) EXPECT() *MockReadOnlyService_Expecter {
+	return &MockReadOnlyService_Expecter{mock: &_m.Mock}
+}
+
+// GlobalRegistryFind provides a mock function for the type MockReadOnlyService
+func (_mock *MockReadOnlyService) GlobalRegistryFind(s string) (*model.Registry, error) {
+	ret := _mock.Called(s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryFind")
+	}
+
+	var r0 *model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (*model.Registry, error)); ok {
+		return returnFunc(s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) *model.Registry); ok {
+		r0 = returnFunc(s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockReadOnlyService_GlobalRegistryFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryFind'
+type MockReadOnlyService_GlobalRegistryFind_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryFind is a helper method to define mock.On call
+//   - s string
+func (_e *MockReadOnlyService_Expecter) GlobalRegistryFind(s interface{}) *MockReadOnlyService_GlobalRegistryFind_Call {
+	return &MockReadOnlyService_GlobalRegistryFind_Call{Call: _e.mock.On("GlobalRegistryFind", s)}
+}
+
+func (_c *MockReadOnlyService_GlobalRegistryFind_Call) Run(run func(s string)) *MockReadOnlyService_GlobalRegistryFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockReadOnlyService_GlobalRegistryFind_Call) Return(registry *model.Registry, err error) *MockReadOnlyService_GlobalRegistryFind_Call {
+	_c.Call.Return(registry, err)
+	return _c
+}
+
+func (_c *MockReadOnlyService_GlobalRegistryFind_Call) RunAndReturn(run func(s string) (*model.Registry, error)) *MockReadOnlyService_GlobalRegistryFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalRegistryList provides a mock function for the type MockReadOnlyService
+func (_mock *MockReadOnlyService) GlobalRegistryList(listOptions *model.ListOptions) ([]*model.Registry, error) {
+	ret := _mock.Called(listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryList")
+	}
+
+	var r0 []*model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Registry, error)); ok {
+		return returnFunc(listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) []*model.Registry); ok {
+		r0 = returnFunc(listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = returnFunc(listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockReadOnlyService_GlobalRegistryList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryList'
+type MockReadOnlyService_GlobalRegistryList_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryList is a helper method to define mock.On call
+//   - listOptions *model.ListOptions
+func (_e *MockReadOnlyService_Expecter) GlobalRegistryList(listOptions interface{}) *MockReadOnlyService_GlobalRegistryList_Call {
+	return &MockReadOnlyService_GlobalRegistryList_Call{Call: _e.mock.On("GlobalRegistryList", listOptions)}
+}
+
+func (_c *MockReadOnlyService_GlobalRegistryList_Call) Run(run func(listOptions *model.ListOptions)) *MockReadOnlyService_GlobalRegistryList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.ListOptions
+		if args[0] != nil {
+			arg0 = args[0].(*model.ListOptions)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockReadOnlyService_GlobalRegistryList_Call) Return(registrys []*model.Registry, err error) *MockReadOnlyService_GlobalRegistryList_Call {
+	_c.Call.Return(registrys, err)
+	return _c
+}
+
+func (_c *MockReadOnlyService_GlobalRegistryList_Call) RunAndReturn(run func(listOptions *model.ListOptions) ([]*model.Registry, error)) *MockReadOnlyService_GlobalRegistryList_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/registry/mocks/mock_Service.go

@@ -0,0 +1,996 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockService {
+	mock := &MockService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockService is an autogenerated mock type for the Service type
+type MockService struct {
+	mock.Mock
+}
+
+type MockService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockService) EXPECT() *MockService_Expecter {
+	return &MockService_Expecter{mock: &_m.Mock}
+}
+
+// GlobalRegistryCreate provides a mock function for the type MockService
+func (_mock *MockService) GlobalRegistryCreate(registry *model.Registry) error {
+	ret := _mock.Called(registry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryCreate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Registry) error); ok {
+		r0 = returnFunc(registry)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_GlobalRegistryCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryCreate'
+type MockService_GlobalRegistryCreate_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryCreate is a helper method to define mock.On call
+//   - registry *model.Registry
+func (_e *MockService_Expecter) GlobalRegistryCreate(registry interface{}) *MockService_GlobalRegistryCreate_Call {
+	return &MockService_GlobalRegistryCreate_Call{Call: _e.mock.On("GlobalRegistryCreate", registry)}
+}
+
+func (_c *MockService_GlobalRegistryCreate_Call) Run(run func(registry *model.Registry)) *MockService_GlobalRegistryCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Registry
+		if args[0] != nil {
+			arg0 = args[0].(*model.Registry)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryCreate_Call) Return(err error) *MockService_GlobalRegistryCreate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryCreate_Call) RunAndReturn(run func(registry *model.Registry) error) *MockService_GlobalRegistryCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalRegistryDelete provides a mock function for the type MockService
+func (_mock *MockService) GlobalRegistryDelete(s string) error {
+	ret := _mock.Called(s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+		r0 = returnFunc(s)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_GlobalRegistryDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryDelete'
+type MockService_GlobalRegistryDelete_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryDelete is a helper method to define mock.On call
+//   - s string
+func (_e *MockService_Expecter) GlobalRegistryDelete(s interface{}) *MockService_GlobalRegistryDelete_Call {
+	return &MockService_GlobalRegistryDelete_Call{Call: _e.mock.On("GlobalRegistryDelete", s)}
+}
+
+func (_c *MockService_GlobalRegistryDelete_Call) Run(run func(s string)) *MockService_GlobalRegistryDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryDelete_Call) Return(err error) *MockService_GlobalRegistryDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryDelete_Call) RunAndReturn(run func(s string) error) *MockService_GlobalRegistryDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalRegistryFind provides a mock function for the type MockService
+func (_mock *MockService) GlobalRegistryFind(s string) (*model.Registry, error) {
+	ret := _mock.Called(s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryFind")
+	}
+
+	var r0 *model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (*model.Registry, error)); ok {
+		return returnFunc(s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) *model.Registry); ok {
+		r0 = returnFunc(s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_GlobalRegistryFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryFind'
+type MockService_GlobalRegistryFind_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryFind is a helper method to define mock.On call
+//   - s string
+func (_e *MockService_Expecter) GlobalRegistryFind(s interface{}) *MockService_GlobalRegistryFind_Call {
+	return &MockService_GlobalRegistryFind_Call{Call: _e.mock.On("GlobalRegistryFind", s)}
+}
+
+func (_c *MockService_GlobalRegistryFind_Call) Run(run func(s string)) *MockService_GlobalRegistryFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryFind_Call) Return(registry *model.Registry, err error) *MockService_GlobalRegistryFind_Call {
+	_c.Call.Return(registry, err)
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryFind_Call) RunAndReturn(run func(s string) (*model.Registry, error)) *MockService_GlobalRegistryFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalRegistryList provides a mock function for the type MockService
+func (_mock *MockService) GlobalRegistryList(listOptions *model.ListOptions) ([]*model.Registry, error) {
+	ret := _mock.Called(listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryList")
+	}
+
+	var r0 []*model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Registry, error)); ok {
+		return returnFunc(listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) []*model.Registry); ok {
+		r0 = returnFunc(listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = returnFunc(listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_GlobalRegistryList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryList'
+type MockService_GlobalRegistryList_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryList is a helper method to define mock.On call
+//   - listOptions *model.ListOptions
+func (_e *MockService_Expecter) GlobalRegistryList(listOptions interface{}) *MockService_GlobalRegistryList_Call {
+	return &MockService_GlobalRegistryList_Call{Call: _e.mock.On("GlobalRegistryList", listOptions)}
+}
+
+func (_c *MockService_GlobalRegistryList_Call) Run(run func(listOptions *model.ListOptions)) *MockService_GlobalRegistryList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.ListOptions
+		if args[0] != nil {
+			arg0 = args[0].(*model.ListOptions)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryList_Call) Return(registrys []*model.Registry, err error) *MockService_GlobalRegistryList_Call {
+	_c.Call.Return(registrys, err)
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryList_Call) RunAndReturn(run func(listOptions *model.ListOptions) ([]*model.Registry, error)) *MockService_GlobalRegistryList_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalRegistryUpdate provides a mock function for the type MockService
+func (_mock *MockService) GlobalRegistryUpdate(registry *model.Registry) error {
+	ret := _mock.Called(registry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalRegistryUpdate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Registry) error); ok {
+		r0 = returnFunc(registry)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_GlobalRegistryUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalRegistryUpdate'
+type MockService_GlobalRegistryUpdate_Call struct {
+	*mock.Call
+}
+
+// GlobalRegistryUpdate is a helper method to define mock.On call
+//   - registry *model.Registry
+func (_e *MockService_Expecter) GlobalRegistryUpdate(registry interface{}) *MockService_GlobalRegistryUpdate_Call {
+	return &MockService_GlobalRegistryUpdate_Call{Call: _e.mock.On("GlobalRegistryUpdate", registry)}
+}
+
+func (_c *MockService_GlobalRegistryUpdate_Call) Run(run func(registry *model.Registry)) *MockService_GlobalRegistryUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Registry
+		if args[0] != nil {
+			arg0 = args[0].(*model.Registry)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryUpdate_Call) Return(err error) *MockService_GlobalRegistryUpdate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_GlobalRegistryUpdate_Call) RunAndReturn(run func(registry *model.Registry) error) *MockService_GlobalRegistryUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgRegistryCreate provides a mock function for the type MockService
+func (_mock *MockService) OrgRegistryCreate(n int64, registry *model.Registry) error {
+	ret := _mock.Called(n, registry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgRegistryCreate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.Registry) error); ok {
+		r0 = returnFunc(n, registry)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_OrgRegistryCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgRegistryCreate'
+type MockService_OrgRegistryCreate_Call struct {
+	*mock.Call
+}
+
+// OrgRegistryCreate is a helper method to define mock.On call
+//   - n int64
+//   - registry *model.Registry
+func (_e *MockService_Expecter) OrgRegistryCreate(n interface{}, registry interface{}) *MockService_OrgRegistryCreate_Call {
+	return &MockService_OrgRegistryCreate_Call{Call: _e.mock.On("OrgRegistryCreate", n, registry)}
+}
+
+func (_c *MockService_OrgRegistryCreate_Call) Run(run func(n int64, registry *model.Registry)) *MockService_OrgRegistryCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 *model.Registry
+		if args[1] != nil {
+			arg1 = args[1].(*model.Registry)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgRegistryCreate_Call) Return(err error) *MockService_OrgRegistryCreate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_OrgRegistryCreate_Call) RunAndReturn(run func(n int64, registry *model.Registry) error) *MockService_OrgRegistryCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgRegistryDelete provides a mock function for the type MockService
+func (_mock *MockService) OrgRegistryDelete(n int64, s string) error {
+	ret := _mock.Called(n, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgRegistryDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(int64, string) error); ok {
+		r0 = returnFunc(n, s)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_OrgRegistryDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgRegistryDelete'
+type MockService_OrgRegistryDelete_Call struct {
+	*mock.Call
+}
+
+// OrgRegistryDelete is a helper method to define mock.On call
+//   - n int64
+//   - s string
+func (_e *MockService_Expecter) OrgRegistryDelete(n interface{}, s interface{}) *MockService_OrgRegistryDelete_Call {
+	return &MockService_OrgRegistryDelete_Call{Call: _e.mock.On("OrgRegistryDelete", n, s)}
+}
+
+func (_c *MockService_OrgRegistryDelete_Call) Run(run func(n int64, s string)) *MockService_OrgRegistryDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgRegistryDelete_Call) Return(err error) *MockService_OrgRegistryDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_OrgRegistryDelete_Call) RunAndReturn(run func(n int64, s string) error) *MockService_OrgRegistryDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgRegistryFind provides a mock function for the type MockService
+func (_mock *MockService) OrgRegistryFind(n int64, s string) (*model.Registry, error) {
+	ret := _mock.Called(n, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgRegistryFind")
+	}
+
+	var r0 *model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int64, string) (*model.Registry, error)); ok {
+		return returnFunc(n, s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int64, string) *model.Registry); ok {
+		r0 = returnFunc(n, s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(int64, string) error); ok {
+		r1 = returnFunc(n, s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_OrgRegistryFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgRegistryFind'
+type MockService_OrgRegistryFind_Call struct {
+	*mock.Call
+}
+
+// OrgRegistryFind is a helper method to define mock.On call
+//   - n int64
+//   - s string
+func (_e *MockService_Expecter) OrgRegistryFind(n interface{}, s interface{}) *MockService_OrgRegistryFind_Call {
+	return &MockService_OrgRegistryFind_Call{Call: _e.mock.On("OrgRegistryFind", n, s)}
+}
+
+func (_c *MockService_OrgRegistryFind_Call) Run(run func(n int64, s string)) *MockService_OrgRegistryFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgRegistryFind_Call) Return(registry *model.Registry, err error) *MockService_OrgRegistryFind_Call {
+	_c.Call.Return(registry, err)
+	return _c
+}
+
+func (_c *MockService_OrgRegistryFind_Call) RunAndReturn(run func(n int64, s string) (*model.Registry, error)) *MockService_OrgRegistryFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgRegistryList provides a mock function for the type MockService
+func (_mock *MockService) OrgRegistryList(n int64, listOptions *model.ListOptions) ([]*model.Registry, error) {
+	ret := _mock.Called(n, listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgRegistryList")
+	}
+
+	var r0 []*model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Registry, error)); ok {
+		return returnFunc(n, listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Registry); ok {
+		r0 = returnFunc(n, listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
+		r1 = returnFunc(n, listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_OrgRegistryList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgRegistryList'
+type MockService_OrgRegistryList_Call struct {
+	*mock.Call
+}
+
+// OrgRegistryList is a helper method to define mock.On call
+//   - n int64
+//   - listOptions *model.ListOptions
+func (_e *MockService_Expecter) OrgRegistryList(n interface{}, listOptions interface{}) *MockService_OrgRegistryList_Call {
+	return &MockService_OrgRegistryList_Call{Call: _e.mock.On("OrgRegistryList", n, listOptions)}
+}
+
+func (_c *MockService_OrgRegistryList_Call) Run(run func(n int64, listOptions *model.ListOptions)) *MockService_OrgRegistryList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 *model.ListOptions
+		if args[1] != nil {
+			arg1 = args[1].(*model.ListOptions)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgRegistryList_Call) Return(registrys []*model.Registry, err error) *MockService_OrgRegistryList_Call {
+	_c.Call.Return(registrys, err)
+	return _c
+}
+
+func (_c *MockService_OrgRegistryList_Call) RunAndReturn(run func(n int64, listOptions *model.ListOptions) ([]*model.Registry, error)) *MockService_OrgRegistryList_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgRegistryUpdate provides a mock function for the type MockService
+func (_mock *MockService) OrgRegistryUpdate(n int64, registry *model.Registry) error {
+	ret := _mock.Called(n, registry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgRegistryUpdate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.Registry) error); ok {
+		r0 = returnFunc(n, registry)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_OrgRegistryUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgRegistryUpdate'
+type MockService_OrgRegistryUpdate_Call struct {
+	*mock.Call
+}
+
+// OrgRegistryUpdate is a helper method to define mock.On call
+//   - n int64
+//   - registry *model.Registry
+func (_e *MockService_Expecter) OrgRegistryUpdate(n interface{}, registry interface{}) *MockService_OrgRegistryUpdate_Call {
+	return &MockService_OrgRegistryUpdate_Call{Call: _e.mock.On("OrgRegistryUpdate", n, registry)}
+}
+
+func (_c *MockService_OrgRegistryUpdate_Call) Run(run func(n int64, registry *model.Registry)) *MockService_OrgRegistryUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 *model.Registry
+		if args[1] != nil {
+			arg1 = args[1].(*model.Registry)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgRegistryUpdate_Call) Return(err error) *MockService_OrgRegistryUpdate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_OrgRegistryUpdate_Call) RunAndReturn(run func(n int64, registry *model.Registry) error) *MockService_OrgRegistryUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryCreate provides a mock function for the type MockService
+func (_mock *MockService) RegistryCreate(repo *model.Repo, registry *model.Registry) error {
+	ret := _mock.Called(repo, registry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryCreate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Registry) error); ok {
+		r0 = returnFunc(repo, registry)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_RegistryCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryCreate'
+type MockService_RegistryCreate_Call struct {
+	*mock.Call
+}
+
+// RegistryCreate is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - registry *model.Registry
+func (_e *MockService_Expecter) RegistryCreate(repo interface{}, registry interface{}) *MockService_RegistryCreate_Call {
+	return &MockService_RegistryCreate_Call{Call: _e.mock.On("RegistryCreate", repo, registry)}
+}
+
+func (_c *MockService_RegistryCreate_Call) Run(run func(repo *model.Repo, registry *model.Registry)) *MockService_RegistryCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.Registry
+		if args[1] != nil {
+			arg1 = args[1].(*model.Registry)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_RegistryCreate_Call) Return(err error) *MockService_RegistryCreate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_RegistryCreate_Call) RunAndReturn(run func(repo *model.Repo, registry *model.Registry) error) *MockService_RegistryCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryDelete provides a mock function for the type MockService
+func (_mock *MockService) RegistryDelete(repo *model.Repo, s string) error {
+	ret := _mock.Called(repo, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) error); ok {
+		r0 = returnFunc(repo, s)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_RegistryDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryDelete'
+type MockService_RegistryDelete_Call struct {
+	*mock.Call
+}
+
+// RegistryDelete is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - s string
+func (_e *MockService_Expecter) RegistryDelete(repo interface{}, s interface{}) *MockService_RegistryDelete_Call {
+	return &MockService_RegistryDelete_Call{Call: _e.mock.On("RegistryDelete", repo, s)}
+}
+
+func (_c *MockService_RegistryDelete_Call) Run(run func(repo *model.Repo, s string)) *MockService_RegistryDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_RegistryDelete_Call) Return(err error) *MockService_RegistryDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_RegistryDelete_Call) RunAndReturn(run func(repo *model.Repo, s string) error) *MockService_RegistryDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryFind provides a mock function for the type MockService
+func (_mock *MockService) RegistryFind(repo *model.Repo, s string) (*model.Registry, error) {
+	ret := _mock.Called(repo, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryFind")
+	}
+
+	var r0 *model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) (*model.Registry, error)); ok {
+		return returnFunc(repo, s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) *model.Registry); ok {
+		r0 = returnFunc(repo, s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
+		r1 = returnFunc(repo, s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_RegistryFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryFind'
+type MockService_RegistryFind_Call struct {
+	*mock.Call
+}
+
+// RegistryFind is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - s string
+func (_e *MockService_Expecter) RegistryFind(repo interface{}, s interface{}) *MockService_RegistryFind_Call {
+	return &MockService_RegistryFind_Call{Call: _e.mock.On("RegistryFind", repo, s)}
+}
+
+func (_c *MockService_RegistryFind_Call) Run(run func(repo *model.Repo, s string)) *MockService_RegistryFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_RegistryFind_Call) Return(registry *model.Registry, err error) *MockService_RegistryFind_Call {
+	_c.Call.Return(registry, err)
+	return _c
+}
+
+func (_c *MockService_RegistryFind_Call) RunAndReturn(run func(repo *model.Repo, s string) (*model.Registry, error)) *MockService_RegistryFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryList provides a mock function for the type MockService
+func (_mock *MockService) RegistryList(repo *model.Repo, listOptions *model.ListOptions) ([]*model.Registry, error) {
+	ret := _mock.Called(repo, listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryList")
+	}
+
+	var r0 []*model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Registry, error)); ok {
+		return returnFunc(repo, listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Registry); ok {
+		r0 = returnFunc(repo, listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
+		r1 = returnFunc(repo, listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_RegistryList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryList'
+type MockService_RegistryList_Call struct {
+	*mock.Call
+}
+
+// RegistryList is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - listOptions *model.ListOptions
+func (_e *MockService_Expecter) RegistryList(repo interface{}, listOptions interface{}) *MockService_RegistryList_Call {
+	return &MockService_RegistryList_Call{Call: _e.mock.On("RegistryList", repo, listOptions)}
+}
+
+func (_c *MockService_RegistryList_Call) Run(run func(repo *model.Repo, listOptions *model.ListOptions)) *MockService_RegistryList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.ListOptions
+		if args[1] != nil {
+			arg1 = args[1].(*model.ListOptions)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_RegistryList_Call) Return(registrys []*model.Registry, err error) *MockService_RegistryList_Call {
+	_c.Call.Return(registrys, err)
+	return _c
+}
+
+func (_c *MockService_RegistryList_Call) RunAndReturn(run func(repo *model.Repo, listOptions *model.ListOptions) ([]*model.Registry, error)) *MockService_RegistryList_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryListPipeline provides a mock function for the type MockService
+func (_mock *MockService) RegistryListPipeline(repo *model.Repo, pipeline *model.Pipeline) ([]*model.Registry, error) {
+	ret := _mock.Called(repo, pipeline)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryListPipeline")
+	}
+
+	var r0 []*model.Registry
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) ([]*model.Registry, error)); ok {
+		return returnFunc(repo, pipeline)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) []*model.Registry); ok {
+		r0 = returnFunc(repo, pipeline)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo, *model.Pipeline) error); ok {
+		r1 = returnFunc(repo, pipeline)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_RegistryListPipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryListPipeline'
+type MockService_RegistryListPipeline_Call struct {
+	*mock.Call
+}
+
+// RegistryListPipeline is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - pipeline *model.Pipeline
+func (_e *MockService_Expecter) RegistryListPipeline(repo interface{}, pipeline interface{}) *MockService_RegistryListPipeline_Call {
+	return &MockService_RegistryListPipeline_Call{Call: _e.mock.On("RegistryListPipeline", repo, pipeline)}
+}
+
+func (_c *MockService_RegistryListPipeline_Call) Run(run func(repo *model.Repo, pipeline *model.Pipeline)) *MockService_RegistryListPipeline_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.Pipeline
+		if args[1] != nil {
+			arg1 = args[1].(*model.Pipeline)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_RegistryListPipeline_Call) Return(registrys []*model.Registry, err error) *MockService_RegistryListPipeline_Call {
+	_c.Call.Return(registrys, err)
+	return _c
+}
+
+func (_c *MockService_RegistryListPipeline_Call) RunAndReturn(run func(repo *model.Repo, pipeline *model.Pipeline) ([]*model.Registry, error)) *MockService_RegistryListPipeline_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RegistryUpdate provides a mock function for the type MockService
+func (_mock *MockService) RegistryUpdate(repo *model.Repo, registry *model.Registry) error {
+	ret := _mock.Called(repo, registry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryUpdate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Registry) error); ok {
+		r0 = returnFunc(repo, registry)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_RegistryUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryUpdate'
+type MockService_RegistryUpdate_Call struct {
+	*mock.Call
+}
+
+// RegistryUpdate is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - registry *model.Registry
+func (_e *MockService_Expecter) RegistryUpdate(repo interface{}, registry interface{}) *MockService_RegistryUpdate_Call {
+	return &MockService_RegistryUpdate_Call{Call: _e.mock.On("RegistryUpdate", repo, registry)}
+}
+
+func (_c *MockService_RegistryUpdate_Call) Run(run func(repo *model.Repo, registry *model.Registry)) *MockService_RegistryUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.Registry
+		if args[1] != nil {
+			arg1 = args[1].(*model.Registry)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_RegistryUpdate_Call) Return(err error) *MockService_RegistryUpdate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_RegistryUpdate_Call) RunAndReturn(run func(repo *model.Repo, registry *model.Registry) error) *MockService_RegistryUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/registry/mocks/service.go

@@ -1,399 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	mock "github.com/stretchr/testify/mock"
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-// GlobalRegistryCreate provides a mock function with given fields: _a0
-func (_m *Service) GlobalRegistryCreate(_a0 *model.Registry) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalRegistryCreate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GlobalRegistryDelete provides a mock function with given fields: _a0
-func (_m *Service) GlobalRegistryDelete(_a0 string) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalRegistryDelete")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GlobalRegistryFind provides a mock function with given fields: _a0
-func (_m *Service) GlobalRegistryFind(_a0 string) (*model.Registry, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalRegistryFind")
-	}
-
-	var r0 *model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (*model.Registry, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(string) *model.Registry); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GlobalRegistryList provides a mock function with given fields: _a0
-func (_m *Service) GlobalRegistryList(_a0 *model.ListOptions) ([]*model.Registry, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalRegistryList")
-	}
-
-	var r0 []*model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Registry, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Registry); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GlobalRegistryUpdate provides a mock function with given fields: _a0
-func (_m *Service) GlobalRegistryUpdate(_a0 *model.Registry) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalRegistryUpdate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OrgRegistryCreate provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgRegistryCreate(_a0 int64, _a1 *model.Registry) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgRegistryCreate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, *model.Registry) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OrgRegistryDelete provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgRegistryDelete(_a0 int64, _a1 string) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgRegistryDelete")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, string) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OrgRegistryFind provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgRegistryFind(_a0 int64, _a1 string) (*model.Registry, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgRegistryFind")
-	}
-
-	var r0 *model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int64, string) (*model.Registry, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(int64, string) *model.Registry); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// OrgRegistryList provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgRegistryList(_a0 int64, _a1 *model.ListOptions) ([]*model.Registry, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgRegistryList")
-	}
-
-	var r0 []*model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Registry, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Registry); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// OrgRegistryUpdate provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgRegistryUpdate(_a0 int64, _a1 *model.Registry) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgRegistryUpdate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, *model.Registry) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// RegistryCreate provides a mock function with given fields: _a0, _a1
-func (_m *Service) RegistryCreate(_a0 *model.Repo, _a1 *model.Registry) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryCreate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Registry) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// RegistryDelete provides a mock function with given fields: _a0, _a1
-func (_m *Service) RegistryDelete(_a0 *model.Repo, _a1 string) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryDelete")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, string) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// RegistryFind provides a mock function with given fields: _a0, _a1
-func (_m *Service) RegistryFind(_a0 *model.Repo, _a1 string) (*model.Registry, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryFind")
-	}
-
-	var r0 *model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Registry, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Registry); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegistryList provides a mock function with given fields: _a0, _a1
-func (_m *Service) RegistryList(_a0 *model.Repo, _a1 *model.ListOptions) ([]*model.Registry, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryList")
-	}
-
-	var r0 []*model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Registry, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Registry); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegistryListPipeline provides a mock function with given fields: _a0, _a1
-func (_m *Service) RegistryListPipeline(_a0 *model.Repo, _a1 *model.Pipeline) ([]*model.Registry, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryListPipeline")
-	}
-
-	var r0 []*model.Registry
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) ([]*model.Registry, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) []*model.Registry); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Registry)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo, *model.Pipeline) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegistryUpdate provides a mock function with given fields: _a0, _a1
-func (_m *Service) RegistryUpdate(_a0 *model.Repo, _a1 *model.Registry) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RegistryUpdate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Registry) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/services/registry/service.go

@@ -16,8 +16,6 @@ package registry
 
 import "go.woodpecker-ci.org/woodpecker/v3/server/model"
 
-//go:generate mockery --name Service --output mocks --case underscore
-
 // Service defines a service for managing registries.
 type Service interface {
 	RegistryListPipeline(*model.Repo, *model.Pipeline) ([]*model.Registry, error)

server/services/secret/db_test.go

@@ -22,7 +22,7 @@ import (
 
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
 	"go.woodpecker-ci.org/woodpecker/v3/server/services/secret"
-	mocks_store "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
+	store_mocks "go.woodpecker-ci.org/woodpecker/v3/server/store/mocks"
 )
 
 var (
@@ -52,7 +52,7 @@ var (
 )
 
 func TestSecretListPipeline(t *testing.T) {
-	mockStore := mocks_store.NewStore(t)
+	mockStore := store_mocks.NewMockStore(t)
 
 	mockStore.On("SecretList", mock.Anything, mock.Anything, mock.Anything).Once().Return([]*model.Secret{
 		globalSecret,

server/services/secret/mocks/mock_Service.go

@@ -0,0 +1,996 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	"go.woodpecker-ci.org/woodpecker/v3/server/model"
+)
+
+// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockService {
+	mock := &MockService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockService is an autogenerated mock type for the Service type
+type MockService struct {
+	mock.Mock
+}
+
+type MockService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockService) EXPECT() *MockService_Expecter {
+	return &MockService_Expecter{mock: &_m.Mock}
+}
+
+// GlobalSecretCreate provides a mock function for the type MockService
+func (_mock *MockService) GlobalSecretCreate(secret *model.Secret) error {
+	ret := _mock.Called(secret)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalSecretCreate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Secret) error); ok {
+		r0 = returnFunc(secret)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_GlobalSecretCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalSecretCreate'
+type MockService_GlobalSecretCreate_Call struct {
+	*mock.Call
+}
+
+// GlobalSecretCreate is a helper method to define mock.On call
+//   - secret *model.Secret
+func (_e *MockService_Expecter) GlobalSecretCreate(secret interface{}) *MockService_GlobalSecretCreate_Call {
+	return &MockService_GlobalSecretCreate_Call{Call: _e.mock.On("GlobalSecretCreate", secret)}
+}
+
+func (_c *MockService_GlobalSecretCreate_Call) Run(run func(secret *model.Secret)) *MockService_GlobalSecretCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Secret
+		if args[0] != nil {
+			arg0 = args[0].(*model.Secret)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalSecretCreate_Call) Return(err error) *MockService_GlobalSecretCreate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_GlobalSecretCreate_Call) RunAndReturn(run func(secret *model.Secret) error) *MockService_GlobalSecretCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalSecretDelete provides a mock function for the type MockService
+func (_mock *MockService) GlobalSecretDelete(s string) error {
+	ret := _mock.Called(s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalSecretDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+		r0 = returnFunc(s)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_GlobalSecretDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalSecretDelete'
+type MockService_GlobalSecretDelete_Call struct {
+	*mock.Call
+}
+
+// GlobalSecretDelete is a helper method to define mock.On call
+//   - s string
+func (_e *MockService_Expecter) GlobalSecretDelete(s interface{}) *MockService_GlobalSecretDelete_Call {
+	return &MockService_GlobalSecretDelete_Call{Call: _e.mock.On("GlobalSecretDelete", s)}
+}
+
+func (_c *MockService_GlobalSecretDelete_Call) Run(run func(s string)) *MockService_GlobalSecretDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalSecretDelete_Call) Return(err error) *MockService_GlobalSecretDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_GlobalSecretDelete_Call) RunAndReturn(run func(s string) error) *MockService_GlobalSecretDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalSecretFind provides a mock function for the type MockService
+func (_mock *MockService) GlobalSecretFind(s string) (*model.Secret, error) {
+	ret := _mock.Called(s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalSecretFind")
+	}
+
+	var r0 *model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (*model.Secret, error)); ok {
+		return returnFunc(s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) *model.Secret); ok {
+		r0 = returnFunc(s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_GlobalSecretFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalSecretFind'
+type MockService_GlobalSecretFind_Call struct {
+	*mock.Call
+}
+
+// GlobalSecretFind is a helper method to define mock.On call
+//   - s string
+func (_e *MockService_Expecter) GlobalSecretFind(s interface{}) *MockService_GlobalSecretFind_Call {
+	return &MockService_GlobalSecretFind_Call{Call: _e.mock.On("GlobalSecretFind", s)}
+}
+
+func (_c *MockService_GlobalSecretFind_Call) Run(run func(s string)) *MockService_GlobalSecretFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalSecretFind_Call) Return(secret *model.Secret, err error) *MockService_GlobalSecretFind_Call {
+	_c.Call.Return(secret, err)
+	return _c
+}
+
+func (_c *MockService_GlobalSecretFind_Call) RunAndReturn(run func(s string) (*model.Secret, error)) *MockService_GlobalSecretFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalSecretList provides a mock function for the type MockService
+func (_mock *MockService) GlobalSecretList(listOptions *model.ListOptions) ([]*model.Secret, error) {
+	ret := _mock.Called(listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalSecretList")
+	}
+
+	var r0 []*model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Secret, error)); ok {
+		return returnFunc(listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) []*model.Secret); ok {
+		r0 = returnFunc(listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = returnFunc(listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_GlobalSecretList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalSecretList'
+type MockService_GlobalSecretList_Call struct {
+	*mock.Call
+}
+
+// GlobalSecretList is a helper method to define mock.On call
+//   - listOptions *model.ListOptions
+func (_e *MockService_Expecter) GlobalSecretList(listOptions interface{}) *MockService_GlobalSecretList_Call {
+	return &MockService_GlobalSecretList_Call{Call: _e.mock.On("GlobalSecretList", listOptions)}
+}
+
+func (_c *MockService_GlobalSecretList_Call) Run(run func(listOptions *model.ListOptions)) *MockService_GlobalSecretList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.ListOptions
+		if args[0] != nil {
+			arg0 = args[0].(*model.ListOptions)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalSecretList_Call) Return(secrets []*model.Secret, err error) *MockService_GlobalSecretList_Call {
+	_c.Call.Return(secrets, err)
+	return _c
+}
+
+func (_c *MockService_GlobalSecretList_Call) RunAndReturn(run func(listOptions *model.ListOptions) ([]*model.Secret, error)) *MockService_GlobalSecretList_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GlobalSecretUpdate provides a mock function for the type MockService
+func (_mock *MockService) GlobalSecretUpdate(secret *model.Secret) error {
+	ret := _mock.Called(secret)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GlobalSecretUpdate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Secret) error); ok {
+		r0 = returnFunc(secret)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_GlobalSecretUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalSecretUpdate'
+type MockService_GlobalSecretUpdate_Call struct {
+	*mock.Call
+}
+
+// GlobalSecretUpdate is a helper method to define mock.On call
+//   - secret *model.Secret
+func (_e *MockService_Expecter) GlobalSecretUpdate(secret interface{}) *MockService_GlobalSecretUpdate_Call {
+	return &MockService_GlobalSecretUpdate_Call{Call: _e.mock.On("GlobalSecretUpdate", secret)}
+}
+
+func (_c *MockService_GlobalSecretUpdate_Call) Run(run func(secret *model.Secret)) *MockService_GlobalSecretUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Secret
+		if args[0] != nil {
+			arg0 = args[0].(*model.Secret)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_GlobalSecretUpdate_Call) Return(err error) *MockService_GlobalSecretUpdate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_GlobalSecretUpdate_Call) RunAndReturn(run func(secret *model.Secret) error) *MockService_GlobalSecretUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgSecretCreate provides a mock function for the type MockService
+func (_mock *MockService) OrgSecretCreate(n int64, secret *model.Secret) error {
+	ret := _mock.Called(n, secret)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgSecretCreate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.Secret) error); ok {
+		r0 = returnFunc(n, secret)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_OrgSecretCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgSecretCreate'
+type MockService_OrgSecretCreate_Call struct {
+	*mock.Call
+}
+
+// OrgSecretCreate is a helper method to define mock.On call
+//   - n int64
+//   - secret *model.Secret
+func (_e *MockService_Expecter) OrgSecretCreate(n interface{}, secret interface{}) *MockService_OrgSecretCreate_Call {
+	return &MockService_OrgSecretCreate_Call{Call: _e.mock.On("OrgSecretCreate", n, secret)}
+}
+
+func (_c *MockService_OrgSecretCreate_Call) Run(run func(n int64, secret *model.Secret)) *MockService_OrgSecretCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 *model.Secret
+		if args[1] != nil {
+			arg1 = args[1].(*model.Secret)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgSecretCreate_Call) Return(err error) *MockService_OrgSecretCreate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_OrgSecretCreate_Call) RunAndReturn(run func(n int64, secret *model.Secret) error) *MockService_OrgSecretCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgSecretDelete provides a mock function for the type MockService
+func (_mock *MockService) OrgSecretDelete(n int64, s string) error {
+	ret := _mock.Called(n, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgSecretDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(int64, string) error); ok {
+		r0 = returnFunc(n, s)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_OrgSecretDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgSecretDelete'
+type MockService_OrgSecretDelete_Call struct {
+	*mock.Call
+}
+
+// OrgSecretDelete is a helper method to define mock.On call
+//   - n int64
+//   - s string
+func (_e *MockService_Expecter) OrgSecretDelete(n interface{}, s interface{}) *MockService_OrgSecretDelete_Call {
+	return &MockService_OrgSecretDelete_Call{Call: _e.mock.On("OrgSecretDelete", n, s)}
+}
+
+func (_c *MockService_OrgSecretDelete_Call) Run(run func(n int64, s string)) *MockService_OrgSecretDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgSecretDelete_Call) Return(err error) *MockService_OrgSecretDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_OrgSecretDelete_Call) RunAndReturn(run func(n int64, s string) error) *MockService_OrgSecretDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgSecretFind provides a mock function for the type MockService
+func (_mock *MockService) OrgSecretFind(n int64, s string) (*model.Secret, error) {
+	ret := _mock.Called(n, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgSecretFind")
+	}
+
+	var r0 *model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int64, string) (*model.Secret, error)); ok {
+		return returnFunc(n, s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int64, string) *model.Secret); ok {
+		r0 = returnFunc(n, s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(int64, string) error); ok {
+		r1 = returnFunc(n, s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_OrgSecretFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgSecretFind'
+type MockService_OrgSecretFind_Call struct {
+	*mock.Call
+}
+
+// OrgSecretFind is a helper method to define mock.On call
+//   - n int64
+//   - s string
+func (_e *MockService_Expecter) OrgSecretFind(n interface{}, s interface{}) *MockService_OrgSecretFind_Call {
+	return &MockService_OrgSecretFind_Call{Call: _e.mock.On("OrgSecretFind", n, s)}
+}
+
+func (_c *MockService_OrgSecretFind_Call) Run(run func(n int64, s string)) *MockService_OrgSecretFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgSecretFind_Call) Return(secret *model.Secret, err error) *MockService_OrgSecretFind_Call {
+	_c.Call.Return(secret, err)
+	return _c
+}
+
+func (_c *MockService_OrgSecretFind_Call) RunAndReturn(run func(n int64, s string) (*model.Secret, error)) *MockService_OrgSecretFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgSecretList provides a mock function for the type MockService
+func (_mock *MockService) OrgSecretList(n int64, listOptions *model.ListOptions) ([]*model.Secret, error) {
+	ret := _mock.Called(n, listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgSecretList")
+	}
+
+	var r0 []*model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Secret, error)); ok {
+		return returnFunc(n, listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Secret); ok {
+		r0 = returnFunc(n, listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
+		r1 = returnFunc(n, listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_OrgSecretList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgSecretList'
+type MockService_OrgSecretList_Call struct {
+	*mock.Call
+}
+
+// OrgSecretList is a helper method to define mock.On call
+//   - n int64
+//   - listOptions *model.ListOptions
+func (_e *MockService_Expecter) OrgSecretList(n interface{}, listOptions interface{}) *MockService_OrgSecretList_Call {
+	return &MockService_OrgSecretList_Call{Call: _e.mock.On("OrgSecretList", n, listOptions)}
+}
+
+func (_c *MockService_OrgSecretList_Call) Run(run func(n int64, listOptions *model.ListOptions)) *MockService_OrgSecretList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 *model.ListOptions
+		if args[1] != nil {
+			arg1 = args[1].(*model.ListOptions)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgSecretList_Call) Return(secrets []*model.Secret, err error) *MockService_OrgSecretList_Call {
+	_c.Call.Return(secrets, err)
+	return _c
+}
+
+func (_c *MockService_OrgSecretList_Call) RunAndReturn(run func(n int64, listOptions *model.ListOptions) ([]*model.Secret, error)) *MockService_OrgSecretList_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OrgSecretUpdate provides a mock function for the type MockService
+func (_mock *MockService) OrgSecretUpdate(n int64, secret *model.Secret) error {
+	ret := _mock.Called(n, secret)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgSecretUpdate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(int64, *model.Secret) error); ok {
+		r0 = returnFunc(n, secret)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_OrgSecretUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrgSecretUpdate'
+type MockService_OrgSecretUpdate_Call struct {
+	*mock.Call
+}
+
+// OrgSecretUpdate is a helper method to define mock.On call
+//   - n int64
+//   - secret *model.Secret
+func (_e *MockService_Expecter) OrgSecretUpdate(n interface{}, secret interface{}) *MockService_OrgSecretUpdate_Call {
+	return &MockService_OrgSecretUpdate_Call{Call: _e.mock.On("OrgSecretUpdate", n, secret)}
+}
+
+func (_c *MockService_OrgSecretUpdate_Call) Run(run func(n int64, secret *model.Secret)) *MockService_OrgSecretUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 int64
+		if args[0] != nil {
+			arg0 = args[0].(int64)
+		}
+		var arg1 *model.Secret
+		if args[1] != nil {
+			arg1 = args[1].(*model.Secret)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_OrgSecretUpdate_Call) Return(err error) *MockService_OrgSecretUpdate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_OrgSecretUpdate_Call) RunAndReturn(run func(n int64, secret *model.Secret) error) *MockService_OrgSecretUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretCreate provides a mock function for the type MockService
+func (_mock *MockService) SecretCreate(repo *model.Repo, secret *model.Secret) error {
+	ret := _mock.Called(repo, secret)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretCreate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Secret) error); ok {
+		r0 = returnFunc(repo, secret)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_SecretCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretCreate'
+type MockService_SecretCreate_Call struct {
+	*mock.Call
+}
+
+// SecretCreate is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - secret *model.Secret
+func (_e *MockService_Expecter) SecretCreate(repo interface{}, secret interface{}) *MockService_SecretCreate_Call {
+	return &MockService_SecretCreate_Call{Call: _e.mock.On("SecretCreate", repo, secret)}
+}
+
+func (_c *MockService_SecretCreate_Call) Run(run func(repo *model.Repo, secret *model.Secret)) *MockService_SecretCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.Secret
+		if args[1] != nil {
+			arg1 = args[1].(*model.Secret)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_SecretCreate_Call) Return(err error) *MockService_SecretCreate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_SecretCreate_Call) RunAndReturn(run func(repo *model.Repo, secret *model.Secret) error) *MockService_SecretCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretDelete provides a mock function for the type MockService
+func (_mock *MockService) SecretDelete(repo *model.Repo, s string) error {
+	ret := _mock.Called(repo, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretDelete")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) error); ok {
+		r0 = returnFunc(repo, s)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_SecretDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretDelete'
+type MockService_SecretDelete_Call struct {
+	*mock.Call
+}
+
+// SecretDelete is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - s string
+func (_e *MockService_Expecter) SecretDelete(repo interface{}, s interface{}) *MockService_SecretDelete_Call {
+	return &MockService_SecretDelete_Call{Call: _e.mock.On("SecretDelete", repo, s)}
+}
+
+func (_c *MockService_SecretDelete_Call) Run(run func(repo *model.Repo, s string)) *MockService_SecretDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_SecretDelete_Call) Return(err error) *MockService_SecretDelete_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_SecretDelete_Call) RunAndReturn(run func(repo *model.Repo, s string) error) *MockService_SecretDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretFind provides a mock function for the type MockService
+func (_mock *MockService) SecretFind(repo *model.Repo, s string) (*model.Secret, error) {
+	ret := _mock.Called(repo, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretFind")
+	}
+
+	var r0 *model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) (*model.Secret, error)); ok {
+		return returnFunc(repo, s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) *model.Secret); ok {
+		r0 = returnFunc(repo, s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
+		r1 = returnFunc(repo, s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_SecretFind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretFind'
+type MockService_SecretFind_Call struct {
+	*mock.Call
+}
+
+// SecretFind is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - s string
+func (_e *MockService_Expecter) SecretFind(repo interface{}, s interface{}) *MockService_SecretFind_Call {
+	return &MockService_SecretFind_Call{Call: _e.mock.On("SecretFind", repo, s)}
+}
+
+func (_c *MockService_SecretFind_Call) Run(run func(repo *model.Repo, s string)) *MockService_SecretFind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_SecretFind_Call) Return(secret *model.Secret, err error) *MockService_SecretFind_Call {
+	_c.Call.Return(secret, err)
+	return _c
+}
+
+func (_c *MockService_SecretFind_Call) RunAndReturn(run func(repo *model.Repo, s string) (*model.Secret, error)) *MockService_SecretFind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretList provides a mock function for the type MockService
+func (_mock *MockService) SecretList(repo *model.Repo, listOptions *model.ListOptions) ([]*model.Secret, error) {
+	ret := _mock.Called(repo, listOptions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretList")
+	}
+
+	var r0 []*model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Secret, error)); ok {
+		return returnFunc(repo, listOptions)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Secret); ok {
+		r0 = returnFunc(repo, listOptions)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
+		r1 = returnFunc(repo, listOptions)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_SecretList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretList'
+type MockService_SecretList_Call struct {
+	*mock.Call
+}
+
+// SecretList is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - listOptions *model.ListOptions
+func (_e *MockService_Expecter) SecretList(repo interface{}, listOptions interface{}) *MockService_SecretList_Call {
+	return &MockService_SecretList_Call{Call: _e.mock.On("SecretList", repo, listOptions)}
+}
+
+func (_c *MockService_SecretList_Call) Run(run func(repo *model.Repo, listOptions *model.ListOptions)) *MockService_SecretList_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.ListOptions
+		if args[1] != nil {
+			arg1 = args[1].(*model.ListOptions)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_SecretList_Call) Return(secrets []*model.Secret, err error) *MockService_SecretList_Call {
+	_c.Call.Return(secrets, err)
+	return _c
+}
+
+func (_c *MockService_SecretList_Call) RunAndReturn(run func(repo *model.Repo, listOptions *model.ListOptions) ([]*model.Secret, error)) *MockService_SecretList_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretListPipeline provides a mock function for the type MockService
+func (_mock *MockService) SecretListPipeline(repo *model.Repo, pipeline *model.Pipeline) ([]*model.Secret, error) {
+	ret := _mock.Called(repo, pipeline)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretListPipeline")
+	}
+
+	var r0 []*model.Secret
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) ([]*model.Secret, error)); ok {
+		return returnFunc(repo, pipeline)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) []*model.Secret); ok {
+		r0 = returnFunc(repo, pipeline)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Secret)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Repo, *model.Pipeline) error); ok {
+		r1 = returnFunc(repo, pipeline)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockService_SecretListPipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretListPipeline'
+type MockService_SecretListPipeline_Call struct {
+	*mock.Call
+}
+
+// SecretListPipeline is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - pipeline *model.Pipeline
+func (_e *MockService_Expecter) SecretListPipeline(repo interface{}, pipeline interface{}) *MockService_SecretListPipeline_Call {
+	return &MockService_SecretListPipeline_Call{Call: _e.mock.On("SecretListPipeline", repo, pipeline)}
+}
+
+func (_c *MockService_SecretListPipeline_Call) Run(run func(repo *model.Repo, pipeline *model.Pipeline)) *MockService_SecretListPipeline_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.Pipeline
+		if args[1] != nil {
+			arg1 = args[1].(*model.Pipeline)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_SecretListPipeline_Call) Return(secrets []*model.Secret, err error) *MockService_SecretListPipeline_Call {
+	_c.Call.Return(secrets, err)
+	return _c
+}
+
+func (_c *MockService_SecretListPipeline_Call) RunAndReturn(run func(repo *model.Repo, pipeline *model.Pipeline) ([]*model.Secret, error)) *MockService_SecretListPipeline_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SecretUpdate provides a mock function for the type MockService
+func (_mock *MockService) SecretUpdate(repo *model.Repo, secret *model.Secret) error {
+	ret := _mock.Called(repo, secret)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretUpdate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Secret) error); ok {
+		r0 = returnFunc(repo, secret)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockService_SecretUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretUpdate'
+type MockService_SecretUpdate_Call struct {
+	*mock.Call
+}
+
+// SecretUpdate is a helper method to define mock.On call
+//   - repo *model.Repo
+//   - secret *model.Secret
+func (_e *MockService_Expecter) SecretUpdate(repo interface{}, secret interface{}) *MockService_SecretUpdate_Call {
+	return &MockService_SecretUpdate_Call{Call: _e.mock.On("SecretUpdate", repo, secret)}
+}
+
+func (_c *MockService_SecretUpdate_Call) Run(run func(repo *model.Repo, secret *model.Secret)) *MockService_SecretUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 *model.Repo
+		if args[0] != nil {
+			arg0 = args[0].(*model.Repo)
+		}
+		var arg1 *model.Secret
+		if args[1] != nil {
+			arg1 = args[1].(*model.Secret)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockService_SecretUpdate_Call) Return(err error) *MockService_SecretUpdate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockService_SecretUpdate_Call) RunAndReturn(run func(repo *model.Repo, secret *model.Secret) error) *MockService_SecretUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/services/secret/mocks/service.go

@@ -1,399 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	mock "github.com/stretchr/testify/mock"
-	model "go.woodpecker-ci.org/woodpecker/v3/server/model"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-// GlobalSecretCreate provides a mock function with given fields: _a0
-func (_m *Service) GlobalSecretCreate(_a0 *model.Secret) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalSecretCreate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GlobalSecretDelete provides a mock function with given fields: _a0
-func (_m *Service) GlobalSecretDelete(_a0 string) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalSecretDelete")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GlobalSecretFind provides a mock function with given fields: _a0
-func (_m *Service) GlobalSecretFind(_a0 string) (*model.Secret, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalSecretFind")
-	}
-
-	var r0 *model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (*model.Secret, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(string) *model.Secret); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GlobalSecretList provides a mock function with given fields: _a0
-func (_m *Service) GlobalSecretList(_a0 *model.ListOptions) ([]*model.Secret, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalSecretList")
-	}
-
-	var r0 []*model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Secret, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Secret); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GlobalSecretUpdate provides a mock function with given fields: _a0
-func (_m *Service) GlobalSecretUpdate(_a0 *model.Secret) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GlobalSecretUpdate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OrgSecretCreate provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgSecretCreate(_a0 int64, _a1 *model.Secret) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgSecretCreate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, *model.Secret) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OrgSecretDelete provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgSecretDelete(_a0 int64, _a1 string) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgSecretDelete")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, string) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OrgSecretFind provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgSecretFind(_a0 int64, _a1 string) (*model.Secret, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgSecretFind")
-	}
-
-	var r0 *model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int64, string) (*model.Secret, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(int64, string) *model.Secret); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// OrgSecretList provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgSecretList(_a0 int64, _a1 *model.ListOptions) ([]*model.Secret, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgSecretList")
-	}
-
-	var r0 []*model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Secret, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Secret); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// OrgSecretUpdate provides a mock function with given fields: _a0, _a1
-func (_m *Service) OrgSecretUpdate(_a0 int64, _a1 *model.Secret) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OrgSecretUpdate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, *model.Secret) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SecretCreate provides a mock function with given fields: _a0, _a1
-func (_m *Service) SecretCreate(_a0 *model.Repo, _a1 *model.Secret) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretCreate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Secret) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SecretDelete provides a mock function with given fields: _a0, _a1
-func (_m *Service) SecretDelete(_a0 *model.Repo, _a1 string) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretDelete")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, string) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SecretFind provides a mock function with given fields: _a0, _a1
-func (_m *Service) SecretFind(_a0 *model.Repo, _a1 string) (*model.Secret, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretFind")
-	}
-
-	var r0 *model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Secret, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Secret); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SecretList provides a mock function with given fields: _a0, _a1
-func (_m *Service) SecretList(_a0 *model.Repo, _a1 *model.ListOptions) ([]*model.Secret, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretList")
-	}
-
-	var r0 []*model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Secret, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Secret); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SecretListPipeline provides a mock function with given fields: _a0, _a1
-func (_m *Service) SecretListPipeline(_a0 *model.Repo, _a1 *model.Pipeline) ([]*model.Secret, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretListPipeline")
-	}
-
-	var r0 []*model.Secret
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) ([]*model.Secret, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Pipeline) []*model.Secret); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Secret)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Repo, *model.Pipeline) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SecretUpdate provides a mock function with given fields: _a0, _a1
-func (_m *Service) SecretUpdate(_a0 *model.Repo, _a1 *model.Secret) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SecretUpdate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Secret) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

server/services/secret/service.go

@@ -16,8 +16,6 @@ package secret
 
 import "go.woodpecker-ci.org/woodpecker/v3/server/model"
 
-//go:generate mockery --name Service --output mocks --case underscore
-
 // Service defines a service for managing secrets.
 type Service interface {
 	SecretListPipeline(*model.Repo, *model.Pipeline) ([]*model.Secret, error)

server/store/store.go

@@ -14,8 +14,6 @@
 
 package store
 
-//go:generate mockery --name Store --output mocks --case underscore --note "+build test"
-
 import (
 	"context"
 

woodpecker-go/woodpecker/interface.go

@@ -18,8 +18,6 @@ import (
 	"net/http"
 )
 
-//go:generate mockery --name Client --output mocks --case underscore --note "+build test"
-
 // Client is used to communicate with a Woodpecker server.
 type Client interface {
 	// SetClient sets the http.Client.