From 5d7a549620d5b262b30d3fce0b126a11d14a06a3 Mon Sep 17 00:00:00 2001 From: Chenyu Zhang Date: Mon, 22 Aug 2022 14:21:13 +0800 Subject: [PATCH] upgrade: bump up mockery to v2.14.0 (#17415) Signed-off-by: chlins --- Makefile | 2 +- .../replication/flow/mock_adapter_factory_test.go | 6 +++--- src/controller/replication/flow/mock_adapter_test.go | 6 +++--- src/controller/replication/mock_flow_controller_test.go | 6 +++--- src/jobservice/mgt/mock_manager.go | 6 +++--- src/jobservice/period/mock_scheduler.go | 6 +++--- src/pkg/scheduler/mock_dao_test.go | 6 +++--- src/pkg/task/mock_execution_dao_test.go | 6 +++--- src/pkg/task/mock_jobservice_client_test.go | 6 +++--- src/pkg/task/mock_task_dao_test.go | 6 +++--- src/pkg/task/mock_task_manager_test.go | 6 +++--- src/testing/common/security/context.go | 6 +++--- src/testing/controller/artifact/controller.go | 6 +++--- src/testing/controller/blob/controller.go | 6 +++--- src/testing/controller/config/controller.go | 6 +++--- src/testing/controller/jobservice/scheduler_controller.go | 6 +++--- src/testing/controller/project/controller.go | 6 +++--- src/testing/controller/proxy/remote_interface.go | 6 +++--- src/testing/controller/purge/controller.go | 6 +++--- src/testing/controller/quota/controller.go | 6 +++--- src/testing/controller/replication/controller.go | 6 +++--- src/testing/controller/repository/controller.go | 6 +++--- src/testing/controller/retention/controller.go | 6 +++--- src/testing/controller/robot/controller.go | 6 +++--- src/testing/controller/scan/checker.go | 6 +++--- src/testing/controller/scan/controller.go | 6 +++--- src/testing/controller/scandataexport/controller.go | 6 +++--- src/testing/controller/scanner/controller.go | 6 +++--- src/testing/controller/systemartifact/controller.go | 6 +++--- src/testing/controller/user/controller.go | 6 +++--- src/testing/lib/cache/cache.go | 6 +++--- src/testing/lib/config/manager.go | 6 +++--- src/testing/lib/orm/creator.go | 6 +++--- src/testing/pkg/accessory/dao/dao.go | 6 +++--- src/testing/pkg/accessory/manager.go | 6 +++--- src/testing/pkg/accessory/model/accessory.go | 6 +++--- src/testing/pkg/allowlist/dao/dao.go | 6 +++--- src/testing/pkg/allowlist/manager.go | 6 +++--- src/testing/pkg/artifact/manager.go | 6 +++--- src/testing/pkg/audit/dao/dao.go | 6 +++--- src/testing/pkg/audit/manager.go | 6 +++--- src/testing/pkg/blob/manager.go | 6 +++--- src/testing/pkg/cached/manifest/redis/cached_manager.go | 6 +++--- src/testing/pkg/distribution/manifest.go | 6 +++--- src/testing/pkg/immutable/dao/dao.go | 6 +++--- src/testing/pkg/joblog/dao/dao.go | 6 +++--- src/testing/pkg/joblog/manager.go | 6 +++--- src/testing/pkg/label/dao/dao.go | 6 +++--- src/testing/pkg/label/manager.go | 6 +++--- src/testing/pkg/ldap/manager.go | 6 +++--- src/testing/pkg/notification/job/dao/dao.go | 6 +++--- src/testing/pkg/notification/policy/dao/dao.go | 6 +++--- src/testing/pkg/notification/policy/manager.go | 6 +++--- src/testing/pkg/oidc/dao/meta_dao.go | 6 +++--- src/testing/pkg/oidc/meta_manager.go | 6 +++--- src/testing/pkg/project/manager.go | 6 +++--- src/testing/pkg/project/metadata/manager.go | 6 +++--- src/testing/pkg/quota/driver/driver.go | 6 +++--- src/testing/pkg/quota/manager.go | 6 +++--- src/testing/pkg/rbac/dao/dao.go | 6 +++--- src/testing/pkg/rbac/manager.go | 6 +++--- src/testing/pkg/reg/adapter/adapter.go | 6 +++--- src/testing/pkg/reg/dao/dao.go | 6 +++--- src/testing/pkg/reg/manager.go | 6 +++--- src/testing/pkg/registry/fake_registry_client.go | 6 +++--- src/testing/pkg/replication/dao/dao.go | 6 +++--- src/testing/pkg/replication/manager.go | 6 +++--- src/testing/pkg/repository/dao/dao.go | 6 +++--- src/testing/pkg/repository/manager.go | 6 +++--- src/testing/pkg/robot/dao/dao.go | 6 +++--- src/testing/pkg/robot/manager.go | 6 +++--- src/testing/pkg/scan/export/artifact_digest_calculator.go | 6 +++--- src/testing/pkg/scan/export/filter_processor.go | 6 +++--- src/testing/pkg/scan/export/manager.go | 6 +++--- src/testing/pkg/scan/report/manager.go | 6 +++--- src/testing/pkg/scan/rest/v1/client.go | 6 +++--- src/testing/pkg/scan/rest/v1/client_pool.go | 6 +++--- src/testing/pkg/scan/rest/v1/request_resolver.go | 6 +++--- src/testing/pkg/scan/rest/v1/response_handler.go | 6 +++--- src/testing/pkg/scan/scanner/manager.go | 6 +++--- src/testing/pkg/scheduler/scheduler.go | 6 +++--- src/testing/pkg/systemartifact/cleanup/selector.go | 6 +++--- src/testing/pkg/systemartifact/dao/dao.go | 6 +++--- src/testing/pkg/systemartifact/manager.go | 6 +++--- src/testing/pkg/task/execution_manager.go | 6 +++--- src/testing/pkg/task/manager.go | 6 +++--- src/testing/pkg/user/dao/dao.go | 6 +++--- src/testing/pkg/user/manager.go | 6 +++--- 88 files changed, 262 insertions(+), 262 deletions(-) diff --git a/Makefile b/Makefile index 5ee4c73a3..dfeb4267c 100644 --- a/Makefile +++ b/Makefile @@ -346,7 +346,7 @@ gen_apis: lint_apis MOCKERY_IMAGENAME=$(IMAGENAMESPACE)/mockery -MOCKERY_VERSION=v2.12.3 +MOCKERY_VERSION=v2.14.0 MOCKERY=$(RUNCONTAINER) ${MOCKERY_IMAGENAME}:${MOCKERY_VERSION} MOCKERY_IMAGE_BUILD_CMD=${DOCKERBUILD} -f ${TOOLSPATH}/mockery/Dockerfile --build-arg GOLANG=${GOBUILDIMAGE} --build-arg MOCKERY_VERSION=${MOCKERY_VERSION} -t ${MOCKERY_IMAGENAME}:$(MOCKERY_VERSION) . diff --git a/src/controller/replication/flow/mock_adapter_factory_test.go b/src/controller/replication/flow/mock_adapter_factory_test.go index 884a0bc46..1aedc23d9 100644 --- a/src/controller/replication/flow/mock_adapter_factory_test.go +++ b/src/controller/replication/flow/mock_adapter_factory_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package flow @@ -53,13 +53,13 @@ func (_m *mockFactory) Create(_a0 *model.Registry) (adapter.Adapter, error) { return r0, r1 } -type newMockFactoryT interface { +type mockConstructorTestingTnewMockFactory interface { mock.TestingT Cleanup(func()) } // newMockFactory creates a new instance of mockFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockFactory(t newMockFactoryT) *mockFactory { +func newMockFactory(t mockConstructorTestingTnewMockFactory) *mockFactory { mock := &mockFactory{} mock.Mock.Test(t) diff --git a/src/controller/replication/flow/mock_adapter_test.go b/src/controller/replication/flow/mock_adapter_test.go index ffe0fb5f5..2336a8b09 100644 --- a/src/controller/replication/flow/mock_adapter_test.go +++ b/src/controller/replication/flow/mock_adapter_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package flow @@ -344,13 +344,13 @@ func (_m *mockAdapter) PushManifest(repository string, reference string, mediaTy return r0, r1 } -type newMockAdapterT interface { +type mockConstructorTestingTnewMockAdapter interface { mock.TestingT Cleanup(func()) } // newMockAdapter creates a new instance of mockAdapter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockAdapter(t newMockAdapterT) *mockAdapter { +func newMockAdapter(t mockConstructorTestingTnewMockAdapter) *mockAdapter { mock := &mockAdapter{} mock.Mock.Test(t) diff --git a/src/controller/replication/mock_flow_controller_test.go b/src/controller/replication/mock_flow_controller_test.go index a999374ab..7c8305b94 100644 --- a/src/controller/replication/mock_flow_controller_test.go +++ b/src/controller/replication/mock_flow_controller_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package replication @@ -31,13 +31,13 @@ func (_m *flowController) Start(ctx context.Context, executionID int64, policy * return r0 } -type newFlowControllerT interface { +type mockConstructorTestingTnewFlowController interface { mock.TestingT Cleanup(func()) } // newFlowController creates a new instance of flowController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newFlowController(t newFlowControllerT) *flowController { +func newFlowController(t mockConstructorTestingTnewFlowController) *flowController { mock := &flowController{} mock.Mock.Test(t) diff --git a/src/jobservice/mgt/mock_manager.go b/src/jobservice/mgt/mock_manager.go index 41f2d4965..cf523079b 100644 --- a/src/jobservice/mgt/mock_manager.go +++ b/src/jobservice/mgt/mock_manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package mgt @@ -141,13 +141,13 @@ func (_m *MockManager) SaveJob(_a0 *job.Stats) error { return r0 } -type NewMockManagerT interface { +type mockConstructorTestingTNewMockManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewMockManager(t NewMockManagerT) *MockManager { +func NewMockManager(t mockConstructorTestingTNewMockManager) *MockManager { mock := &MockManager{} mock.Mock.Test(t) diff --git a/src/jobservice/period/mock_scheduler.go b/src/jobservice/period/mock_scheduler.go index 107bf5de4..b0b19cae6 100644 --- a/src/jobservice/period/mock_scheduler.go +++ b/src/jobservice/period/mock_scheduler.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package period @@ -49,13 +49,13 @@ func (_m *MockScheduler) UnSchedule(policyID string) error { return r0 } -type NewMockSchedulerT interface { +type mockConstructorTestingTNewMockScheduler interface { mock.TestingT Cleanup(func()) } // NewMockScheduler creates a new instance of MockScheduler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockScheduler(t NewMockSchedulerT) *MockScheduler { +func NewMockScheduler(t mockConstructorTestingTNewMockScheduler) *MockScheduler { mock := &MockScheduler{} mock.Mock.Test(t) diff --git a/src/pkg/scheduler/mock_dao_test.go b/src/pkg/scheduler/mock_dao_test.go index b93c53fbf..096a7d1e1 100644 --- a/src/pkg/scheduler/mock_dao_test.go +++ b/src/pkg/scheduler/mock_dao_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scheduler @@ -137,13 +137,13 @@ func (_m *mockDAO) UpdateRevision(ctx context.Context, id int64, revision int64) return r0, r1 } -type newMockDAOT interface { +type mockConstructorTestingTnewMockDAO interface { mock.TestingT Cleanup(func()) } // newMockDAO creates a new instance of mockDAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockDAO(t newMockDAOT) *mockDAO { +func newMockDAO(t mockConstructorTestingTnewMockDAO) *mockDAO { mock := &mockDAO{} mock.Mock.Test(t) diff --git a/src/pkg/task/mock_execution_dao_test.go b/src/pkg/task/mock_execution_dao_test.go index 57eb1d8bf..8cc981980 100644 --- a/src/pkg/task/mock_execution_dao_test.go +++ b/src/pkg/task/mock_execution_dao_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package task @@ -190,13 +190,13 @@ func (_m *mockExecutionDAO) Update(ctx context.Context, execution *dao.Execution return r0 } -type newMockExecutionDAOT interface { +type mockConstructorTestingTnewMockExecutionDAO interface { mock.TestingT Cleanup(func()) } // newMockExecutionDAO creates a new instance of mockExecutionDAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockExecutionDAO(t newMockExecutionDAOT) *mockExecutionDAO { +func newMockExecutionDAO(t mockConstructorTestingTnewMockExecutionDAO) *mockExecutionDAO { mock := &mockExecutionDAO{} mock.Mock.Test(t) diff --git a/src/pkg/task/mock_jobservice_client_test.go b/src/pkg/task/mock_jobservice_client_test.go index 4191321cc..b1f8a6ce3 100644 --- a/src/pkg/task/mock_jobservice_client_test.go +++ b/src/pkg/task/mock_jobservice_client_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package task @@ -95,13 +95,13 @@ func (_m *mockJobserviceClient) SubmitJob(_a0 *models.JobData) (string, error) { return r0, r1 } -type newMockJobserviceClientT interface { +type mockConstructorTestingTnewMockJobserviceClient interface { mock.TestingT Cleanup(func()) } // newMockJobserviceClient creates a new instance of mockJobserviceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockJobserviceClient(t newMockJobserviceClientT) *mockJobserviceClient { +func newMockJobserviceClient(t mockConstructorTestingTnewMockJobserviceClient) *mockJobserviceClient { mock := &mockJobserviceClient{} mock.Mock.Test(t) diff --git a/src/pkg/task/mock_task_dao_test.go b/src/pkg/task/mock_task_dao_test.go index f06edda7c..bc35740d0 100644 --- a/src/pkg/task/mock_task_dao_test.go +++ b/src/pkg/task/mock_task_dao_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package task @@ -199,13 +199,13 @@ func (_m *mockTaskDAO) UpdateStatus(ctx context.Context, id int64, status string return r0 } -type newMockTaskDAOT interface { +type mockConstructorTestingTnewMockTaskDAO interface { mock.TestingT Cleanup(func()) } // newMockTaskDAO creates a new instance of mockTaskDAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockTaskDAO(t newMockTaskDAOT) *mockTaskDAO { +func newMockTaskDAO(t mockConstructorTestingTnewMockTaskDAO) *mockTaskDAO { mock := &mockTaskDAO{} mock.Mock.Test(t) diff --git a/src/pkg/task/mock_task_manager_test.go b/src/pkg/task/mock_task_manager_test.go index 6e8ed032d..7cf6bf625 100644 --- a/src/pkg/task/mock_task_manager_test.go +++ b/src/pkg/task/mock_task_manager_test.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package task @@ -160,13 +160,13 @@ func (_m *mockTaskManager) UpdateExtraAttrs(ctx context.Context, id int64, extra return r0 } -type newMockTaskManagerT interface { +type mockConstructorTestingTnewMockTaskManager interface { mock.TestingT Cleanup(func()) } // newMockTaskManager creates a new instance of mockTaskManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newMockTaskManager(t newMockTaskManagerT) *mockTaskManager { +func newMockTaskManager(t mockConstructorTestingTnewMockTaskManager) *mockTaskManager { mock := &mockTaskManager{} mock.Mock.Test(t) diff --git a/src/testing/common/security/context.go b/src/testing/common/security/context.go index 50425cfb7..fb26f2cb5 100644 --- a/src/testing/common/security/context.go +++ b/src/testing/common/security/context.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package security @@ -99,13 +99,13 @@ func (_m *Context) Name() string { return r0 } -type NewContextT interface { +type mockConstructorTestingTNewContext interface { mock.TestingT Cleanup(func()) } // NewContext creates a new instance of Context. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewContext(t NewContextT) *Context { +func NewContext(t mockConstructorTestingTNewContext) *Context { mock := &Context{} mock.Mock.Test(t) diff --git a/src/testing/controller/artifact/controller.go b/src/testing/controller/artifact/controller.go index c7dae27c2..9b5ff2e33 100644 --- a/src/testing/controller/artifact/controller.go +++ b/src/testing/controller/artifact/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package artifact @@ -253,13 +253,13 @@ func (_m *Controller) Walk(ctx context.Context, root *artifact.Artifact, walkFn return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/blob/controller.go b/src/testing/controller/blob/controller.go index 4240051fc..baf7d4d9f 100644 --- a/src/testing/controller/blob/controller.go +++ b/src/testing/controller/blob/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package blob @@ -335,13 +335,13 @@ func (_m *Controller) Update(ctx context.Context, _a1 *models.Blob) error { return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/config/controller.go b/src/testing/controller/config/controller.go index 2826ca67b..7a6b0018b 100644 --- a/src/testing/controller/config/controller.go +++ b/src/testing/controller/config/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package config @@ -111,13 +111,13 @@ func (_m *Controller) UserConfigs(ctx context.Context) (map[string]*models.Value return r0, r1 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/jobservice/scheduler_controller.go b/src/testing/controller/jobservice/scheduler_controller.go index d890bab71..dc16bfe34 100644 --- a/src/testing/controller/jobservice/scheduler_controller.go +++ b/src/testing/controller/jobservice/scheduler_controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package jobservice @@ -73,13 +73,13 @@ func (_m *SchedulerController) Get(ctx context.Context, vendorType string) (*sch return r0, r1 } -type NewSchedulerControllerT interface { +type mockConstructorTestingTNewSchedulerController interface { mock.TestingT Cleanup(func()) } // NewSchedulerController creates a new instance of SchedulerController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewSchedulerController(t NewSchedulerControllerT) *SchedulerController { +func NewSchedulerController(t mockConstructorTestingTNewSchedulerController) *SchedulerController { mock := &SchedulerController{} mock.Mock.Test(t) diff --git a/src/testing/controller/project/controller.go b/src/testing/controller/project/controller.go index c9873562b..1a5f8987e 100644 --- a/src/testing/controller/project/controller.go +++ b/src/testing/controller/project/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package project @@ -225,13 +225,13 @@ func (_m *Controller) Update(ctx context.Context, _a1 *models.Project) error { return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/proxy/remote_interface.go b/src/testing/controller/proxy/remote_interface.go index f16b2e835..df677adcd 100644 --- a/src/testing/controller/proxy/remote_interface.go +++ b/src/testing/controller/proxy/remote_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package proxy @@ -128,13 +128,13 @@ func (_m *RemoteInterface) ManifestExist(repo string, ref string) (bool, *distri return r0, r1, r2 } -type NewRemoteInterfaceT interface { +type mockConstructorTestingTNewRemoteInterface interface { mock.TestingT Cleanup(func()) } // NewRemoteInterface creates a new instance of RemoteInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewRemoteInterface(t NewRemoteInterfaceT) *RemoteInterface { +func NewRemoteInterface(t mockConstructorTestingTNewRemoteInterface) *RemoteInterface { mock := &RemoteInterface{} mock.Mock.Test(t) diff --git a/src/testing/controller/purge/controller.go b/src/testing/controller/purge/controller.go index 720fee92a..824a6843f 100644 --- a/src/testing/controller/purge/controller.go +++ b/src/testing/controller/purge/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package purge @@ -49,13 +49,13 @@ func (_m *Controller) Stop(ctx context.Context, id int64) error { return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/quota/controller.go b/src/testing/controller/quota/controller.go index 3995acb56..275fcce0c 100644 --- a/src/testing/controller/quota/controller.go +++ b/src/testing/controller/quota/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package quota @@ -243,13 +243,13 @@ func (_m *Controller) Update(ctx context.Context, _a1 *models.Quota) error { return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/replication/controller.go b/src/testing/controller/replication/controller.go index ec5fd044d..7d93d0799 100644 --- a/src/testing/controller/replication/controller.go +++ b/src/testing/controller/replication/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package replication @@ -335,13 +335,13 @@ func (_m *Controller) UpdatePolicy(ctx context.Context, policy *model.Policy, pr return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/repository/controller.go b/src/testing/controller/repository/controller.go index 27d4118ae..290147664 100644 --- a/src/testing/controller/repository/controller.go +++ b/src/testing/controller/repository/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package repository @@ -183,13 +183,13 @@ func (_m *Controller) Update(ctx context.Context, _a1 *model.RepoRecord, propert return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/retention/controller.go b/src/testing/controller/retention/controller.go index 6434b8253..7480e9d46 100644 --- a/src/testing/controller/retention/controller.go +++ b/src/testing/controller/retention/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package retention @@ -282,13 +282,13 @@ func (_m *Controller) UpdateRetention(ctx context.Context, p *policy.Metadata) e return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/robot/controller.go b/src/testing/controller/robot/controller.go index 5c0f4a2d3..8e94dcc81 100644 --- a/src/testing/controller/robot/controller.go +++ b/src/testing/controller/robot/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package robot @@ -139,13 +139,13 @@ func (_m *Controller) Update(ctx context.Context, r *robot.Robot, option *robot. return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/scan/checker.go b/src/testing/controller/scan/checker.go index 578138659..341d09d54 100644 --- a/src/testing/controller/scan/checker.go +++ b/src/testing/controller/scan/checker.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scan @@ -36,13 +36,13 @@ func (_m *Checker) IsScannable(ctx context.Context, _a1 *artifact.Artifact) (boo return r0, r1 } -type NewCheckerT interface { +type mockConstructorTestingTNewChecker interface { mock.TestingT Cleanup(func()) } // NewChecker creates a new instance of Checker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewChecker(t NewCheckerT) *Checker { +func NewChecker(t mockConstructorTestingTNewChecker) *Checker { mock := &Checker{} mock.Mock.Test(t) diff --git a/src/testing/controller/scan/controller.go b/src/testing/controller/scan/controller.go index 564baa452..0ee8dd63f 100644 --- a/src/testing/controller/scan/controller.go +++ b/src/testing/controller/scan/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scan @@ -190,13 +190,13 @@ func (_m *Controller) Stop(ctx context.Context, _a1 *artifact.Artifact) error { return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/scandataexport/controller.go b/src/testing/controller/scandataexport/controller.go index ce6e65f54..010df9b4b 100644 --- a/src/testing/controller/scandataexport/controller.go +++ b/src/testing/controller/scandataexport/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scandataexport @@ -120,13 +120,13 @@ func (_m *Controller) Start(ctx context.Context, criteria export.Request) (int64 return r0, r1 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/scanner/controller.go b/src/testing/controller/scanner/controller.go index fc11cc1a1..257d8130f 100644 --- a/src/testing/controller/scanner/controller.go +++ b/src/testing/controller/scanner/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scanner @@ -263,13 +263,13 @@ func (_m *Controller) UpdateRegistration(ctx context.Context, registration *scan return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/systemartifact/controller.go b/src/testing/controller/systemartifact/controller.go index 39835f52e..861910282 100644 --- a/src/testing/controller/systemartifact/controller.go +++ b/src/testing/controller/systemartifact/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package systemartifact @@ -27,13 +27,13 @@ func (_m *Controller) Start(ctx context.Context, async bool, trigger string) err return r0 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/controller/user/controller.go b/src/testing/controller/user/controller.go index b85caf8b9..b3acfb16f 100644 --- a/src/testing/controller/user/controller.go +++ b/src/testing/controller/user/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package user @@ -294,13 +294,13 @@ func (_m *Controller) VerifyPassword(ctx context.Context, usernameOrEmail string return r0, r1 } -type NewControllerT interface { +type mockConstructorTestingTNewController interface { mock.TestingT Cleanup(func()) } // NewController creates a new instance of Controller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewController(t NewControllerT) *Controller { +func NewController(t mockConstructorTestingTNewController) *Controller { mock := &Controller{} mock.Mock.Test(t) diff --git a/src/testing/lib/cache/cache.go b/src/testing/lib/cache/cache.go index 9faadf8bf..4c6ed3d7c 100644 --- a/src/testing/lib/cache/cache.go +++ b/src/testing/lib/cache/cache.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package cache @@ -121,13 +121,13 @@ func (_m *Cache) Save(ctx context.Context, key string, value interface{}, expira return r0 } -type NewCacheT interface { +type mockConstructorTestingTNewCache interface { mock.TestingT Cleanup(func()) } // NewCache creates a new instance of Cache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewCache(t NewCacheT) *Cache { +func NewCache(t mockConstructorTestingTNewCache) *Cache { mock := &Cache{} mock.Mock.Test(t) diff --git a/src/testing/lib/config/manager.go b/src/testing/lib/config/manager.go index d5182df8c..e3f2dd473 100644 --- a/src/testing/lib/config/manager.go +++ b/src/testing/lib/config/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package config @@ -141,13 +141,13 @@ func (_m *Manager) ValidateCfg(ctx context.Context, cfgs map[string]interface{}) return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/lib/orm/creator.go b/src/testing/lib/orm/creator.go index 012e032eb..7bbcb9ad9 100644 --- a/src/testing/lib/orm/creator.go +++ b/src/testing/lib/orm/creator.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package orm @@ -28,13 +28,13 @@ func (_m *Creator) Create() orm.Ormer { return r0 } -type NewCreatorT interface { +type mockConstructorTestingTNewCreator interface { mock.TestingT Cleanup(func()) } // NewCreator creates a new instance of Creator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewCreator(t NewCreatorT) *Creator { +func NewCreator(t mockConstructorTestingTNewCreator) *Creator { mock := &Creator{} mock.Mock.Test(t) diff --git a/src/testing/pkg/accessory/dao/dao.go b/src/testing/pkg/accessory/dao/dao.go index ff2f7bf20..232487a8f 100644 --- a/src/testing/pkg/accessory/dao/dao.go +++ b/src/testing/pkg/accessory/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -139,13 +139,13 @@ func (_m *DAO) List(ctx context.Context, query *q.Query) ([]*dao.Accessory, erro return r0, r1 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/accessory/manager.go b/src/testing/pkg/accessory/manager.go index a58820dce..a7a4b05a2 100644 --- a/src/testing/pkg/accessory/manager.go +++ b/src/testing/pkg/accessory/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package accessory @@ -146,13 +146,13 @@ func (_m *Manager) List(ctx context.Context, query *q.Query) ([]model.Accessory, return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/accessory/model/accessory.go b/src/testing/pkg/accessory/model/accessory.go index e3c258ed2..e4df6efca 100644 --- a/src/testing/pkg/accessory/model/accessory.go +++ b/src/testing/pkg/accessory/model/accessory.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package model @@ -82,13 +82,13 @@ func (_m *Accessory) Kind() string { return r0 } -type NewAccessoryT interface { +type mockConstructorTestingTNewAccessory interface { mock.TestingT Cleanup(func()) } // NewAccessory creates a new instance of Accessory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewAccessory(t NewAccessoryT) *Accessory { +func NewAccessory(t mockConstructorTestingTNewAccessory) *Accessory { mock := &Accessory{} mock.Mock.Test(t) diff --git a/src/testing/pkg/allowlist/dao/dao.go b/src/testing/pkg/allowlist/dao/dao.go index 93c0724be..d48911c6b 100644 --- a/src/testing/pkg/allowlist/dao/dao.go +++ b/src/testing/pkg/allowlist/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -59,13 +59,13 @@ func (_m *DAO) Set(ctx context.Context, l models.CVEAllowlist) (int64, error) { return r0, r1 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/allowlist/manager.go b/src/testing/pkg/allowlist/manager.go index 0365d8c0b..7406a1909 100644 --- a/src/testing/pkg/allowlist/manager.go +++ b/src/testing/pkg/allowlist/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package robot @@ -102,13 +102,13 @@ func (_m *Manager) SetSys(ctx context.Context, list models.CVEAllowlist) error { return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/artifact/manager.go b/src/testing/pkg/artifact/manager.go index 88995c121..4a8ebb210 100644 --- a/src/testing/pkg/artifact/manager.go +++ b/src/testing/pkg/artifact/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package artifact @@ -216,13 +216,13 @@ func (_m *Manager) UpdatePullTime(ctx context.Context, id int64, pullTime time.T return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/audit/dao/dao.go b/src/testing/pkg/audit/dao/dao.go index 0e68519aa..d07b86b7b 100644 --- a/src/testing/pkg/audit/dao/dao.go +++ b/src/testing/pkg/audit/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -140,13 +140,13 @@ func (_m *DAO) Purge(ctx context.Context, retentionHour int, includeOperations [ return r0, r1 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/audit/manager.go b/src/testing/pkg/audit/manager.go index 2db286eec..c96870f95 100644 --- a/src/testing/pkg/audit/manager.go +++ b/src/testing/pkg/audit/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package audit @@ -139,13 +139,13 @@ func (_m *Manager) Purge(ctx context.Context, retentionHour int, includeOperatio return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/blob/manager.go b/src/testing/pkg/blob/manager.go index 8a894a7e1..b7bd76bda 100644 --- a/src/testing/pkg/blob/manager.go +++ b/src/testing/pkg/blob/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package blob @@ -313,13 +313,13 @@ func (_m *Manager) UselessBlobs(ctx context.Context, timeWindowHours int64) ([]* return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/cached/manifest/redis/cached_manager.go b/src/testing/pkg/cached/manifest/redis/cached_manager.go index 235377aa2..b14f040c6 100644 --- a/src/testing/pkg/cached/manifest/redis/cached_manager.go +++ b/src/testing/pkg/cached/manifest/redis/cached_manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package redis @@ -145,13 +145,13 @@ func (_m *CachedManager) Save(ctx context.Context, digest string, manifest []byt return r0 } -type NewCachedManagerT interface { +type mockConstructorTestingTNewCachedManager interface { mock.TestingT Cleanup(func()) } // NewCachedManager creates a new instance of CachedManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewCachedManager(t NewCachedManagerT) *CachedManager { +func NewCachedManager(t mockConstructorTestingTNewCachedManager) *CachedManager { mock := &CachedManager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/distribution/manifest.go b/src/testing/pkg/distribution/manifest.go index e0603956c..81b262759 100644 --- a/src/testing/pkg/distribution/manifest.go +++ b/src/testing/pkg/distribution/manifest.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package distribution @@ -58,13 +58,13 @@ func (_m *Manifest) References() []distribution.Descriptor { return r0 } -type NewManifestT interface { +type mockConstructorTestingTNewManifest interface { mock.TestingT Cleanup(func()) } // NewManifest creates a new instance of Manifest. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewManifest(t NewManifestT) *Manifest { +func NewManifest(t mockConstructorTestingTNewManifest) *Manifest { mock := &Manifest{} mock.Mock.Test(t) diff --git a/src/testing/pkg/immutable/dao/dao.go b/src/testing/pkg/immutable/dao/dao.go index 24538ef48..67d2809c8 100644 --- a/src/testing/pkg/immutable/dao/dao.go +++ b/src/testing/pkg/immutable/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -147,13 +147,13 @@ func (_m *DAO) UpdateImmutableRule(ctx context.Context, projectID int64, ir *mod return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/joblog/dao/dao.go b/src/testing/pkg/joblog/dao/dao.go index 699d327d1..70b25eed2 100644 --- a/src/testing/pkg/joblog/dao/dao.go +++ b/src/testing/pkg/joblog/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -82,13 +82,13 @@ func (_m *DAO) Get(ctx context.Context, uuid string) (*models.JobLog, error) { return r0, r1 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/joblog/manager.go b/src/testing/pkg/joblog/manager.go index d1dbe2338..d6752cc94 100644 --- a/src/testing/pkg/joblog/manager.go +++ b/src/testing/pkg/joblog/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package joblog @@ -82,13 +82,13 @@ func (_m *Manager) Get(ctx context.Context, uuid string) (*models.JobLog, error) return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/label/dao/dao.go b/src/testing/pkg/label/dao/dao.go index 5fefa5acd..f2b782eee 100644 --- a/src/testing/pkg/label/dao/dao.go +++ b/src/testing/pkg/label/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -212,13 +212,13 @@ func (_m *DAO) Update(ctx context.Context, label *model.Label) error { return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/label/manager.go b/src/testing/pkg/label/manager.go index 61b0c29e3..f3b2ccecb 100644 --- a/src/testing/pkg/label/manager.go +++ b/src/testing/pkg/label/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package label @@ -212,13 +212,13 @@ func (_m *Manager) Update(ctx context.Context, _a1 *model.Label) error { return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/ldap/manager.go b/src/testing/pkg/ldap/manager.go index 9daa4d53c..c85fff126 100644 --- a/src/testing/pkg/ldap/manager.go +++ b/src/testing/pkg/ldap/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package ldap @@ -108,13 +108,13 @@ func (_m *Manager) SearchUser(ctx context.Context, sess *ldap.Session, username return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/notification/job/dao/dao.go b/src/testing/pkg/notification/job/dao/dao.go index 9817045ff..38f2ea28e 100644 --- a/src/testing/pkg/notification/job/dao/dao.go +++ b/src/testing/pkg/notification/job/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -177,13 +177,13 @@ func (_m *DAO) Update(ctx context.Context, n *model.Job, props ...string) error return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/notification/policy/dao/dao.go b/src/testing/pkg/notification/policy/dao/dao.go index 158590766..75bb57871 100644 --- a/src/testing/pkg/notification/policy/dao/dao.go +++ b/src/testing/pkg/notification/policy/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -133,13 +133,13 @@ func (_m *DAO) Update(ctx context.Context, n *model.Policy) error { return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/notification/policy/manager.go b/src/testing/pkg/notification/policy/manager.go index a0e497b72..f34e3fa25 100644 --- a/src/testing/pkg/notification/policy/manager.go +++ b/src/testing/pkg/notification/policy/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package notification @@ -192,13 +192,13 @@ func (_m *Manager) Update(ctx context.Context, _a1 *model.Policy) error { return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/oidc/dao/meta_dao.go b/src/testing/pkg/oidc/dao/meta_dao.go index 6b91e7e17..0e8c202e3 100644 --- a/src/testing/pkg/oidc/dao/meta_dao.go +++ b/src/testing/pkg/oidc/dao/meta_dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -119,13 +119,13 @@ func (_m *MetaDAO) Update(ctx context.Context, oidcUser *models.OIDCUser, props return r0 } -type NewMetaDAOT interface { +type mockConstructorTestingTNewMetaDAO interface { mock.TestingT Cleanup(func()) } // NewMetaDAO creates a new instance of MetaDAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMetaDAO(t NewMetaDAOT) *MetaDAO { +func NewMetaDAO(t mockConstructorTestingTNewMetaDAO) *MetaDAO { mock := &MetaDAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/oidc/meta_manager.go b/src/testing/pkg/oidc/meta_manager.go index 31bba1ec9..703e33e01 100644 --- a/src/testing/pkg/oidc/meta_manager.go +++ b/src/testing/pkg/oidc/meta_manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package oidc @@ -130,13 +130,13 @@ func (_m *MetaManager) Update(ctx context.Context, oidcUser *models.OIDCUser, co return r0 } -type NewMetaManagerT interface { +type mockConstructorTestingTNewMetaManager interface { mock.TestingT Cleanup(func()) } // NewMetaManager creates a new instance of MetaManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMetaManager(t NewMetaManagerT) *MetaManager { +func NewMetaManager(t mockConstructorTestingTNewMetaManager) *MetaManager { mock := &MetaManager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/project/manager.go b/src/testing/pkg/project/manager.go index 236a2b5ab..e8b134be8 100644 --- a/src/testing/pkg/project/manager.go +++ b/src/testing/pkg/project/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package project @@ -148,13 +148,13 @@ func (_m *Manager) ListRoles(ctx context.Context, projectID int64, userID int, g return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/project/metadata/manager.go b/src/testing/pkg/project/metadata/manager.go index a92952efe..315443cc6 100644 --- a/src/testing/pkg/project/metadata/manager.go +++ b/src/testing/pkg/project/metadata/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package metadata @@ -117,13 +117,13 @@ func (_m *Manager) Update(ctx context.Context, projectID int64, meta map[string] return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/quota/driver/driver.go b/src/testing/pkg/quota/driver/driver.go index 3b03bddcd..041de4a1b 100644 --- a/src/testing/pkg/quota/driver/driver.go +++ b/src/testing/pkg/quota/driver/driver.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package driver @@ -113,13 +113,13 @@ func (_m *Driver) Validate(hardLimits types.ResourceList) error { return r0 } -type NewDriverT interface { +type mockConstructorTestingTNewDriver interface { mock.TestingT Cleanup(func()) } // NewDriver creates a new instance of Driver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDriver(t NewDriverT) *Driver { +func NewDriver(t mockConstructorTestingTNewDriver) *Driver { mock := &Driver{} mock.Mock.Test(t) diff --git a/src/testing/pkg/quota/manager.go b/src/testing/pkg/quota/manager.go index 81aa5cfb3..a143fe2af 100644 --- a/src/testing/pkg/quota/manager.go +++ b/src/testing/pkg/quota/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package quota @@ -164,13 +164,13 @@ func (_m *Manager) Update(ctx context.Context, _a1 *models.Quota) error { return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/rbac/dao/dao.go b/src/testing/pkg/rbac/dao/dao.go index d76dafbfb..2a2430715 100644 --- a/src/testing/pkg/rbac/dao/dao.go +++ b/src/testing/pkg/rbac/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -170,13 +170,13 @@ func (_m *DAO) ListRbacPolicies(ctx context.Context, query *q.Query) ([]*model.P return r0, r1 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/rbac/manager.go b/src/testing/pkg/rbac/manager.go index 493b3aeaf..ff720f09b 100644 --- a/src/testing/pkg/rbac/manager.go +++ b/src/testing/pkg/rbac/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package rbac @@ -169,13 +169,13 @@ func (_m *Manager) ListRbacPolicies(ctx context.Context, query *q.Query) ([]*mod return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/reg/adapter/adapter.go b/src/testing/pkg/reg/adapter/adapter.go index b358e5527..36b6d27fb 100644 --- a/src/testing/pkg/reg/adapter/adapter.go +++ b/src/testing/pkg/reg/adapter/adapter.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package adapter @@ -70,13 +70,13 @@ func (_m *Adapter) PrepareForPush(_a0 []*model.Resource) error { return r0 } -type NewAdapterT interface { +type mockConstructorTestingTNewAdapter interface { mock.TestingT Cleanup(func()) } // NewAdapter creates a new instance of Adapter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewAdapter(t NewAdapterT) *Adapter { +func NewAdapter(t mockConstructorTestingTNewAdapter) *Adapter { mock := &Adapter{} mock.Mock.Test(t) diff --git a/src/testing/pkg/reg/dao/dao.go b/src/testing/pkg/reg/dao/dao.go index 4a47e22dd..0f6b4e513 100644 --- a/src/testing/pkg/reg/dao/dao.go +++ b/src/testing/pkg/reg/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -139,13 +139,13 @@ func (_m *DAO) Update(ctx context.Context, registry *dao.Registry, props ...stri return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/reg/manager.go b/src/testing/pkg/reg/manager.go index 8c2e301dc..da01cf9c3 100644 --- a/src/testing/pkg/reg/manager.go +++ b/src/testing/pkg/reg/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package manager @@ -211,13 +211,13 @@ func (_m *Manager) Update(ctx context.Context, registry *model.Registry, props . return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/registry/fake_registry_client.go b/src/testing/pkg/registry/fake_registry_client.go index 813789a67..8200a4e15 100644 --- a/src/testing/pkg/registry/fake_registry_client.go +++ b/src/testing/pkg/registry/fake_registry_client.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package registry @@ -309,13 +309,13 @@ func (_m *Client) PushManifest(repository string, reference string, mediaType st return r0, r1 } -type NewClientT interface { +type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) } // NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewClient(t NewClientT) *Client { +func NewClient(t mockConstructorTestingTNewClient) *Client { mock := &Client{} mock.Mock.Test(t) diff --git a/src/testing/pkg/replication/dao/dao.go b/src/testing/pkg/replication/dao/dao.go index 10eba4d6a..816270c10 100644 --- a/src/testing/pkg/replication/dao/dao.go +++ b/src/testing/pkg/replication/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -140,13 +140,13 @@ func (_m *DAO) Update(ctx context.Context, policy *model.Policy, props ...string return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/replication/manager.go b/src/testing/pkg/replication/manager.go index 0f29ac5dc..91c4705c5 100644 --- a/src/testing/pkg/replication/manager.go +++ b/src/testing/pkg/replication/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package manager @@ -139,13 +139,13 @@ func (_m *Manager) Update(ctx context.Context, policy *model.Policy, props ...st return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/repository/dao/dao.go b/src/testing/pkg/repository/dao/dao.go index 3ce3aab35..be27c7807 100644 --- a/src/testing/pkg/repository/dao/dao.go +++ b/src/testing/pkg/repository/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -177,13 +177,13 @@ func (_m *DAO) Update(ctx context.Context, repository *model.RepoRecord, props . return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/repository/manager.go b/src/testing/pkg/repository/manager.go index 60b42d4ef..d986e1e47 100644 --- a/src/testing/pkg/repository/manager.go +++ b/src/testing/pkg/repository/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package repository @@ -199,13 +199,13 @@ func (_m *Manager) Update(ctx context.Context, _a1 *model.RepoRecord, props ...s return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/robot/dao/dao.go b/src/testing/pkg/robot/dao/dao.go index 23fd9852f..abd3e88ab 100644 --- a/src/testing/pkg/robot/dao/dao.go +++ b/src/testing/pkg/robot/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -154,13 +154,13 @@ func (_m *DAO) Update(ctx context.Context, r *model.Robot, props ...string) erro return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/robot/manager.go b/src/testing/pkg/robot/manager.go index 55ded1750..7e4b04ac3 100644 --- a/src/testing/pkg/robot/manager.go +++ b/src/testing/pkg/robot/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package robot @@ -153,13 +153,13 @@ func (_m *Manager) Update(ctx context.Context, m *model.Robot, props ...string) return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/export/artifact_digest_calculator.go b/src/testing/pkg/scan/export/artifact_digest_calculator.go index dd8b76080..62ffc288a 100644 --- a/src/testing/pkg/scan/export/artifact_digest_calculator.go +++ b/src/testing/pkg/scan/export/artifact_digest_calculator.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package export @@ -34,13 +34,13 @@ func (_m *ArtifactDigestCalculator) Calculate(fileName string) (digest.Digest, e return r0, r1 } -type NewArtifactDigestCalculatorT interface { +type mockConstructorTestingTNewArtifactDigestCalculator interface { mock.TestingT Cleanup(func()) } // NewArtifactDigestCalculator creates a new instance of ArtifactDigestCalculator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewArtifactDigestCalculator(t NewArtifactDigestCalculatorT) *ArtifactDigestCalculator { +func NewArtifactDigestCalculator(t mockConstructorTestingTNewArtifactDigestCalculator) *ArtifactDigestCalculator { mock := &ArtifactDigestCalculator{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/export/filter_processor.go b/src/testing/pkg/scan/export/filter_processor.go index 9b81b58fc..be9af0f80 100644 --- a/src/testing/pkg/scan/export/filter_processor.go +++ b/src/testing/pkg/scan/export/filter_processor.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package export @@ -107,13 +107,13 @@ func (_m *FilterProcessor) ProcessTagFilter(ctx context.Context, filter string, return r0, r1 } -type NewFilterProcessorT interface { +type mockConstructorTestingTNewFilterProcessor interface { mock.TestingT Cleanup(func()) } // NewFilterProcessor creates a new instance of FilterProcessor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewFilterProcessor(t NewFilterProcessorT) *FilterProcessor { +func NewFilterProcessor(t mockConstructorTestingTNewFilterProcessor) *FilterProcessor { mock := &FilterProcessor{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/export/manager.go b/src/testing/pkg/scan/export/manager.go index c66fa69b3..32b085d15 100644 --- a/src/testing/pkg/scan/export/manager.go +++ b/src/testing/pkg/scan/export/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package export @@ -37,13 +37,13 @@ func (_m *Manager) Fetch(ctx context.Context, params export.Params) ([]export.Da return r0, r1 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/report/manager.go b/src/testing/pkg/scan/report/manager.go index 016b8b6bc..a43588d59 100644 --- a/src/testing/pkg/scan/report/manager.go +++ b/src/testing/pkg/scan/report/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package report @@ -132,13 +132,13 @@ func (_m *Manager) UpdateReportData(ctx context.Context, uuid string, _a2 string return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/rest/v1/client.go b/src/testing/pkg/scan/rest/v1/client.go index befaf86d5..96372701a 100644 --- a/src/testing/pkg/scan/rest/v1/client.go +++ b/src/testing/pkg/scan/rest/v1/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package v1 @@ -79,13 +79,13 @@ func (_m *Client) SubmitScan(req *v1.ScanRequest) (*v1.ScanResponse, error) { return r0, r1 } -type NewClientT interface { +type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) } // NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewClient(t NewClientT) *Client { +func NewClient(t mockConstructorTestingTNewClient) *Client { mock := &Client{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/rest/v1/client_pool.go b/src/testing/pkg/scan/rest/v1/client_pool.go index 93d9e0dca..4b35a868d 100644 --- a/src/testing/pkg/scan/rest/v1/client_pool.go +++ b/src/testing/pkg/scan/rest/v1/client_pool.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package v1 @@ -35,13 +35,13 @@ func (_m *ClientPool) Get(url string, authType string, accessCredential string, return r0, r1 } -type NewClientPoolT interface { +type mockConstructorTestingTNewClientPool interface { mock.TestingT Cleanup(func()) } // NewClientPool creates a new instance of ClientPool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewClientPool(t NewClientPoolT) *ClientPool { +func NewClientPool(t mockConstructorTestingTNewClientPool) *ClientPool { mock := &ClientPool{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/rest/v1/request_resolver.go b/src/testing/pkg/scan/rest/v1/request_resolver.go index c4237bbc5..2c8bd66b9 100644 --- a/src/testing/pkg/scan/rest/v1/request_resolver.go +++ b/src/testing/pkg/scan/rest/v1/request_resolver.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package v1 @@ -18,13 +18,13 @@ func (_m *RequestResolver) Execute(req *http.Request) { _m.Called(req) } -type NewRequestResolverT interface { +type mockConstructorTestingTNewRequestResolver interface { mock.TestingT Cleanup(func()) } // NewRequestResolver creates a new instance of RequestResolver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewRequestResolver(t NewRequestResolverT) *RequestResolver { +func NewRequestResolver(t mockConstructorTestingTNewRequestResolver) *RequestResolver { mock := &RequestResolver{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/rest/v1/response_handler.go b/src/testing/pkg/scan/rest/v1/response_handler.go index 4b05f5cd6..2f7dff7c6 100644 --- a/src/testing/pkg/scan/rest/v1/response_handler.go +++ b/src/testing/pkg/scan/rest/v1/response_handler.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package v1 @@ -36,13 +36,13 @@ func (_m *responseHandler) Execute(code int, resp *http.Response) ([]byte, error return r0, r1 } -type newResponseHandlerT interface { +type mockConstructorTestingTnewResponseHandler interface { mock.TestingT Cleanup(func()) } // newResponseHandler creates a new instance of responseHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func newResponseHandler(t newResponseHandlerT) *responseHandler { +func newResponseHandler(t mockConstructorTestingTnewResponseHandler) *responseHandler { mock := &responseHandler{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scan/scanner/manager.go b/src/testing/pkg/scan/scanner/manager.go index 94760853b..256893c47 100644 --- a/src/testing/pkg/scan/scanner/manager.go +++ b/src/testing/pkg/scan/scanner/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scanner @@ -169,13 +169,13 @@ func (_m *Manager) Update(ctx context.Context, registration *daoscanner.Registra return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/scheduler/scheduler.go b/src/testing/pkg/scheduler/scheduler.go index 198633daf..608eda008 100644 --- a/src/testing/pkg/scheduler/scheduler.go +++ b/src/testing/pkg/scheduler/scheduler.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package scheduler @@ -111,13 +111,13 @@ func (_m *Scheduler) UnScheduleByVendor(ctx context.Context, vendorType string, return r0 } -type NewSchedulerT interface { +type mockConstructorTestingTNewScheduler interface { mock.TestingT Cleanup(func()) } // NewScheduler creates a new instance of Scheduler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewScheduler(t NewSchedulerT) *Scheduler { +func NewScheduler(t mockConstructorTestingTNewScheduler) *Scheduler { mock := &Scheduler{} mock.Mock.Test(t) diff --git a/src/testing/pkg/systemartifact/cleanup/selector.go b/src/testing/pkg/systemartifact/cleanup/selector.go index 407e266c9..8edf38691 100644 --- a/src/testing/pkg/systemartifact/cleanup/selector.go +++ b/src/testing/pkg/systemartifact/cleanup/selector.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package cleanup @@ -62,13 +62,13 @@ func (_m *Selector) ListWithFilters(ctx context.Context, query *q.Query) ([]*mod return r0, r1 } -type NewSelectorT interface { +type mockConstructorTestingTNewSelector interface { mock.TestingT Cleanup(func()) } // NewSelector creates a new instance of Selector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewSelector(t NewSelectorT) *Selector { +func NewSelector(t mockConstructorTestingTNewSelector) *Selector { mock := &Selector{} mock.Mock.Test(t) diff --git a/src/testing/pkg/systemartifact/dao/dao.go b/src/testing/pkg/systemartifact/dao/dao.go index 8d1aa7b78..8692f77c3 100644 --- a/src/testing/pkg/systemartifact/dao/dao.go +++ b/src/testing/pkg/systemartifact/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -119,13 +119,13 @@ func (_m *DAO) Size(ctx context.Context) (int64, error) { return r0, r1 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/systemartifact/manager.go b/src/testing/pkg/systemartifact/manager.go index cd69feefc..819356b5d 100644 --- a/src/testing/pkg/systemartifact/manager.go +++ b/src/testing/pkg/systemartifact/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package systemartifact @@ -183,13 +183,13 @@ func (_m *Manager) RegisterCleanupCriteria(vendor string, artifactType string, c _m.Called(vendor, artifactType, criteria) } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/task/execution_manager.go b/src/testing/pkg/task/execution_manager.go index 40687925c..3b40d9660 100644 --- a/src/testing/pkg/task/execution_manager.go +++ b/src/testing/pkg/task/execution_manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package task @@ -211,13 +211,13 @@ func (_m *ExecutionManager) UpdateExtraAttrs(ctx context.Context, id int64, extr return r0 } -type NewExecutionManagerT interface { +type mockConstructorTestingTNewExecutionManager interface { mock.TestingT Cleanup(func()) } // NewExecutionManager creates a new instance of ExecutionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewExecutionManager(t NewExecutionManagerT) *ExecutionManager { +func NewExecutionManager(t mockConstructorTestingTNewExecutionManager) *ExecutionManager { mock := &ExecutionManager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/task/manager.go b/src/testing/pkg/task/manager.go index 69f9b1b1b..d7a8eb4c4 100644 --- a/src/testing/pkg/task/manager.go +++ b/src/testing/pkg/task/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package task @@ -162,13 +162,13 @@ func (_m *Manager) UpdateExtraAttrs(ctx context.Context, id int64, extraAttrs ma return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t) diff --git a/src/testing/pkg/user/dao/dao.go b/src/testing/pkg/user/dao/dao.go index af00b5888..0d04c3ecc 100644 --- a/src/testing/pkg/user/dao/dao.go +++ b/src/testing/pkg/user/dao/dao.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package dao @@ -117,13 +117,13 @@ func (_m *DAO) Update(ctx context.Context, user *models.User, props ...string) e return r0 } -type NewDAOT interface { +type mockConstructorTestingTNewDAO interface { mock.TestingT Cleanup(func()) } // NewDAO creates a new instance of DAO. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewDAO(t NewDAOT) *DAO { +func NewDAO(t mockConstructorTestingTNewDAO) *DAO { mock := &DAO{} mock.Mock.Test(t) diff --git a/src/testing/pkg/user/manager.go b/src/testing/pkg/user/manager.go index 708af1f4a..a00154556 100644 --- a/src/testing/pkg/user/manager.go +++ b/src/testing/pkg/user/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.12.3. DO NOT EDIT. +// Code generated by mockery v2.14.0. DO NOT EDIT. package user @@ -258,13 +258,13 @@ func (_m *Manager) UpdateProfile(ctx context.Context, _a1 *commonmodels.User, co return r0 } -type NewManagerT interface { +type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) } // 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. -func NewManager(t NewManagerT) *Manager { +func NewManager(t mockConstructorTestingTNewManager) *Manager { mock := &Manager{} mock.Mock.Test(t)