repository.go

// Code generated by MockGen. DO NOT EDIT.
// Source: oras.land/oras-go/v2/registry (interfaces: Repository)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	io "io"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v1 "github.com/opencontainers/image-spec/specs-go/v1"
	registry "oras.land/oras-go/v2/registry"
)

// MockRepository is a mock of Repository interface.
type MockRepository struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryMockRecorder
}

// MockRepositoryMockRecorder is the mock recorder for MockRepository.
type MockRepositoryMockRecorder struct {
	mock *MockRepository
}

// NewMockRepository creates a new mock instance.
func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
	mock := &MockRepository{ctrl: ctrl}
	mock.recorder = &MockRepositoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
	return m.recorder
}

// Blobs mocks base method.
func (m *MockRepository) Blobs() registry.BlobStore {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Blobs")
	ret0, _ := ret[0].(registry.BlobStore)
	return ret0
}

// Blobs indicates an expected call of Blobs.
func (mr *MockRepositoryMockRecorder) Blobs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Blobs", reflect.TypeOf((*MockRepository)(nil).Blobs))
}

// Delete mocks base method.
func (m *MockRepository) Delete(arg0 context.Context, arg1 v1.Descriptor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockRepositoryMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), arg0, arg1)
}

// Exists mocks base method.
func (m *MockRepository) Exists(arg0 context.Context, arg1 v1.Descriptor) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exists indicates an expected call of Exists.
func (mr *MockRepositoryMockRecorder) Exists(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockRepository)(nil).Exists), arg0, arg1)
}

// Fetch mocks base method.
func (m *MockRepository) Fetch(arg0 context.Context, arg1 v1.Descriptor) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fetch indicates an expected call of Fetch.
func (mr *MockRepositoryMockRecorder) Fetch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockRepository)(nil).Fetch), arg0, arg1)
}

// FetchReference mocks base method.
func (m *MockRepository) FetchReference(arg0 context.Context, arg1 string) (v1.Descriptor, io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchReference", arg0, arg1)
	ret0, _ := ret[0].(v1.Descriptor)
	ret1, _ := ret[1].(io.ReadCloser)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchReference indicates an expected call of FetchReference.
func (mr *MockRepositoryMockRecorder) FetchReference(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchReference", reflect.TypeOf((*MockRepository)(nil).FetchReference), arg0, arg1)
}

// Manifests mocks base method.
func (m *MockRepository) Manifests() registry.ManifestStore {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Manifests")
	ret0, _ := ret[0].(registry.ManifestStore)
	return ret0
}

// Manifests indicates an expected call of Manifests.
func (mr *MockRepositoryMockRecorder) Manifests() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Manifests", reflect.TypeOf((*MockRepository)(nil).Manifests))
}

// Push mocks base method.
func (m *MockRepository) Push(arg0 context.Context, arg1 v1.Descriptor, arg2 io.Reader) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Push", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Push indicates an expected call of Push.
func (mr *MockRepositoryMockRecorder) Push(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockRepository)(nil).Push), arg0, arg1, arg2)
}

// PushReference mocks base method.
func (m *MockRepository) PushReference(arg0 context.Context, arg1 v1.Descriptor, arg2 io.Reader, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushReference", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// PushReference indicates an expected call of PushReference.
func (mr *MockRepositoryMockRecorder) PushReference(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushReference", reflect.TypeOf((*MockRepository)(nil).PushReference), arg0, arg1, arg2, arg3)
}

// Referrers mocks base method.
func (m *MockRepository) Referrers(arg0 context.Context, arg1 v1.Descriptor, arg2 string, arg3 func([]v1.Descriptor) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Referrers", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Referrers indicates an expected call of Referrers.
func (mr *MockRepositoryMockRecorder) Referrers(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Referrers", reflect.TypeOf((*MockRepository)(nil).Referrers), arg0, arg1, arg2, arg3)
}

// Resolve mocks base method.
func (m *MockRepository) Resolve(arg0 context.Context, arg1 string) (v1.Descriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resolve", arg0, arg1)
	ret0, _ := ret[0].(v1.Descriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resolve indicates an expected call of Resolve.
func (mr *MockRepositoryMockRecorder) Resolve(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockRepository)(nil).Resolve), arg0, arg1)
}

// Tag mocks base method.
func (m *MockRepository) Tag(arg0 context.Context, arg1 v1.Descriptor, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tag", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Tag indicates an expected call of Tag.
func (mr *MockRepositoryMockRecorder) Tag(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockRepository)(nil).Tag), arg0, arg1, arg2)
}

// Tags mocks base method.
func (m *MockRepository) Tags(arg0 context.Context, arg1 string, arg2 func([]string) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tags", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Tags indicates an expected call of Tags.
func (mr *MockRepositoryMockRecorder) Tags(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tags", reflect.TypeOf((*MockRepository)(nil).Tags), arg0, arg1, arg2)
}