mock_snapshots_service.go

// Copyright (c) 2021 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
// which is available at https://www.apache.org/licenses/LICENSE-2.0.
//
// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/containerd/containerd/snapshots (interfaces: Snapshotter)

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

import (
	context "context"
	reflect "reflect"

	mount "github.com/containerd/containerd/mount"
	snapshots "github.com/containerd/containerd/snapshots"
	gomock "github.com/golang/mock/gomock"
)

// MockSnapshotter is a mock of Snapshotter interface.
type MockSnapshotter struct {
	ctrl     *gomock.Controller
	recorder *MockSnapshotterMockRecorder
}

// MockSnapshotterMockRecorder is the mock recorder for MockSnapshotter.
type MockSnapshotterMockRecorder struct {
	mock *MockSnapshotter
}

// NewMockSnapshotter creates a new mock instance.
func NewMockSnapshotter(ctrl *gomock.Controller) *MockSnapshotter {
	mock := &MockSnapshotter{ctrl: ctrl}
	mock.recorder = &MockSnapshotterMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockSnapshotter) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Commit mocks base method.
func (m *MockSnapshotter) Commit(arg0 context.Context, arg1, arg2 string, arg3 ...snapshots.Opt) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Commit", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit.
func (mr *MockSnapshotterMockRecorder) Commit(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockSnapshotter)(nil).Commit), varargs...)
}

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

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

// Prepare mocks base method.
func (m *MockSnapshotter) Prepare(arg0 context.Context, arg1, arg2 string, arg3 ...snapshots.Opt) ([]mount.Mount, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Prepare", varargs...)
	ret0, _ := ret[0].([]mount.Mount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Prepare indicates an expected call of Prepare.
func (mr *MockSnapshotterMockRecorder) Prepare(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockSnapshotter)(nil).Prepare), varargs...)
}

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

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

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

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

// Update mocks base method.
func (m *MockSnapshotter) Update(arg0 context.Context, arg1 snapshots.Info, arg2 ...string) (snapshots.Info, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(snapshots.Info)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockSnapshotterMockRecorder) Update(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSnapshotter)(nil).Update), varargs...)
}

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

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

// View mocks base method.
func (m *MockSnapshotter) View(arg0 context.Context, arg1, arg2 string, arg3 ...snapshots.Opt) ([]mount.Mount, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "View", varargs...)
	ret0, _ := ret[0].([]mount.Mount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// View indicates an expected call of View.
func (mr *MockSnapshotterMockRecorder) View(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "View", reflect.TypeOf((*MockSnapshotter)(nil).View), varargs...)
}

// Walk mocks base method.
func (m *MockSnapshotter) Walk(arg0 context.Context, arg1 snapshots.WalkFunc, arg2 ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Walk", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Walk indicates an expected call of Walk.
func (mr *MockSnapshotterMockRecorder) Walk(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Walk", reflect.TypeOf((*MockSnapshotter)(nil).Walk), varargs...)
}