Model.go

// Code generated by mockery v1.0.0. DO NOT EDIT.

package mocks

import (
	context "context"

	domain "github.com/FleekHQ/space-daemon/core/space/domain"
	mock "github.com/stretchr/testify/mock"

	model "github.com/FleekHQ/space-daemon/core/textile/model"
)

// Model is an autogenerated mock type for the Model type
type Model struct {
	mock.Mock
}

// BucketBackupToggle provides a mock function with given fields: ctx, bucketSlug, backup
func (_m *Model) BucketBackupToggle(ctx context.Context, bucketSlug string, backup bool) (*model.BucketSchema, error) {
	ret := _m.Called(ctx, bucketSlug, backup)

	var r0 *model.BucketSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) *model.BucketSchema); ok {
		r0 = rf(ctx, bucketSlug, backup)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.BucketSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = rf(ctx, bucketSlug, backup)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateBucket provides a mock function with given fields: ctx, bucketSlug, dbID
func (_m *Model) CreateBucket(ctx context.Context, bucketSlug string, dbID string) (*model.BucketSchema, error) {
	ret := _m.Called(ctx, bucketSlug, dbID)

	var r0 *model.BucketSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *model.BucketSchema); ok {
		r0 = rf(ctx, bucketSlug, dbID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.BucketSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, bucketSlug, dbID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateMirrorBucket provides a mock function with given fields: ctx, bucketSlug, mirrorBucket
func (_m *Model) CreateMirrorBucket(ctx context.Context, bucketSlug string, mirrorBucket *model.MirrorBucketSchema) (*model.BucketSchema, error) {
	ret := _m.Called(ctx, bucketSlug, mirrorBucket)

	var r0 *model.BucketSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, *model.MirrorBucketSchema) *model.BucketSchema); ok {
		r0 = rf(ctx, bucketSlug, mirrorBucket)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.BucketSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, *model.MirrorBucketSchema) error); ok {
		r1 = rf(ctx, bucketSlug, mirrorBucket)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateMirrorFile provides a mock function with given fields: ctx, mirrorFile
func (_m *Model) CreateMirrorFile(ctx context.Context, mirrorFile *domain.MirrorFile) (*model.MirrorFileSchema, error) {
	ret := _m.Called(ctx, mirrorFile)

	var r0 *model.MirrorFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, *domain.MirrorFile) *model.MirrorFileSchema); ok {
		r0 = rf(ctx, mirrorFile)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MirrorFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *domain.MirrorFile) error); ok {
		r1 = rf(ctx, mirrorFile)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateReceivedFileViaInvitation provides a mock function with given fields: ctx, file, invitationId, accepted, key, sharedBy
func (_m *Model) CreateReceivedFileViaInvitation(ctx context.Context, file domain.FullPath, invitationId string, accepted bool, key []byte, sharedBy string) (*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, file, invitationId, accepted, key, sharedBy)

	var r0 *model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, domain.FullPath, string, bool, []byte, string) *model.ReceivedFileSchema); ok {
		r0 = rf(ctx, file, invitationId, accepted, key, sharedBy)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, domain.FullPath, string, bool, []byte, string) error); ok {
		r1 = rf(ctx, file, invitationId, accepted, key, sharedBy)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateReceivedFileViaPublicLink provides a mock function with given fields: ctx, ipfsHash, password, filename, filesize, accepted
func (_m *Model) CreateReceivedFileViaPublicLink(ctx context.Context, ipfsHash string, password string, filename string, filesize string, accepted bool) (*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, ipfsHash, password, filename, filesize, accepted)

	var r0 *model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, bool) *model.ReceivedFileSchema); ok {
		r0 = rf(ctx, ipfsHash, password, filename, filesize, accepted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, bool) error); ok {
		r1 = rf(ctx, ipfsHash, password, filename, filesize, accepted)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateSentFileViaInvitation provides a mock function with given fields: ctx, file, invitationId, key
func (_m *Model) CreateSentFileViaInvitation(ctx context.Context, file domain.FullPath, invitationId string, key []byte) (*model.SentFileSchema, error) {
	ret := _m.Called(ctx, file, invitationId, key)

	var r0 *model.SentFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, domain.FullPath, string, []byte) *model.SentFileSchema); ok {
		r0 = rf(ctx, file, invitationId, key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.SentFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, domain.FullPath, string, []byte) error); ok {
		r1 = rf(ctx, file, invitationId, key)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateSharedPublicKey provides a mock function with given fields: ctx, pubKey
func (_m *Model) CreateSharedPublicKey(ctx context.Context, pubKey string) (*model.SharedPublicKeySchema, error) {
	ret := _m.Called(ctx, pubKey)

	var r0 *model.SharedPublicKeySchema
	if rf, ok := ret.Get(0).(func(context.Context, string) *model.SharedPublicKeySchema); ok {
		r0 = rf(ctx, pubKey)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.SharedPublicKeySchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, pubKey)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteReceivedFiles provides a mock function with given fields: ctx, paths, keys
func (_m *Model) DeleteReceivedFiles(ctx context.Context, paths []domain.FullPath, keys [][]byte) error {
	ret := _m.Called(ctx, paths, keys)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []domain.FullPath, [][]byte) error); ok {
		r0 = rf(ctx, paths, keys)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DeleteSearchIndexRecord provides a mock function with given fields: ctx, name, path, bucketSlug, dbId
func (_m *Model) DeleteSearchIndexRecord(ctx context.Context, name string, path string, bucketSlug string, dbId string) error {
	ret := _m.Called(ctx, name, path, bucketSlug, dbId)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok {
		r0 = rf(ctx, name, path, bucketSlug, dbId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// FindBucket provides a mock function with given fields: ctx, bucketSlug
func (_m *Model) FindBucket(ctx context.Context, bucketSlug string) (*model.BucketSchema, error) {
	ret := _m.Called(ctx, bucketSlug)

	var r0 *model.BucketSchema
	if rf, ok := ret.Get(0).(func(context.Context, string) *model.BucketSchema); ok {
		r0 = rf(ctx, bucketSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.BucketSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, bucketSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindMirrorFileByPathAndBucketSlug provides a mock function with given fields: ctx, path, bucketSlug
func (_m *Model) FindMirrorFileByPathAndBucketSlug(ctx context.Context, path string, bucketSlug string) (*model.MirrorFileSchema, error) {
	ret := _m.Called(ctx, path, bucketSlug)

	var r0 *model.MirrorFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *model.MirrorFileSchema); ok {
		r0 = rf(ctx, path, bucketSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MirrorFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, path, bucketSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindMirrorFileByPaths provides a mock function with given fields: ctx, paths
func (_m *Model) FindMirrorFileByPaths(ctx context.Context, paths []string) (map[string]*model.MirrorFileSchema, error) {
	ret := _m.Called(ctx, paths)

	var r0 map[string]*model.MirrorFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, []string) map[string]*model.MirrorFileSchema); ok {
		r0 = rf(ctx, paths)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*model.MirrorFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, paths)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindPublicLinkReceivedFile provides a mock function with given fields: ctx, ipfsHash
func (_m *Model) FindPublicLinkReceivedFile(ctx context.Context, ipfsHash string) (*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, ipfsHash)

	var r0 *model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string) *model.ReceivedFileSchema); ok {
		r0 = rf(ctx, ipfsHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, ipfsHash)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindReceivedFile provides a mock function with given fields: ctx, remoteDbID, bucket, path
func (_m *Model) FindReceivedFile(ctx context.Context, remoteDbID string, bucket string, path string) (*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, remoteDbID, bucket, path)

	var r0 *model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *model.ReceivedFileSchema); ok {
		r0 = rf(ctx, remoteDbID, bucket, path)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, remoteDbID, bucket, path)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindReceivedFilesByIds provides a mock function with given fields: ctx, ids
func (_m *Model) FindReceivedFilesByIds(ctx context.Context, ids []string) ([]*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, ids)

	var r0 []*model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, []string) []*model.ReceivedFileSchema); ok {
		r0 = rf(ctx, ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindSentFile provides a mock function with given fields: ctx, remoteDbID, bucket, path
func (_m *Model) FindSentFile(ctx context.Context, remoteDbID string, bucket string, path string) (*model.SentFileSchema, error) {
	ret := _m.Called(ctx, remoteDbID, bucket, path)

	var r0 *model.SentFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *model.SentFileSchema); ok {
		r0 = rf(ctx, remoteDbID, bucket, path)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.SentFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, remoteDbID, bucket, path)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// InitSearchIndexCollection provides a mock function with given fields: ctx
func (_m *Model) InitSearchIndexCollection(ctx context.Context) error {
	ret := _m.Called(ctx)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListBuckets provides a mock function with given fields: ctx
func (_m *Model) ListBuckets(ctx context.Context) ([]*model.BucketSchema, error) {
	ret := _m.Called(ctx)

	var r0 []*model.BucketSchema
	if rf, ok := ret.Get(0).(func(context.Context) []*model.BucketSchema); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.BucketSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListReceivedFiles provides a mock function with given fields: ctx, accepted, seek, limit
func (_m *Model) ListReceivedFiles(ctx context.Context, accepted bool, seek string, limit int) ([]*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, accepted, seek, limit)

	var r0 []*model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, bool, string, int) []*model.ReceivedFileSchema); ok {
		r0 = rf(ctx, accepted, seek, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, bool, string, int) error); ok {
		r1 = rf(ctx, accepted, seek, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListReceivedPublicFiles provides a mock function with given fields: ctx, cidHash, accepted
func (_m *Model) ListReceivedPublicFiles(ctx context.Context, cidHash string, accepted bool) ([]*model.ReceivedFileSchema, error) {
	ret := _m.Called(ctx, cidHash, accepted)

	var r0 []*model.ReceivedFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) []*model.ReceivedFileSchema); ok {
		r0 = rf(ctx, cidHash, accepted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.ReceivedFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = rf(ctx, cidHash, accepted)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSentFiles provides a mock function with given fields: ctx, seek, limit
func (_m *Model) ListSentFiles(ctx context.Context, seek string, limit int) ([]*model.SentFileSchema, error) {
	ret := _m.Called(ctx, seek, limit)

	var r0 []*model.SentFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, int) []*model.SentFileSchema); ok {
		r0 = rf(ctx, seek, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.SentFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
		r1 = rf(ctx, seek, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSharedPublicKeys provides a mock function with given fields: ctx
func (_m *Model) ListSharedPublicKeys(ctx context.Context) ([]*model.SharedPublicKeySchema, error) {
	ret := _m.Called(ctx)

	var r0 []*model.SharedPublicKeySchema
	if rf, ok := ret.Get(0).(func(context.Context) []*model.SharedPublicKeySchema); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.SharedPublicKeySchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QuerySearchIndex provides a mock function with given fields: ctx, query
func (_m *Model) QuerySearchIndex(ctx context.Context, query string) ([]*model.SearchIndexRecord, error) {
	ret := _m.Called(ctx, query)

	var r0 []*model.SearchIndexRecord
	if rf, ok := ret.Get(0).(func(context.Context, string) []*model.SearchIndexRecord); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.SearchIndexRecord)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateMirrorFile provides a mock function with given fields: ctx, mirrorFile
func (_m *Model) UpdateMirrorFile(ctx context.Context, mirrorFile *model.MirrorFileSchema) (*model.MirrorFileSchema, error) {
	ret := _m.Called(ctx, mirrorFile)

	var r0 *model.MirrorFileSchema
	if rf, ok := ret.Get(0).(func(context.Context, *model.MirrorFileSchema) *model.MirrorFileSchema); ok {
		r0 = rf(ctx, mirrorFile)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MirrorFileSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *model.MirrorFileSchema) error); ok {
		r1 = rf(ctx, mirrorFile)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSearchIndexRecord provides a mock function with given fields: ctx, name, path, itemType, bucketSlug, dbId
func (_m *Model) UpdateSearchIndexRecord(ctx context.Context, name string, path string, itemType model.SearchItemType, bucketSlug string, dbId string) (*model.SearchIndexRecord, error) {
	ret := _m.Called(ctx, name, path, itemType, bucketSlug, dbId)

	var r0 *model.SearchIndexRecord
	if rf, ok := ret.Get(0).(func(context.Context, string, string, model.SearchItemType, string, string) *model.SearchIndexRecord); ok {
		r0 = rf(ctx, name, path, itemType, bucketSlug, dbId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.SearchIndexRecord)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, model.SearchItemType, string, string) error); ok {
		r1 = rf(ctx, name, path, itemType, bucketSlug, dbId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpsertBucket provides a mock function with given fields: ctx, bucketSlug, dbID
func (_m *Model) UpsertBucket(ctx context.Context, bucketSlug string, dbID string) (*model.BucketSchema, error) {
	ret := _m.Called(ctx, bucketSlug, dbID)

	var r0 *model.BucketSchema
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *model.BucketSchema); ok {
		r0 = rf(ctx, bucketSlug, dbID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.BucketSchema)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, bucketSlug, dbID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}