From 9b22e2943f336146d2383024ce5557a773acc701 Mon Sep 17 00:00:00 2001 From: MinerYang Date: Tue, 7 Jun 2022 16:04:33 +0800 Subject: [PATCH] bumpup mockery to v1.12.3 (#16955) Signed-off-by: yminer Co-authored-by: yminer --- Makefile | 2 +- .../flow/mock_adapter_factory_test.go | 17 ++++++++++++++++- .../replication/flow/mock_adapter_test.go | 17 ++++++++++++++++- .../replication/mock_flow_controller_test.go | 17 ++++++++++++++++- src/jobservice/mgt/mock_manager.go | 17 ++++++++++++++++- src/jobservice/period/mock_scheduler.go | 17 ++++++++++++++++- src/pkg/scheduler/mock_dao_test.go | 17 ++++++++++++++++- src/pkg/task/mock_execution_dao_test.go | 17 ++++++++++++++++- src/pkg/task/mock_jobservice_client_test.go | 17 ++++++++++++++++- src/pkg/task/mock_task_dao_test.go | 17 ++++++++++++++++- src/pkg/task/mock_task_manager_test.go | 17 ++++++++++++++++- src/testing/common/security/context.go | 17 ++++++++++++++++- src/testing/controller/artifact/controller.go | 17 ++++++++++++++++- src/testing/controller/blob/controller.go | 17 ++++++++++++++++- src/testing/controller/config/controller.go | 17 ++++++++++++++++- .../jobservice/scheduler_controller.go | 17 ++++++++++++++++- src/testing/controller/project/controller.go | 17 ++++++++++++++++- .../controller/proxy/remote_interface.go | 17 ++++++++++++++++- src/testing/controller/purge/controller.go | 17 ++++++++++++++++- src/testing/controller/quota/controller.go | 17 ++++++++++++++++- .../controller/replication/controller.go | 17 ++++++++++++++++- src/testing/controller/repository/controller.go | 17 ++++++++++++++++- src/testing/controller/retention/controller.go | 17 ++++++++++++++++- src/testing/controller/robot/controller.go | 17 ++++++++++++++++- src/testing/controller/scan/checker.go | 17 ++++++++++++++++- src/testing/controller/scan/controller.go | 17 ++++++++++++++++- src/testing/controller/scanner/controller.go | 17 ++++++++++++++++- src/testing/controller/user/controller.go | 17 ++++++++++++++++- src/testing/lib/cache/cache.go | 17 ++++++++++++++++- src/testing/lib/orm/creator.go | 17 ++++++++++++++++- src/testing/pkg/accessory/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/accessory/manager.go | 17 ++++++++++++++++- src/testing/pkg/accessory/model/accessory.go | 17 ++++++++++++++++- src/testing/pkg/allowlist/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/allowlist/manager.go | 17 ++++++++++++++++- src/testing/pkg/artifact/manager.go | 17 ++++++++++++++++- src/testing/pkg/audit/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/audit/manager.go | 17 ++++++++++++++++- src/testing/pkg/blob/manager.go | 17 ++++++++++++++++- .../pkg/cached/manifest/redis/cached_manager.go | 17 ++++++++++++++++- src/testing/pkg/distribution/manifest.go | 17 ++++++++++++++++- src/testing/pkg/immutable/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/joblog/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/joblog/manager.go | 17 ++++++++++++++++- src/testing/pkg/label/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/label/manager.go | 17 ++++++++++++++++- src/testing/pkg/ldap/manager.go | 17 ++++++++++++++++- src/testing/pkg/notification/job/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/notification/policy/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/notification/policy/manager.go | 17 ++++++++++++++++- src/testing/pkg/oidc/dao/meta_dao.go | 17 ++++++++++++++++- src/testing/pkg/oidc/meta_manager.go | 17 ++++++++++++++++- src/testing/pkg/project/manager.go | 17 ++++++++++++++++- src/testing/pkg/project/metadata/manager.go | 17 ++++++++++++++++- src/testing/pkg/quota/driver/driver.go | 17 ++++++++++++++++- src/testing/pkg/quota/manager.go | 17 ++++++++++++++++- src/testing/pkg/rbac/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/rbac/manager.go | 17 ++++++++++++++++- src/testing/pkg/reg/adapter/adapter.go | 17 ++++++++++++++++- src/testing/pkg/reg/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/reg/manager.go | 17 ++++++++++++++++- src/testing/pkg/replication/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/replication/manager.go | 17 ++++++++++++++++- src/testing/pkg/repository/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/repository/manager.go | 17 ++++++++++++++++- src/testing/pkg/robot/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/robot/manager.go | 17 ++++++++++++++++- src/testing/pkg/scan/report/manager.go | 17 ++++++++++++++++- src/testing/pkg/scan/rest/v1/client.go | 17 ++++++++++++++++- src/testing/pkg/scan/rest/v1/client_pool.go | 17 ++++++++++++++++- .../pkg/scan/rest/v1/request_resolver.go | 17 ++++++++++++++++- .../pkg/scan/rest/v1/response_handler.go | 17 ++++++++++++++++- src/testing/pkg/scan/scanner/manager.go | 17 ++++++++++++++++- src/testing/pkg/scheduler/scheduler.go | 17 ++++++++++++++++- .../pkg/systemartifact/cleanup/selector.go | 17 ++++++++++++++++- src/testing/pkg/systemartifact/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/systemartifact/manager.go | 17 ++++++++++++++++- src/testing/pkg/task/execution_manager.go | 17 ++++++++++++++++- src/testing/pkg/task/manager.go | 17 ++++++++++++++++- src/testing/pkg/user/dao/dao.go | 17 ++++++++++++++++- src/testing/pkg/user/manager.go | 17 ++++++++++++++++- 81 files changed, 1281 insertions(+), 81 deletions(-) diff --git a/Makefile b/Makefile index 86f04d893..23375ed93 100644 --- a/Makefile +++ b/Makefile @@ -346,7 +346,7 @@ gen_apis: lint_apis MOCKERY_IMAGENAME=$(IMAGENAMESPACE)/mockery -MOCKERY_VERSION=v2.1.0 +MOCKERY_VERSION=v2.12.3 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 6a01c26bb..884a0bc46 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package flow @@ -52,3 +52,18 @@ func (_m *mockFactory) Create(_a0 *model.Registry) (adapter.Adapter, error) { return r0, r1 } + +type newMockFactoryT 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 { + mock := &mockFactory{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/controller/replication/flow/mock_adapter_test.go b/src/controller/replication/flow/mock_adapter_test.go index 810e4c8c6..ffe0fb5f5 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package flow @@ -343,3 +343,18 @@ func (_m *mockAdapter) PushManifest(repository string, reference string, mediaTy return r0, r1 } + +type newMockAdapterT 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 { + mock := &mockAdapter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/controller/replication/mock_flow_controller_test.go b/src/controller/replication/mock_flow_controller_test.go index d678fe4ac..a999374ab 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package replication @@ -30,3 +30,18 @@ func (_m *flowController) Start(ctx context.Context, executionID int64, policy * return r0 } + +type newFlowControllerT 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 { + mock := &flowController{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/jobservice/mgt/mock_manager.go b/src/jobservice/mgt/mock_manager.go index 73fb5e908..41f2d4965 100644 --- a/src/jobservice/mgt/mock_manager.go +++ b/src/jobservice/mgt/mock_manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package mgt @@ -140,3 +140,18 @@ func (_m *MockManager) SaveJob(_a0 *job.Stats) error { return r0 } + +type NewMockManagerT 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 { + mock := &MockManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/jobservice/period/mock_scheduler.go b/src/jobservice/period/mock_scheduler.go index 1477cca56..107bf5de4 100644 --- a/src/jobservice/period/mock_scheduler.go +++ b/src/jobservice/period/mock_scheduler.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package period @@ -48,3 +48,18 @@ func (_m *MockScheduler) UnSchedule(policyID string) error { return r0 } + +type NewMockSchedulerT 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 { + mock := &MockScheduler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/pkg/scheduler/mock_dao_test.go b/src/pkg/scheduler/mock_dao_test.go index d599ade8f..b93c53fbf 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package scheduler @@ -136,3 +136,18 @@ func (_m *mockDAO) UpdateRevision(ctx context.Context, id int64, revision int64) return r0, r1 } + +type newMockDAOT 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 { + mock := &mockDAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/pkg/task/mock_execution_dao_test.go b/src/pkg/task/mock_execution_dao_test.go index 827466340..57eb1d8bf 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package task @@ -189,3 +189,18 @@ func (_m *mockExecutionDAO) Update(ctx context.Context, execution *dao.Execution return r0 } + +type newMockExecutionDAOT 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 { + mock := &mockExecutionDAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/pkg/task/mock_jobservice_client_test.go b/src/pkg/task/mock_jobservice_client_test.go index c2860e81f..4191321cc 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package task @@ -94,3 +94,18 @@ func (_m *mockJobserviceClient) SubmitJob(_a0 *models.JobData) (string, error) { return r0, r1 } + +type newMockJobserviceClientT 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 { + mock := &mockJobserviceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/pkg/task/mock_task_dao_test.go b/src/pkg/task/mock_task_dao_test.go index 918799625..f06edda7c 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package task @@ -198,3 +198,18 @@ func (_m *mockTaskDAO) UpdateStatus(ctx context.Context, id int64, status string return r0 } + +type newMockTaskDAOT 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 { + mock := &mockTaskDAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/pkg/task/mock_task_manager_test.go b/src/pkg/task/mock_task_manager_test.go index ecaaa74b1..6e8ed032d 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package task @@ -159,3 +159,18 @@ func (_m *mockTaskManager) UpdateExtraAttrs(ctx context.Context, id int64, extra return r0 } + +type newMockTaskManagerT 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 { + mock := &mockTaskManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/common/security/context.go b/src/testing/common/security/context.go index ce2646957..50425cfb7 100644 --- a/src/testing/common/security/context.go +++ b/src/testing/common/security/context.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package security @@ -98,3 +98,18 @@ func (_m *Context) Name() string { return r0 } + +type NewContextT 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 { + mock := &Context{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/artifact/controller.go b/src/testing/controller/artifact/controller.go index 650e5b6eb..c7dae27c2 100644 --- a/src/testing/controller/artifact/controller.go +++ b/src/testing/controller/artifact/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package artifact @@ -252,3 +252,18 @@ func (_m *Controller) Walk(ctx context.Context, root *artifact.Artifact, walkFn return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/blob/controller.go b/src/testing/controller/blob/controller.go index dd2e350a2..4240051fc 100644 --- a/src/testing/controller/blob/controller.go +++ b/src/testing/controller/blob/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package blob @@ -334,3 +334,18 @@ func (_m *Controller) Update(ctx context.Context, _a1 *models.Blob) error { return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/config/controller.go b/src/testing/controller/config/controller.go index 91f72d8c2..2826ca67b 100644 --- a/src/testing/controller/config/controller.go +++ b/src/testing/controller/config/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package config @@ -110,3 +110,18 @@ func (_m *Controller) UserConfigs(ctx context.Context) (map[string]*models.Value return r0, r1 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/jobservice/scheduler_controller.go b/src/testing/controller/jobservice/scheduler_controller.go index 49351ab74..d890bab71 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package jobservice @@ -72,3 +72,18 @@ func (_m *SchedulerController) Get(ctx context.Context, vendorType string) (*sch return r0, r1 } + +type NewSchedulerControllerT 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 { + mock := &SchedulerController{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/project/controller.go b/src/testing/controller/project/controller.go index f09270ba5..c9873562b 100644 --- a/src/testing/controller/project/controller.go +++ b/src/testing/controller/project/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package project @@ -224,3 +224,18 @@ func (_m *Controller) Update(ctx context.Context, _a1 *models.Project) error { return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/proxy/remote_interface.go b/src/testing/controller/proxy/remote_interface.go index ba231b946..f16b2e835 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package proxy @@ -127,3 +127,18 @@ func (_m *RemoteInterface) ManifestExist(repo string, ref string) (bool, *distri return r0, r1, r2 } + +type NewRemoteInterfaceT 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 { + mock := &RemoteInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/purge/controller.go b/src/testing/controller/purge/controller.go index 7a5f1e532..9354880cc 100644 --- a/src/testing/controller/purge/controller.go +++ b/src/testing/controller/purge/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package purge @@ -34,3 +34,18 @@ func (_m *Controller) Start(ctx context.Context, policy purge.JobPolicy, trigger return r0, r1 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/quota/controller.go b/src/testing/controller/quota/controller.go index 11d8c4419..3995acb56 100644 --- a/src/testing/controller/quota/controller.go +++ b/src/testing/controller/quota/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package quota @@ -242,3 +242,18 @@ func (_m *Controller) Update(ctx context.Context, _a1 *models.Quota) error { return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/replication/controller.go b/src/testing/controller/replication/controller.go index 6461fe3ac..ec5fd044d 100644 --- a/src/testing/controller/replication/controller.go +++ b/src/testing/controller/replication/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package replication @@ -334,3 +334,18 @@ func (_m *Controller) UpdatePolicy(ctx context.Context, policy *model.Policy, pr return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/repository/controller.go b/src/testing/controller/repository/controller.go index 0ea05f55f..27d4118ae 100644 --- a/src/testing/controller/repository/controller.go +++ b/src/testing/controller/repository/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package repository @@ -182,3 +182,18 @@ func (_m *Controller) Update(ctx context.Context, _a1 *model.RepoRecord, propert return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/retention/controller.go b/src/testing/controller/retention/controller.go index 12daa4a55..6434b8253 100644 --- a/src/testing/controller/retention/controller.go +++ b/src/testing/controller/retention/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package retention @@ -281,3 +281,18 @@ func (_m *Controller) UpdateRetention(ctx context.Context, p *policy.Metadata) e return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/robot/controller.go b/src/testing/controller/robot/controller.go index c3042e47e..5c0f4a2d3 100644 --- a/src/testing/controller/robot/controller.go +++ b/src/testing/controller/robot/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package robot @@ -138,3 +138,18 @@ func (_m *Controller) Update(ctx context.Context, r *robot.Robot, option *robot. return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/scan/checker.go b/src/testing/controller/scan/checker.go index 6bba0410f..578138659 100644 --- a/src/testing/controller/scan/checker.go +++ b/src/testing/controller/scan/checker.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package scan @@ -35,3 +35,18 @@ func (_m *Checker) IsScannable(ctx context.Context, _a1 *artifact.Artifact) (boo return r0, r1 } + +type NewCheckerT 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 { + mock := &Checker{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/scan/controller.go b/src/testing/controller/scan/controller.go index 1805e10f8..b60c608ac 100644 --- a/src/testing/controller/scan/controller.go +++ b/src/testing/controller/scan/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package scan @@ -189,3 +189,18 @@ func (_m *Controller) Stop(ctx context.Context, _a1 *artifact.Artifact) error { return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/scanner/controller.go b/src/testing/controller/scanner/controller.go index 5934c6225..fc11cc1a1 100644 --- a/src/testing/controller/scanner/controller.go +++ b/src/testing/controller/scanner/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package scanner @@ -262,3 +262,18 @@ func (_m *Controller) UpdateRegistration(ctx context.Context, registration *scan return r0 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/controller/user/controller.go b/src/testing/controller/user/controller.go index 46f9d121f..b85caf8b9 100644 --- a/src/testing/controller/user/controller.go +++ b/src/testing/controller/user/controller.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package user @@ -293,3 +293,18 @@ func (_m *Controller) VerifyPassword(ctx context.Context, usernameOrEmail string return r0, r1 } + +type NewControllerT 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 { + mock := &Controller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/lib/cache/cache.go b/src/testing/lib/cache/cache.go index 803b6851c..9faadf8bf 100644 --- a/src/testing/lib/cache/cache.go +++ b/src/testing/lib/cache/cache.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package cache @@ -120,3 +120,18 @@ func (_m *Cache) Save(ctx context.Context, key string, value interface{}, expira return r0 } + +type NewCacheT 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 { + mock := &Cache{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/lib/orm/creator.go b/src/testing/lib/orm/creator.go index ea442ea60..012e032eb 100644 --- a/src/testing/lib/orm/creator.go +++ b/src/testing/lib/orm/creator.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package orm @@ -27,3 +27,18 @@ func (_m *Creator) Create() orm.Ormer { return r0 } + +type NewCreatorT 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 { + mock := &Creator{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/accessory/dao/dao.go b/src/testing/pkg/accessory/dao/dao.go index 4a5d91d34..ff2f7bf20 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -138,3 +138,18 @@ func (_m *DAO) List(ctx context.Context, query *q.Query) ([]*dao.Accessory, erro return r0, r1 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/accessory/manager.go b/src/testing/pkg/accessory/manager.go index c6833afc6..a58820dce 100644 --- a/src/testing/pkg/accessory/manager.go +++ b/src/testing/pkg/accessory/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package accessory @@ -145,3 +145,18 @@ func (_m *Manager) List(ctx context.Context, query *q.Query) ([]model.Accessory, return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/accessory/model/accessory.go b/src/testing/pkg/accessory/model/accessory.go index 140c7a4ce..e3c258ed2 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package model @@ -81,3 +81,18 @@ func (_m *Accessory) Kind() string { return r0 } + +type NewAccessoryT 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 { + mock := &Accessory{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/allowlist/dao/dao.go b/src/testing/pkg/allowlist/dao/dao.go index bc12fe323..93c0724be 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -58,3 +58,18 @@ func (_m *DAO) Set(ctx context.Context, l models.CVEAllowlist) (int64, error) { return r0, r1 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/allowlist/manager.go b/src/testing/pkg/allowlist/manager.go index ffa3e5cee..0365d8c0b 100644 --- a/src/testing/pkg/allowlist/manager.go +++ b/src/testing/pkg/allowlist/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package robot @@ -101,3 +101,18 @@ func (_m *Manager) SetSys(ctx context.Context, list models.CVEAllowlist) error { return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/artifact/manager.go b/src/testing/pkg/artifact/manager.go index 20d746c31..88995c121 100644 --- a/src/testing/pkg/artifact/manager.go +++ b/src/testing/pkg/artifact/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package artifact @@ -215,3 +215,18 @@ func (_m *Manager) UpdatePullTime(ctx context.Context, id int64, pullTime time.T return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/audit/dao/dao.go b/src/testing/pkg/audit/dao/dao.go index ee4181e01..0e68519aa 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -139,3 +139,18 @@ func (_m *DAO) Purge(ctx context.Context, retentionHour int, includeOperations [ return r0, r1 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/audit/manager.go b/src/testing/pkg/audit/manager.go index 877cf0c04..2db286eec 100644 --- a/src/testing/pkg/audit/manager.go +++ b/src/testing/pkg/audit/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package audit @@ -138,3 +138,18 @@ func (_m *Manager) Purge(ctx context.Context, retentionHour int, includeOperatio return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/blob/manager.go b/src/testing/pkg/blob/manager.go index 342b33669..8a894a7e1 100644 --- a/src/testing/pkg/blob/manager.go +++ b/src/testing/pkg/blob/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package blob @@ -312,3 +312,18 @@ func (_m *Manager) UselessBlobs(ctx context.Context, timeWindowHours int64) ([]* return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/cached/manifest/redis/cached_manager.go b/src/testing/pkg/cached/manifest/redis/cached_manager.go index 8e9bd842d..72c592a0e 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package redis @@ -126,3 +126,18 @@ func (_m *CachedManager) Save(ctx context.Context, digest string, manifest []byt return r0 } + +type NewCachedManagerT 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 { + mock := &CachedManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/distribution/manifest.go b/src/testing/pkg/distribution/manifest.go index ba560daf5..e0603956c 100644 --- a/src/testing/pkg/distribution/manifest.go +++ b/src/testing/pkg/distribution/manifest.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package distribution @@ -57,3 +57,18 @@ func (_m *Manifest) References() []distribution.Descriptor { return r0 } + +type NewManifestT 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 { + mock := &Manifest{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/immutable/dao/dao.go b/src/testing/pkg/immutable/dao/dao.go index e9e9734b2..24538ef48 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -146,3 +146,18 @@ func (_m *DAO) UpdateImmutableRule(ctx context.Context, projectID int64, ir *mod return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/joblog/dao/dao.go b/src/testing/pkg/joblog/dao/dao.go index ceab3332a..699d327d1 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -81,3 +81,18 @@ func (_m *DAO) Get(ctx context.Context, uuid string) (*models.JobLog, error) { return r0, r1 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/joblog/manager.go b/src/testing/pkg/joblog/manager.go index 8f6e9b877..d1dbe2338 100644 --- a/src/testing/pkg/joblog/manager.go +++ b/src/testing/pkg/joblog/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package joblog @@ -81,3 +81,18 @@ func (_m *Manager) Get(ctx context.Context, uuid string) (*models.JobLog, error) return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/label/dao/dao.go b/src/testing/pkg/label/dao/dao.go index c40cded2a..5fefa5acd 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -211,3 +211,18 @@ func (_m *DAO) Update(ctx context.Context, label *model.Label) error { return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/label/manager.go b/src/testing/pkg/label/manager.go index 69b34d90d..61b0c29e3 100644 --- a/src/testing/pkg/label/manager.go +++ b/src/testing/pkg/label/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package label @@ -211,3 +211,18 @@ func (_m *Manager) Update(ctx context.Context, _a1 *model.Label) error { return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/ldap/manager.go b/src/testing/pkg/ldap/manager.go index 2d79817b4..9daa4d53c 100644 --- a/src/testing/pkg/ldap/manager.go +++ b/src/testing/pkg/ldap/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package ldap @@ -107,3 +107,18 @@ func (_m *Manager) SearchUser(ctx context.Context, sess *ldap.Session, username return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/notification/job/dao/dao.go b/src/testing/pkg/notification/job/dao/dao.go index ce8063240..9817045ff 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -176,3 +176,18 @@ func (_m *DAO) Update(ctx context.Context, n *model.Job, props ...string) error return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/notification/policy/dao/dao.go b/src/testing/pkg/notification/policy/dao/dao.go index ed875efc5..158590766 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -132,3 +132,18 @@ func (_m *DAO) Update(ctx context.Context, n *model.Policy) error { return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/notification/policy/manager.go b/src/testing/pkg/notification/policy/manager.go index ff9073fca..a0e497b72 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package notification @@ -191,3 +191,18 @@ func (_m *Manager) Update(ctx context.Context, _a1 *model.Policy) error { return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/oidc/dao/meta_dao.go b/src/testing/pkg/oidc/dao/meta_dao.go index ab8f3efa2..6b91e7e17 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -118,3 +118,18 @@ func (_m *MetaDAO) Update(ctx context.Context, oidcUser *models.OIDCUser, props return r0 } + +type NewMetaDAOT 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 { + mock := &MetaDAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/oidc/meta_manager.go b/src/testing/pkg/oidc/meta_manager.go index b8dbf6188..31bba1ec9 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package oidc @@ -129,3 +129,18 @@ func (_m *MetaManager) Update(ctx context.Context, oidcUser *models.OIDCUser, co return r0 } + +type NewMetaManagerT 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 { + mock := &MetaManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/project/manager.go b/src/testing/pkg/project/manager.go index d6b7bba90..236a2b5ab 100644 --- a/src/testing/pkg/project/manager.go +++ b/src/testing/pkg/project/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package project @@ -147,3 +147,18 @@ func (_m *Manager) ListRoles(ctx context.Context, projectID int64, userID int, g return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/project/metadata/manager.go b/src/testing/pkg/project/metadata/manager.go index 98add736b..a92952efe 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package metadata @@ -116,3 +116,18 @@ func (_m *Manager) Update(ctx context.Context, projectID int64, meta map[string] return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/quota/driver/driver.go b/src/testing/pkg/quota/driver/driver.go index b7102309d..3b03bddcd 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package driver @@ -112,3 +112,18 @@ func (_m *Driver) Validate(hardLimits types.ResourceList) error { return r0 } + +type NewDriverT 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 { + mock := &Driver{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/quota/manager.go b/src/testing/pkg/quota/manager.go index 2682e3172..81aa5cfb3 100644 --- a/src/testing/pkg/quota/manager.go +++ b/src/testing/pkg/quota/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package quota @@ -163,3 +163,18 @@ func (_m *Manager) Update(ctx context.Context, _a1 *models.Quota) error { return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/rbac/dao/dao.go b/src/testing/pkg/rbac/dao/dao.go index f0373755c..d76dafbfb 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -169,3 +169,18 @@ func (_m *DAO) ListRbacPolicies(ctx context.Context, query *q.Query) ([]*model.P return r0, r1 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/rbac/manager.go b/src/testing/pkg/rbac/manager.go index 3837ac174..493b3aeaf 100644 --- a/src/testing/pkg/rbac/manager.go +++ b/src/testing/pkg/rbac/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package rbac @@ -168,3 +168,18 @@ func (_m *Manager) ListRbacPolicies(ctx context.Context, query *q.Query) ([]*mod return r0, r1 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/reg/adapter/adapter.go b/src/testing/pkg/reg/adapter/adapter.go index b7efc71ca..b358e5527 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package adapter @@ -69,3 +69,18 @@ func (_m *Adapter) PrepareForPush(_a0 []*model.Resource) error { return r0 } + +type NewAdapterT 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 { + mock := &Adapter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/reg/dao/dao.go b/src/testing/pkg/reg/dao/dao.go index 131930b3e..4a47e22dd 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -138,3 +138,18 @@ func (_m *DAO) Update(ctx context.Context, registry *dao.Registry, props ...stri return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/reg/manager.go b/src/testing/pkg/reg/manager.go index fb2e21bfc..8c2e301dc 100644 --- a/src/testing/pkg/reg/manager.go +++ b/src/testing/pkg/reg/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package manager @@ -210,3 +210,18 @@ func (_m *Manager) Update(ctx context.Context, registry *model.Registry, props . return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/replication/dao/dao.go b/src/testing/pkg/replication/dao/dao.go index b4ac40eb9..10eba4d6a 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -139,3 +139,18 @@ func (_m *DAO) Update(ctx context.Context, policy *model.Policy, props ...string return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/replication/manager.go b/src/testing/pkg/replication/manager.go index 1600f9a3d..0f29ac5dc 100644 --- a/src/testing/pkg/replication/manager.go +++ b/src/testing/pkg/replication/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package manager @@ -138,3 +138,18 @@ func (_m *Manager) Update(ctx context.Context, policy *model.Policy, props ...st return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/repository/dao/dao.go b/src/testing/pkg/repository/dao/dao.go index 8d71d966f..3ce3aab35 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -176,3 +176,18 @@ func (_m *DAO) Update(ctx context.Context, repository *model.RepoRecord, props . return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/repository/manager.go b/src/testing/pkg/repository/manager.go index d6e4abac0..60b42d4ef 100644 --- a/src/testing/pkg/repository/manager.go +++ b/src/testing/pkg/repository/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package repository @@ -198,3 +198,18 @@ func (_m *Manager) Update(ctx context.Context, _a1 *model.RepoRecord, props ...s return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/robot/dao/dao.go b/src/testing/pkg/robot/dao/dao.go index 7376fd006..23fd9852f 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -153,3 +153,18 @@ func (_m *DAO) Update(ctx context.Context, r *model.Robot, props ...string) erro return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/robot/manager.go b/src/testing/pkg/robot/manager.go index fed171a25..55ded1750 100644 --- a/src/testing/pkg/robot/manager.go +++ b/src/testing/pkg/robot/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package robot @@ -152,3 +152,18 @@ func (_m *Manager) Update(ctx context.Context, m *model.Robot, props ...string) return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scan/report/manager.go b/src/testing/pkg/scan/report/manager.go index 4c2b28e86..016b8b6bc 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package report @@ -131,3 +131,18 @@ func (_m *Manager) UpdateReportData(ctx context.Context, uuid string, _a2 string return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scan/rest/v1/client.go b/src/testing/pkg/scan/rest/v1/client.go index c2fdb5051..befaf86d5 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package v1 @@ -78,3 +78,18 @@ func (_m *Client) SubmitScan(req *v1.ScanRequest) (*v1.ScanResponse, error) { return r0, r1 } + +type NewClientT 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 { + mock := &Client{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scan/rest/v1/client_pool.go b/src/testing/pkg/scan/rest/v1/client_pool.go index cf881eac9..93d9e0dca 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package v1 @@ -34,3 +34,18 @@ func (_m *ClientPool) Get(url string, authType string, accessCredential string, return r0, r1 } + +type NewClientPoolT 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 { + mock := &ClientPool{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scan/rest/v1/request_resolver.go b/src/testing/pkg/scan/rest/v1/request_resolver.go index 82f62e6ee..c4237bbc5 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package v1 @@ -17,3 +17,18 @@ type RequestResolver struct { func (_m *RequestResolver) Execute(req *http.Request) { _m.Called(req) } + +type NewRequestResolverT 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 { + mock := &RequestResolver{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scan/rest/v1/response_handler.go b/src/testing/pkg/scan/rest/v1/response_handler.go index a215ef3bd..4b05f5cd6 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package v1 @@ -35,3 +35,18 @@ func (_m *responseHandler) Execute(code int, resp *http.Response) ([]byte, error return r0, r1 } + +type newResponseHandlerT 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 { + mock := &responseHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scan/scanner/manager.go b/src/testing/pkg/scan/scanner/manager.go index 6f8fee63c..94760853b 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package scanner @@ -168,3 +168,18 @@ func (_m *Manager) Update(ctx context.Context, registration *daoscanner.Registra return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/scheduler/scheduler.go b/src/testing/pkg/scheduler/scheduler.go index feeb7925a..198633daf 100644 --- a/src/testing/pkg/scheduler/scheduler.go +++ b/src/testing/pkg/scheduler/scheduler.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package scheduler @@ -110,3 +110,18 @@ func (_m *Scheduler) UnScheduleByVendor(ctx context.Context, vendorType string, return r0 } + +type NewSchedulerT 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 { + mock := &Scheduler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/systemartifact/cleanup/selector.go b/src/testing/pkg/systemartifact/cleanup/selector.go index 5431c14e0..407e266c9 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package cleanup @@ -61,3 +61,18 @@ func (_m *Selector) ListWithFilters(ctx context.Context, query *q.Query) ([]*mod return r0, r1 } + +type NewSelectorT 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 { + mock := &Selector{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/systemartifact/dao/dao.go b/src/testing/pkg/systemartifact/dao/dao.go index 5587838b8..8d1aa7b78 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -118,3 +118,18 @@ func (_m *DAO) Size(ctx context.Context) (int64, error) { return r0, r1 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/systemartifact/manager.go b/src/testing/pkg/systemartifact/manager.go index 6256f275f..43a9c4522 100644 --- a/src/testing/pkg/systemartifact/manager.go +++ b/src/testing/pkg/systemartifact/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package systemartifact @@ -166,3 +166,18 @@ func (_m *Manager) Read(ctx context.Context, vendor string, repository string, d func (_m *Manager) RegisterCleanupCriteria(vendor string, artifactType string, criteria systemartifact.Selector) { _m.Called(vendor, artifactType, criteria) } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/task/execution_manager.go b/src/testing/pkg/task/execution_manager.go index 17ffac959..40687925c 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package task @@ -210,3 +210,18 @@ func (_m *ExecutionManager) UpdateExtraAttrs(ctx context.Context, id int64, extr return r0 } + +type NewExecutionManagerT 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 { + mock := &ExecutionManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/task/manager.go b/src/testing/pkg/task/manager.go index 5b6a79040..69f9b1b1b 100644 --- a/src/testing/pkg/task/manager.go +++ b/src/testing/pkg/task/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package task @@ -161,3 +161,18 @@ func (_m *Manager) UpdateExtraAttrs(ctx context.Context, id int64, extraAttrs ma return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/user/dao/dao.go b/src/testing/pkg/user/dao/dao.go index b8ffa4eb4..af00b5888 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.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package dao @@ -116,3 +116,18 @@ func (_m *DAO) Update(ctx context.Context, user *models.User, props ...string) e return r0 } + +type NewDAOT 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 { + mock := &DAO{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/src/testing/pkg/user/manager.go b/src/testing/pkg/user/manager.go index f869f1887..27ab5b028 100644 --- a/src/testing/pkg/user/manager.go +++ b/src/testing/pkg/user/manager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.1.0. DO NOT EDIT. +// Code generated by mockery v2.12.3. DO NOT EDIT. package user @@ -235,3 +235,18 @@ func (_m *Manager) UpdateProfile(ctx context.Context, _a1 *models.User, col ...s return r0 } + +type NewManagerT 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 { + mock := &Manager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}