From e9c545e25b997bd9e8f99d5c18f4ecc1b3f3c301 Mon Sep 17 00:00:00 2001
From: qwerty287 <80460567+qwerty287@users.noreply.github.com>
Date: Wed, 24 Sep 2025 13:41:03 +0200
Subject: [PATCH] Add `StepFinished` to log service (#5530)

---
 pipeline/rpc/proto/woodpecker.pb.go       |    2 +-
 pipeline/rpc/proto/woodpecker_grpc.pb.go  |    2 +-
 server/grpc/rpc.go                        |    4 +
 server/pipeline/step_status.go            |   33 -
 server/pipeline/step_status_test.go       |   83 -
 server/services/log/file/file.go          |    2 +
 server/services/log/mocks/mock_Service.go |   40 +
 server/services/log/service.go            |    1 +
 server/store/datastore/log.go             |    2 +
 server/store/mocks/mock_Store.go          |   40 +
 server/store/mocks/store.go               | 2816 +++++++++++++++++++++
 server/store/store.go                     |    1 +
 12 files changed, 2908 insertions(+), 118 deletions(-)
 create mode 100644 server/store/mocks/store.go

diff --git a/pipeline/rpc/proto/woodpecker.pb.go b/pipeline/rpc/proto/woodpecker.pb.go
index 83e938256..d0563df31 100644
--- a/pipeline/rpc/proto/woodpecker.pb.go
+++ b/pipeline/rpc/proto/woodpecker.pb.go
@@ -16,7 +16,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.36.9
-// 	protoc        v6.31.1
+// 	protoc        v6.32.0
 // source: woodpecker.proto
 
 package proto
diff --git a/pipeline/rpc/proto/woodpecker_grpc.pb.go b/pipeline/rpc/proto/woodpecker_grpc.pb.go
index 4ecfaf474..e332e9fe7 100644
--- a/pipeline/rpc/proto/woodpecker_grpc.pb.go
+++ b/pipeline/rpc/proto/woodpecker_grpc.pb.go
@@ -16,7 +16,7 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.5.1
-// - protoc             v6.31.1
+// - protoc             v6.32.0
 // source: woodpecker.proto
 
 package proto
diff --git a/server/grpc/rpc.go b/server/grpc/rpc.go
index dc576ae1c..c70e3edc2 100644
--- a/server/grpc/rpc.go
+++ b/server/grpc/rpc.go
@@ -188,6 +188,10 @@ func (s *RPC) Update(c context.Context, strWorkflowID string, state rpc.StepStat
 		log.Error().Err(err).Msg("rpc.update: cannot update step")
 	}
 
+	if state.Exited {
+		server.Config.Services.LogStore.StepFinished(step)
+	}
+
 	if currentPipeline.Workflows, err = s.store.WorkflowGetTree(currentPipeline); err != nil {
 		log.Error().Err(err).Msg("cannot build tree from step list")
 		return err
diff --git a/server/pipeline/step_status.go b/server/pipeline/step_status.go
index 364384a05..31ac5b8dd 100644
--- a/server/pipeline/step_status.go
+++ b/server/pipeline/step_status.go
@@ -16,8 +16,6 @@
 package pipeline
 
 import (
-	"time"
-
 	"go.woodpecker-ci.org/woodpecker/v3/pipeline"
 	"go.woodpecker-ci.org/woodpecker/v3/pipeline/rpc"
 	"go.woodpecker-ci.org/woodpecker/v3/server/model"
@@ -43,12 +41,6 @@ func UpdateStepStatus(store store.Store, step *model.Step, state rpc.StepState)
 	return store.StepUpdate(step)
 }
 
-func UpdateStepToStatusStarted(store store.Store, step model.Step, state rpc.StepState) (*model.Step, error) {
-	step.Started = state.Started
-	step.State = model.StatusRunning
-	return &step, store.StepUpdate(&step)
-}
-
 func UpdateStepToStatusSkipped(store store.Store, step model.Step, finished int64) (*model.Step, error) {
 	step.State = model.StatusSkipped
 	if step.Started != 0 {
@@ -57,28 +49,3 @@ func UpdateStepToStatusSkipped(store store.Store, step model.Step, finished int6
 	}
 	return &step, store.StepUpdate(&step)
 }
-
-func UpdateStepStatusToDone(store store.Store, step model.Step, state rpc.StepState) (*model.Step, error) {
-	step.Finished = state.Finished
-	step.Error = state.Error
-	step.ExitCode = state.ExitCode
-	if state.Started == 0 {
-		step.State = model.StatusSkipped
-	} else {
-		step.State = model.StatusSuccess
-	}
-	if step.ExitCode != 0 || step.Error != "" {
-		step.State = model.StatusFailure
-	}
-	return &step, store.StepUpdate(&step)
-}
-
-func UpdateStepToStatusKilled(store store.Store, step model.Step) (*model.Step, error) {
-	step.State = model.StatusKilled
-	step.Finished = time.Now().Unix()
-	if step.Started == 0 {
-		step.Started = step.Finished
-	}
-	step.ExitCode = pipeline.ExitCodeKilled
-	return &step, store.StepUpdate(&step)
-}
diff --git a/server/pipeline/step_status_test.go b/server/pipeline/step_status_test.go
index f049f5adf..0537d892b 100644
--- a/server/pipeline/step_status_test.go
+++ b/server/pipeline/step_status_test.go
@@ -17,7 +17,6 @@ package pipeline
 
 import (
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -149,16 +148,6 @@ func TestUpdateStepStatusExitedWithCode(t *testing.T) {
 	assert.Equal(t, 1, step.ExitCode)
 }
 
-func TestUpdateStepToStatusStarted(t *testing.T) {
-	t.Parallel()
-
-	state := rpc.StepState{Started: int64(42)}
-	step, _ := UpdateStepToStatusStarted(mockStoreStep(t), model.Step{}, state)
-
-	assert.Equal(t, model.StatusRunning, step.State)
-	assert.EqualValues(t, 42, step.Started)
-}
-
 func TestUpdateStepToStatusSkipped(t *testing.T) {
 	t.Parallel()
 
@@ -180,75 +169,3 @@ func TestUpdateStepToStatusSkippedButStarted(t *testing.T) {
 	assert.Equal(t, model.StatusSuccess, step.State)
 	assert.EqualValues(t, 1, step.Finished)
 }
-
-func TestUpdateStepStatusToDoneSkipped(t *testing.T) {
-	t.Parallel()
-
-	state := rpc.StepState{
-		Finished: int64(34),
-	}
-
-	step, _ := UpdateStepStatusToDone(mockStoreStep(t), model.Step{}, state)
-
-	assert.Equal(t, model.StatusSkipped, step.State)
-	assert.EqualValues(t, 34, step.Finished)
-	assert.Empty(t, step.Error)
-	assert.Equal(t, 0, step.ExitCode)
-}
-
-func TestUpdateStepStatusToDoneSuccess(t *testing.T) {
-	t.Parallel()
-
-	state := rpc.StepState{
-		Started:  int64(42),
-		Finished: int64(34),
-	}
-
-	step, _ := UpdateStepStatusToDone(mockStoreStep(t), model.Step{}, state)
-
-	assert.Equal(t, model.StatusSuccess, step.State)
-	assert.EqualValues(t, 34, step.Finished)
-	assert.Empty(t, step.Error)
-	assert.Equal(t, 0, step.ExitCode)
-}
-
-func TestUpdateStepStatusToDoneFailureWithError(t *testing.T) {
-	t.Parallel()
-
-	state := rpc.StepState{Error: "an error"}
-
-	step, _ := UpdateStepStatusToDone(mockStoreStep(t), model.Step{}, state)
-
-	assert.Equal(t, model.StatusFailure, step.State)
-}
-
-func TestUpdateStepStatusToDoneFailureWithExitCode(t *testing.T) {
-	t.Parallel()
-
-	state := rpc.StepState{ExitCode: 43}
-
-	step, _ := UpdateStepStatusToDone(mockStoreStep(t), model.Step{}, state)
-
-	assert.Equal(t, model.StatusFailure, step.State)
-}
-
-func TestUpdateStepToStatusKilledStarted(t *testing.T) {
-	t.Parallel()
-
-	now := time.Now().Unix()
-
-	step, _ := UpdateStepToStatusKilled(mockStoreStep(t), model.Step{})
-
-	assert.Equal(t, model.StatusKilled, step.State)
-	assert.LessOrEqual(t, now, step.Finished)
-	assert.Equal(t, step.Finished, step.Started)
-	assert.Equal(t, 137, step.ExitCode)
-}
-
-func TestUpdateStepToStatusKilledNotStarted(t *testing.T) {
-	t.Parallel()
-
-	step, _ := UpdateStepToStatusKilled(mockStoreStep(t), model.Step{Started: int64(1)})
-
-	assert.EqualValues(t, 1, step.Started)
-}
diff --git a/server/services/log/file/file.go b/server/services/log/file/file.go
index 3bc5b8a2b..c150b4b53 100644
--- a/server/services/log/file/file.go
+++ b/server/services/log/file/file.go
@@ -102,3 +102,5 @@ func (l logStore) LogAppend(step *model.Step, logEntries []*model.LogEntry) erro
 func (l logStore) LogDelete(step *model.Step) error {
 	return os.Remove(l.filePath(step.ID))
 }
+
+func (l logStore) StepFinished(_ *model.Step) {}
diff --git a/server/services/log/mocks/mock_Service.go b/server/services/log/mocks/mock_Service.go
index d5bb6c874..16e4dd056 100644
--- a/server/services/log/mocks/mock_Service.go
+++ b/server/services/log/mocks/mock_Service.go
@@ -205,3 +205,43 @@ func (_c *MockService_LogFind_Call) RunAndReturn(run func(step *model.Step) ([]*
 	_c.Call.Return(run)
 	return _c
 }
+
+// StepFinished provides a mock function for the type MockService
+func (_mock *MockService) StepFinished(step *model.Step) {
+	_mock.Called(step)
+	return
+}
+
+// MockService_StepFinished_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StepFinished'
+type MockService_StepFinished_Call struct {
+	*mock.Call
+}
+
+// StepFinished is a helper method to define mock.On call
+//   - step *model.Step
+func (_e *MockService_Expecter) StepFinished(step interface{}) *MockService_StepFinished_Call {
+	return &MockService_StepFinished_Call{Call: _e.mock.On("StepFinished", step)}
+}
+
+func (_c *MockService_StepFinished_Call) Run(run func(step *model.Step)) *MockService_StepFinished_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_StepFinished_Call) Return() *MockService_StepFinished_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockService_StepFinished_Call) RunAndReturn(run func(step *model.Step)) *MockService_StepFinished_Call {
+	_c.Run(run)
+	return _c
+}
diff --git a/server/services/log/service.go b/server/services/log/service.go
index e922b89ee..c4d98a845 100644
--- a/server/services/log/service.go
+++ b/server/services/log/service.go
@@ -6,4 +6,5 @@ type Service interface {
 	LogFind(step *model.Step) ([]*model.LogEntry, error)
 	LogAppend(step *model.Step, logEntries []*model.LogEntry) error
 	LogDelete(step *model.Step) error
+	StepFinished(step *model.Step)
 }
diff --git a/server/store/datastore/log.go b/server/store/datastore/log.go
index ade01c08c..36cc0829d 100644
--- a/server/store/datastore/log.go
+++ b/server/store/datastore/log.go
@@ -56,3 +56,5 @@ func logDelete(sess *xorm.Session, stepID int64) error {
 	_, err := sess.Where("step_id = ?", stepID).Delete(new(model.LogEntry))
 	return err
 }
+
+func (s storage) StepFinished(_ *model.Step) {}
diff --git a/server/store/mocks/mock_Store.go b/server/store/mocks/mock_Store.go
index 8f0c65163..86beae528 100644
--- a/server/store/mocks/mock_Store.go
+++ b/server/store/mocks/mock_Store.go
@@ -5673,6 +5673,46 @@ func (_c *MockStore_StepFind_Call) RunAndReturn(run func(pipeline *model.Pipelin
 	return _c
 }
 
+// StepFinished provides a mock function for the type MockStore
+func (_mock *MockStore) StepFinished(step *model.Step) {
+	_mock.Called(step)
+	return
+}
+
+// MockStore_StepFinished_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StepFinished'
+type MockStore_StepFinished_Call struct {
+	*mock.Call
+}
+
+// StepFinished is a helper method to define mock.On call
+//   - step *model.Step
+func (_e *MockStore_Expecter) StepFinished(step interface{}) *MockStore_StepFinished_Call {
+	return &MockStore_StepFinished_Call{Call: _e.mock.On("StepFinished", step)}
+}
+
+func (_c *MockStore_StepFinished_Call) Run(run func(step *model.Step)) *MockStore_StepFinished_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 *MockStore_StepFinished_Call) Return() *MockStore_StepFinished_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockStore_StepFinished_Call) RunAndReturn(run func(step *model.Step)) *MockStore_StepFinished_Call {
+	_c.Run(run)
+	return _c
+}
+
 // StepList provides a mock function for the type MockStore
 func (_mock *MockStore) StepList(pipeline *model.Pipeline) ([]*model.Step, error) {
 	ret := _mock.Called(pipeline)
diff --git a/server/store/mocks/store.go b/server/store/mocks/store.go
new file mode 100644
index 000000000..1a9fead5a
--- /dev/null
+++ b/server/store/mocks/store.go
@@ -0,0 +1,2816 @@
+// 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"
+)
+
+// Store is an autogenerated mock type for the Store type
+type Store struct {
+	mock.Mock
+}
+
+// AgentCreate provides a mock function with given fields: _a0
+func (_m *Store) AgentCreate(_a0 *model.Agent) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// AgentDelete provides a mock function with given fields: _a0
+func (_m *Store) AgentDelete(_a0 *model.Agent) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// AgentFind provides a mock function with given fields: _a0
+func (_m *Store) AgentFind(_a0 int64) (*model.Agent, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentFind")
+	}
+
+	var r0 *model.Agent
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Agent, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Agent); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Agent)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AgentFindByToken provides a mock function with given fields: _a0
+func (_m *Store) AgentFindByToken(_a0 string) (*model.Agent, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentFindByToken")
+	}
+
+	var r0 *model.Agent
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Agent, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Agent); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Agent)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AgentList provides a mock function with given fields: p
+func (_m *Store) AgentList(p *model.ListOptions) ([]*model.Agent, error) {
+	ret := _m.Called(p)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentList")
+	}
+
+	var r0 []*model.Agent
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Agent, error)); ok {
+		return rf(p)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Agent); ok {
+		r0 = rf(p)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Agent)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = rf(p)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AgentListForOrg provides a mock function with given fields: orgID, opt
+func (_m *Store) AgentListForOrg(orgID int64, opt *model.ListOptions) ([]*model.Agent, error) {
+	ret := _m.Called(orgID, opt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentListForOrg")
+	}
+
+	var r0 []*model.Agent
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Agent, error)); ok {
+		return rf(orgID, opt)
+	}
+	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Agent); ok {
+		r0 = rf(orgID, opt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Agent)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
+		r1 = rf(orgID, opt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AgentUpdate provides a mock function with given fields: _a0
+func (_m *Store) AgentUpdate(_a0 *model.Agent) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AgentUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Close provides a mock function with no fields
+func (_m *Store) Close() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ConfigPersist provides a mock function with given fields: _a0
+func (_m *Store) ConfigPersist(_a0 *model.Config) (*model.Config, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConfigPersist")
+	}
+
+	var r0 *model.Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Config) (*model.Config, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Config) *model.Config); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Config) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ConfigsForPipeline provides a mock function with given fields: pipelineID
+func (_m *Store) ConfigsForPipeline(pipelineID int64) ([]*model.Config, error) {
+	ret := _m.Called(pipelineID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConfigsForPipeline")
+	}
+
+	var r0 []*model.Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) ([]*model.Config, error)); ok {
+		return rf(pipelineID)
+	}
+	if rf, ok := ret.Get(0).(func(int64) []*model.Config); ok {
+		r0 = rf(pipelineID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(pipelineID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CreatePipeline provides a mock function with given fields: _a0, _a1
+func (_m *Store) CreatePipeline(_a0 *model.Pipeline, _a1 ...*model.Step) error {
+	_va := make([]interface{}, len(_a1))
+	for _i := range _a1 {
+		_va[_i] = _a1[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreatePipeline")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline, ...*model.Step) error); ok {
+		r0 = rf(_a0, _a1...)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// CreateRedirection provides a mock function with given fields: redirection
+func (_m *Store) CreateRedirection(redirection *model.Redirection) error {
+	ret := _m.Called(redirection)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateRedirection")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Redirection) error); ok {
+		r0 = rf(redirection)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// CreateRepo provides a mock function with given fields: _a0
+func (_m *Store) CreateRepo(_a0 *model.Repo) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateRepo")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// CreateUser provides a mock function with given fields: _a0
+func (_m *Store) CreateUser(_a0 *model.User) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.User) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// CronCreate provides a mock function with given fields: _a0
+func (_m *Store) CronCreate(_a0 *model.Cron) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Cron) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// CronDelete provides a mock function with given fields: _a0, _a1
+func (_m *Store) CronDelete(_a0 *model.Repo, _a1 int64) error {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, int64) error); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// CronFind provides a mock function with given fields: _a0, _a1
+func (_m *Store) CronFind(_a0 *model.Repo, _a1 int64) (*model.Cron, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronFind")
+	}
+
+	var r0 *model.Cron
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, int64) (*model.Cron, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, int64) *model.Cron); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Cron)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, int64) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CronGetLock provides a mock function with given fields: _a0, _a1
+func (_m *Store) CronGetLock(_a0 *model.Cron, _a1 int64) (bool, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronGetLock")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Cron, int64) (bool, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Cron, int64) bool); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Cron, int64) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CronList provides a mock function with given fields: _a0, _a1
+func (_m *Store) CronList(_a0 *model.Repo, _a1 *model.ListOptions) ([]*model.Cron, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronList")
+	}
+
+	var r0 []*model.Cron
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Cron, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Cron); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Cron)
+		}
+	}
+
+	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
+}
+
+// CronListNextExecute provides a mock function with given fields: _a0, _a1
+func (_m *Store) CronListNextExecute(_a0 int64, _a1 int64) ([]*model.Cron, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronListNextExecute")
+	}
+
+	var r0 []*model.Cron
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int64) ([]*model.Cron, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int64) []*model.Cron); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Cron)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CronUpdate provides a mock function with given fields: _a0, _a1
+func (_m *Store) CronUpdate(_a0 *model.Repo, _a1 *model.Cron) error {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CronUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Cron) error); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeletePipeline provides a mock function with given fields: _a0
+func (_m *Store) DeletePipeline(_a0 *model.Pipeline) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeletePipeline")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteRepo provides a mock function with given fields: _a0
+func (_m *Store) DeleteRepo(_a0 *model.Repo) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteRepo")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteUser provides a mock function with given fields: _a0
+func (_m *Store) DeleteUser(_a0 *model.User) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.User) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ForgeCreate provides a mock function with given fields: _a0
+func (_m *Store) ForgeCreate(_a0 *model.Forge) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ForgeDelete provides a mock function with given fields: _a0
+func (_m *Store) ForgeDelete(_a0 *model.Forge) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ForgeGet provides a mock function with given fields: _a0
+func (_m *Store) ForgeGet(_a0 int64) (*model.Forge, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeGet")
+	}
+
+	var r0 *model.Forge
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Forge, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Forge); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Forge)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ForgeList provides a mock function with given fields: p
+func (_m *Store) ForgeList(p *model.ListOptions) ([]*model.Forge, error) {
+	ret := _m.Called(p)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeList")
+	}
+
+	var r0 []*model.Forge
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Forge, error)); ok {
+		return rf(p)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Forge); ok {
+		r0 = rf(p)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Forge)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = rf(p)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ForgeUpdate provides a mock function with given fields: _a0
+func (_m *Store) ForgeUpdate(_a0 *model.Forge) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ForgeUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetActivePipelineList provides a mock function with given fields: repo
+func (_m *Store) GetActivePipelineList(repo *model.Repo) ([]*model.Pipeline, error) {
+	ret := _m.Called(repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetActivePipelineList")
+	}
+
+	var r0 []*model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo) ([]*model.Pipeline, error)); ok {
+		return rf(repo)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo) []*model.Pipeline); ok {
+		r0 = rf(repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo) error); ok {
+		r1 = rf(repo)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipeline provides a mock function with given fields: _a0
+func (_m *Store) GetPipeline(_a0 int64) (*model.Pipeline, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipeline")
+	}
+
+	var r0 *model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Pipeline, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Pipeline); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineBadge provides a mock function with given fields: _a0, _a1
+func (_m *Store) GetPipelineBadge(_a0 *model.Repo, _a1 string) (*model.Pipeline, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineBadge")
+	}
+
+	var r0 *model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Pipeline, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Pipeline); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineCount provides a mock function with no fields
+func (_m *Store) GetPipelineCount() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineLast provides a mock function with given fields: _a0, _a1
+func (_m *Store) GetPipelineLast(_a0 *model.Repo, _a1 string) (*model.Pipeline, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineLast")
+	}
+
+	var r0 *model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Pipeline, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Pipeline); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineLastBefore provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Store) GetPipelineLastBefore(_a0 *model.Repo, _a1 string, _a2 int64) (*model.Pipeline, error) {
+	ret := _m.Called(_a0, _a1, _a2)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineLastBefore")
+	}
+
+	var r0 *model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, string, int64) (*model.Pipeline, error)); ok {
+		return rf(_a0, _a1, _a2)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, string, int64) *model.Pipeline); ok {
+		r0 = rf(_a0, _a1, _a2)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, string, int64) error); ok {
+		r1 = rf(_a0, _a1, _a2)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineList provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Store) GetPipelineList(_a0 *model.Repo, _a1 *model.ListOptions, _a2 *model.PipelineFilter) ([]*model.Pipeline, error) {
+	ret := _m.Called(_a0, _a1, _a2)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineList")
+	}
+
+	var r0 []*model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) ([]*model.Pipeline, error)); ok {
+		return rf(_a0, _a1, _a2)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) []*model.Pipeline); ok {
+		r0 = rf(_a0, _a1, _a2)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) error); ok {
+		r1 = rf(_a0, _a1, _a2)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineNumber provides a mock function with given fields: _a0, _a1
+func (_m *Store) GetPipelineNumber(_a0 *model.Repo, _a1 int64) (*model.Pipeline, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineNumber")
+	}
+
+	var r0 *model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Repo, int64) (*model.Pipeline, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, int64) *model.Pipeline); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, int64) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPipelineQueue provides a mock function with no fields
+func (_m *Store) GetPipelineQueue() ([]*model.Feed, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPipelineQueue")
+	}
+
+	var r0 []*model.Feed
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Feed, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Feed); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Feed)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRepo provides a mock function with given fields: _a0
+func (_m *Store) GetRepo(_a0 int64) (*model.Repo, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRepo")
+	}
+
+	var r0 *model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Repo, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Repo); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRepoCount provides a mock function with no fields
+func (_m *Store) GetRepoCount() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRepoCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRepoForgeID provides a mock function with given fields: _a0
+func (_m *Store) GetRepoForgeID(_a0 model.ForgeRemoteID) (*model.Repo, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRepoForgeID")
+	}
+
+	var r0 *model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID) (*model.Repo, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID) *model.Repo); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.ForgeRemoteID) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRepoLatestPipelines provides a mock function with given fields: _a0
+func (_m *Store) GetRepoLatestPipelines(_a0 []int64) ([]*model.Pipeline, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRepoLatestPipelines")
+	}
+
+	var r0 []*model.Pipeline
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]int64) ([]*model.Pipeline, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func([]int64) []*model.Pipeline); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Pipeline)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRepoName provides a mock function with given fields: _a0
+func (_m *Store) GetRepoName(_a0 string) (*model.Repo, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRepoName")
+	}
+
+	var r0 *model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Repo, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Repo); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRepoNameFallback provides a mock function with given fields: remoteID, fullName
+func (_m *Store) GetRepoNameFallback(remoteID model.ForgeRemoteID, fullName string) (*model.Repo, error) {
+	ret := _m.Called(remoteID, fullName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRepoNameFallback")
+	}
+
+	var r0 *model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) (*model.Repo, error)); ok {
+		return rf(remoteID, fullName)
+	}
+	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) *model.Repo); ok {
+		r0 = rf(remoteID, fullName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.ForgeRemoteID, string) error); ok {
+		r1 = rf(remoteID, fullName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUser provides a mock function with given fields: _a0
+func (_m *Store) GetUser(_a0 int64) (*model.User, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUser")
+	}
+
+	var r0 *model.User
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.User, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.User); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUserCount provides a mock function with no fields
+func (_m *Store) GetUserCount() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUserList provides a mock function with given fields: p
+func (_m *Store) GetUserList(p *model.ListOptions) ([]*model.User, error) {
+	ret := _m.Called(p)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserList")
+	}
+
+	var r0 []*model.User
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.User, error)); ok {
+		return rf(p)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.User); ok {
+		r0 = rf(p)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.User)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = rf(p)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUserLogin provides a mock function with given fields: _a0
+func (_m *Store) GetUserLogin(_a0 string) (*model.User, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserLogin")
+	}
+
+	var r0 *model.User
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.User, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUserRemoteID provides a mock function with given fields: _a0, _a1
+func (_m *Store) GetUserRemoteID(_a0 model.ForgeRemoteID, _a1 string) (*model.User, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserRemoteID")
+	}
+
+	var r0 *model.User
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) (*model.User, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) *model.User); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.ForgeRemoteID, string) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GlobalRegistryFind provides a mock function with given fields: _a0
+func (_m *Store) 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 *Store) 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
+}
+
+// GlobalSecretFind provides a mock function with given fields: _a0
+func (_m *Store) 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 *Store) 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
+}
+
+// HasRedirectionForRepo provides a mock function with given fields: _a0, _a1
+func (_m *Store) HasRedirectionForRepo(_a0 int64, _a1 string) (bool, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HasRedirectionForRepo")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, string) (bool, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(int64, string) bool); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// LogAppend provides a mock function with given fields: _a0, _a1
+func (_m *Store) LogAppend(_a0 *model.Step, _a1 []*model.LogEntry) error {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogAppend")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Step, []*model.LogEntry) error); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// LogDelete provides a mock function with given fields: _a0
+func (_m *Store) LogDelete(_a0 *model.Step) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Step) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// LogFind provides a mock function with given fields: _a0
+func (_m *Store) LogFind(_a0 *model.Step) ([]*model.LogEntry, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogFind")
+	}
+
+	var r0 []*model.LogEntry
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Step) ([]*model.LogEntry, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Step) []*model.LogEntry); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.LogEntry)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Step) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Migrate provides a mock function with given fields: _a0, _a1
+func (_m *Store) Migrate(_a0 context.Context, _a1 bool) error {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Migrate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, bool) error); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OrgCreate provides a mock function with given fields: _a0
+func (_m *Store) OrgCreate(_a0 *model.Org) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Org) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OrgDelete provides a mock function with given fields: _a0
+func (_m *Store) OrgDelete(_a0 int64) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OrgFindByName provides a mock function with given fields: _a0, _a1
+func (_m *Store) OrgFindByName(_a0 string, _a1 int64) (*model.Org, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgFindByName")
+	}
+
+	var r0 *model.Org
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) (*model.Org, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) *model.Org); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Org)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OrgGet provides a mock function with given fields: _a0
+func (_m *Store) OrgGet(_a0 int64) (*model.Org, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgGet")
+	}
+
+	var r0 *model.Org
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Org, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Org); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Org)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OrgList provides a mock function with given fields: _a0
+func (_m *Store) OrgList(_a0 *model.ListOptions) ([]*model.Org, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgList")
+	}
+
+	var r0 []*model.Org
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Org, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Org); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Org)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OrgRegistryFind provides a mock function with given fields: _a0, _a1
+func (_m *Store) 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 *Store) 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
+}
+
+// OrgRepoList provides a mock function with given fields: _a0, _a1
+func (_m *Store) OrgRepoList(_a0 *model.Org, _a1 *model.ListOptions) ([]*model.Repo, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgRepoList")
+	}
+
+	var r0 []*model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Org, *model.ListOptions) ([]*model.Repo, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Org, *model.ListOptions) []*model.Repo); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Org, *model.ListOptions) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OrgSecretFind provides a mock function with given fields: _a0, _a1
+func (_m *Store) 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 *Store) 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
+}
+
+// OrgUpdate provides a mock function with given fields: _a0
+func (_m *Store) OrgUpdate(_a0 *model.Org) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OrgUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Org) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermFind provides a mock function with given fields: user, repo
+func (_m *Store) PermFind(user *model.User, repo *model.Repo) (*model.Perm, error) {
+	ret := _m.Called(user, repo)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermFind")
+	}
+
+	var r0 *model.Perm
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) (*model.Perm, error)); ok {
+		return rf(user, repo)
+	}
+	if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) *model.Perm); ok {
+		r0 = rf(user, repo)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Perm)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.User, *model.Repo) error); ok {
+		r1 = rf(user, repo)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermUpsert provides a mock function with given fields: perm
+func (_m *Store) PermUpsert(perm *model.Perm) error {
+	ret := _m.Called(perm)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermUpsert")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Perm) error); ok {
+		r0 = rf(perm)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Ping provides a mock function with no fields
+func (_m *Store) Ping() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Ping")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PipelineConfigCreate provides a mock function with given fields: _a0
+func (_m *Store) PipelineConfigCreate(_a0 *model.PipelineConfig) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PipelineConfigCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.PipelineConfig) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RegistryCreate provides a mock function with given fields: _a0
+func (_m *Store) RegistryCreate(_a0 *model.Registry) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RegistryDelete provides a mock function with given fields: _a0
+func (_m *Store) RegistryDelete(_a0 *model.Registry) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RegistryFind provides a mock function with given fields: _a0, _a1
+func (_m *Store) 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, _a2
+func (_m *Store) RegistryList(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions) ([]*model.Registry, error) {
+	ret := _m.Called(_a0, _a1, _a2)
+
+	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, bool, *model.ListOptions) ([]*model.Registry, error)); ok {
+		return rf(_a0, _a1, _a2)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) []*model.Registry); ok {
+		r0 = rf(_a0, _a1, _a2)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, bool, *model.ListOptions) error); ok {
+		r1 = rf(_a0, _a1, _a2)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RegistryListAll provides a mock function with no fields
+func (_m *Store) RegistryListAll() ([]*model.Registry, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryListAll")
+	}
+
+	var r0 []*model.Registry
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Registry, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Registry); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Registry)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RegistryUpdate provides a mock function with given fields: _a0
+func (_m *Store) RegistryUpdate(_a0 *model.Registry) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RegistryUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RepoList provides a mock function with given fields: user, owned, active
+func (_m *Store) RepoList(user *model.User, owned bool, active bool) ([]*model.Repo, error) {
+	ret := _m.Called(user, owned, active)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RepoList")
+	}
+
+	var r0 []*model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.User, bool, bool) ([]*model.Repo, error)); ok {
+		return rf(user, owned, active)
+	}
+	if rf, ok := ret.Get(0).(func(*model.User, bool, bool) []*model.Repo); ok {
+		r0 = rf(user, owned, active)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.User, bool, bool) error); ok {
+		r1 = rf(user, owned, active)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RepoListAll provides a mock function with given fields: active, p
+func (_m *Store) RepoListAll(active bool, p *model.ListOptions) ([]*model.Repo, error) {
+	ret := _m.Called(active, p)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RepoListAll")
+	}
+
+	var r0 []*model.Repo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(bool, *model.ListOptions) ([]*model.Repo, error)); ok {
+		return rf(active, p)
+	}
+	if rf, ok := ret.Get(0).(func(bool, *model.ListOptions) []*model.Repo); ok {
+		r0 = rf(active, p)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Repo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(bool, *model.ListOptions) error); ok {
+		r1 = rf(active, p)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RepoListLatest provides a mock function with given fields: _a0
+func (_m *Store) RepoListLatest(_a0 *model.User) ([]*model.Feed, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RepoListLatest")
+	}
+
+	var r0 []*model.Feed
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.User) ([]*model.Feed, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.User) []*model.Feed); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Feed)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.User) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SecretCreate provides a mock function with given fields: _a0
+func (_m *Store) SecretCreate(_a0 *model.Secret) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SecretDelete provides a mock function with given fields: _a0
+func (_m *Store) SecretDelete(_a0 *model.Secret) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SecretFind provides a mock function with given fields: _a0, _a1
+func (_m *Store) 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, _a2
+func (_m *Store) SecretList(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions) ([]*model.Secret, error) {
+	ret := _m.Called(_a0, _a1, _a2)
+
+	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, bool, *model.ListOptions) ([]*model.Secret, error)); ok {
+		return rf(_a0, _a1, _a2)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) []*model.Secret); ok {
+		r0 = rf(_a0, _a1, _a2)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Secret)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Repo, bool, *model.ListOptions) error); ok {
+		r1 = rf(_a0, _a1, _a2)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SecretListAll provides a mock function with no fields
+func (_m *Store) SecretListAll() ([]*model.Secret, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretListAll")
+	}
+
+	var r0 []*model.Secret
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Secret, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Secret); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Secret)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SecretUpdate provides a mock function with given fields: _a0
+func (_m *Store) SecretUpdate(_a0 *model.Secret) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SecretUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ServerConfigDelete provides a mock function with given fields: _a0
+func (_m *Store) ServerConfigDelete(_a0 string) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ServerConfigDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ServerConfigGet provides a mock function with given fields: _a0
+func (_m *Store) ServerConfigGet(_a0 string) (string, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ServerConfigGet")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ServerConfigSet provides a mock function with given fields: _a0, _a1
+func (_m *Store) ServerConfigSet(_a0 string, _a1 string) error {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ServerConfigSet")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// StepByUUID provides a mock function with given fields: _a0
+func (_m *Store) StepByUUID(_a0 string) (*model.Step, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepByUUID")
+	}
+
+	var r0 *model.Step
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Step, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Step); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Step)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StepChild provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Store) StepChild(_a0 *model.Pipeline, _a1 int, _a2 string) (*model.Step, error) {
+	ret := _m.Called(_a0, _a1, _a2)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepChild")
+	}
+
+	var r0 *model.Step
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline, int, string) (*model.Step, error)); ok {
+		return rf(_a0, _a1, _a2)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Pipeline, int, string) *model.Step); ok {
+		r0 = rf(_a0, _a1, _a2)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Step)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Pipeline, int, string) error); ok {
+		r1 = rf(_a0, _a1, _a2)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StepFind provides a mock function with given fields: _a0, _a1
+func (_m *Store) StepFind(_a0 *model.Pipeline, _a1 int) (*model.Step, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepFind")
+	}
+
+	var r0 *model.Step
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline, int) (*model.Step, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Pipeline, int) *model.Step); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Step)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Pipeline, int) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StepFinished provides a mock function with given fields: _a0
+func (_m *Store) StepFinished(_a0 *model.Step) {
+	_m.Called(_a0)
+}
+
+// StepList provides a mock function with given fields: _a0
+func (_m *Store) StepList(_a0 *model.Pipeline) ([]*model.Step, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepList")
+	}
+
+	var r0 []*model.Step
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline) ([]*model.Step, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Pipeline) []*model.Step); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Step)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StepListFromWorkflowFind provides a mock function with given fields: _a0
+func (_m *Store) StepListFromWorkflowFind(_a0 *model.Workflow) ([]*model.Step, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepListFromWorkflowFind")
+	}
+
+	var r0 []*model.Step
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Workflow) ([]*model.Step, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Workflow) []*model.Step); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Step)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Workflow) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StepLoad provides a mock function with given fields: _a0
+func (_m *Store) StepLoad(_a0 int64) (*model.Step, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepLoad")
+	}
+
+	var r0 *model.Step
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Step, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Step); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Step)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StepUpdate provides a mock function with given fields: _a0
+func (_m *Store) StepUpdate(_a0 *model.Step) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StepUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Step) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// TaskDelete provides a mock function with given fields: _a0
+func (_m *Store) TaskDelete(_a0 string) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TaskDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// TaskInsert provides a mock function with given fields: _a0
+func (_m *Store) TaskInsert(_a0 *model.Task) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TaskInsert")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Task) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// TaskList provides a mock function with no fields
+func (_m *Store) TaskList() ([]*model.Task, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for TaskList")
+	}
+
+	var r0 []*model.Task
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Task, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Task); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Task)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdatePipeline provides a mock function with given fields: _a0
+func (_m *Store) UpdatePipeline(_a0 *model.Pipeline) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdatePipeline")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateRepo provides a mock function with given fields: _a0
+func (_m *Store) UpdateRepo(_a0 *model.Repo) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRepo")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateUser provides a mock function with given fields: _a0
+func (_m *Store) UpdateUser(_a0 *model.User) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.User) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UserFeed provides a mock function with given fields: _a0
+func (_m *Store) UserFeed(_a0 *model.User) ([]*model.Feed, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UserFeed")
+	}
+
+	var r0 []*model.Feed
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.User) ([]*model.Feed, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.User) []*model.Feed); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Feed)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.User) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// WorkflowGetTree provides a mock function with given fields: _a0
+func (_m *Store) WorkflowGetTree(_a0 *model.Pipeline) ([]*model.Workflow, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WorkflowGetTree")
+	}
+
+	var r0 []*model.Workflow
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline) ([]*model.Workflow, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Pipeline) []*model.Workflow); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Workflow)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// WorkflowLoad provides a mock function with given fields: _a0
+func (_m *Store) WorkflowLoad(_a0 int64) (*model.Workflow, error) {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WorkflowLoad")
+	}
+
+	var r0 *model.Workflow
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (*model.Workflow, error)); ok {
+		return rf(_a0)
+	}
+	if rf, ok := ret.Get(0).(func(int64) *model.Workflow); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Workflow)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// WorkflowUpdate provides a mock function with given fields: _a0
+func (_m *Store) WorkflowUpdate(_a0 *model.Workflow) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WorkflowUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Workflow) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// WorkflowsCreate provides a mock function with given fields: _a0
+func (_m *Store) WorkflowsCreate(_a0 []*model.Workflow) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WorkflowsCreate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]*model.Workflow) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// WorkflowsReplace provides a mock function with given fields: _a0, _a1
+func (_m *Store) WorkflowsReplace(_a0 *model.Pipeline, _a1 []*model.Workflow) error {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WorkflowsReplace")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Pipeline, []*model.Workflow) error); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewStore creates a new instance of Store. 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 NewStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Store {
+	mock := &Store{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/server/store/store.go b/server/store/store.go
index b848b4bf6..e12b85a05 100644
--- a/server/store/store.go
+++ b/server/store/store.go
@@ -147,6 +147,7 @@ type Store interface {
 	LogFind(*model.Step) ([]*model.LogEntry, error)
 	LogAppend(*model.Step, []*model.LogEntry) error
 	LogDelete(*model.Step) error
+	StepFinished(*model.Step)
 
 	// Tasks
 	// TaskList TODO: paginate & opt filter