mock_tasksvc.go

Documentation: edge-infra.dev/pkg/sds/devices/agent/mocks

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: github.com/containerd/containerd/api/services/tasks/v1 (interfaces: TasksClient)
     3  
     4  // Package mocks is a generated GoMock package.
     5  package mocks
     6  
     7  import (
     8  	context "context"
     9  	reflect "reflect"
    10  
    11  	tasks "github.com/containerd/containerd/api/services/tasks/v1"
    12  	gomock "github.com/golang/mock/gomock"
    13  	grpc "google.golang.org/grpc"
    14  	emptypb "google.golang.org/protobuf/types/known/emptypb"
    15  )
    16  
    17  // MockTasksClient is a mock of TasksClient interface.
    18  type MockTasksClient struct {
    19  	ctrl     *gomock.Controller
    20  	recorder *MockTasksClientMockRecorder
    21  }
    22  
    23  // MockTasksClientMockRecorder is the mock recorder for MockTasksClient.
    24  type MockTasksClientMockRecorder struct {
    25  	mock *MockTasksClient
    26  }
    27  
    28  // NewMockTasksClient creates a new mock instance.
    29  func NewMockTasksClient(ctrl *gomock.Controller) *MockTasksClient {
    30  	mock := &MockTasksClient{ctrl: ctrl}
    31  	mock.recorder = &MockTasksClientMockRecorder{mock}
    32  	return mock
    33  }
    34  
    35  // EXPECT returns an object that allows the caller to indicate expected use.
    36  func (m *MockTasksClient) EXPECT() *MockTasksClientMockRecorder {
    37  	return m.recorder
    38  }
    39  
    40  // Checkpoint mocks base method.
    41  func (m *MockTasksClient) Checkpoint(arg0 context.Context, arg1 *tasks.CheckpointTaskRequest, arg2 ...grpc.CallOption) (*tasks.CheckpointTaskResponse, error) {
    42  	m.ctrl.T.Helper()
    43  	varargs := []interface{}{arg0, arg1}
    44  	for _, a := range arg2 {
    45  		varargs = append(varargs, a)
    46  	}
    47  	ret := m.ctrl.Call(m, "Checkpoint", varargs...)
    48  	ret0, _ := ret[0].(*tasks.CheckpointTaskResponse)
    49  	ret1, _ := ret[1].(error)
    50  	return ret0, ret1
    51  }
    52  
    53  // Checkpoint indicates an expected call of Checkpoint.
    54  func (mr *MockTasksClientMockRecorder) Checkpoint(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    55  	mr.mock.ctrl.T.Helper()
    56  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    57  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Checkpoint", reflect.TypeOf((*MockTasksClient)(nil).Checkpoint), varargs...)
    58  }
    59  
    60  // CloseIO mocks base method.
    61  func (m *MockTasksClient) CloseIO(arg0 context.Context, arg1 *tasks.CloseIORequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
    62  	m.ctrl.T.Helper()
    63  	varargs := []interface{}{arg0, arg1}
    64  	for _, a := range arg2 {
    65  		varargs = append(varargs, a)
    66  	}
    67  	ret := m.ctrl.Call(m, "CloseIO", varargs...)
    68  	ret0, _ := ret[0].(*emptypb.Empty)
    69  	ret1, _ := ret[1].(error)
    70  	return ret0, ret1
    71  }
    72  
    73  // CloseIO indicates an expected call of CloseIO.
    74  func (mr *MockTasksClientMockRecorder) CloseIO(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    75  	mr.mock.ctrl.T.Helper()
    76  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    77  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseIO", reflect.TypeOf((*MockTasksClient)(nil).CloseIO), varargs...)
    78  }
    79  
    80  // Create mocks base method.
    81  func (m *MockTasksClient) Create(arg0 context.Context, arg1 *tasks.CreateTaskRequest, arg2 ...grpc.CallOption) (*tasks.CreateTaskResponse, error) {
    82  	m.ctrl.T.Helper()
    83  	varargs := []interface{}{arg0, arg1}
    84  	for _, a := range arg2 {
    85  		varargs = append(varargs, a)
    86  	}
    87  	ret := m.ctrl.Call(m, "Create", varargs...)
    88  	ret0, _ := ret[0].(*tasks.CreateTaskResponse)
    89  	ret1, _ := ret[1].(error)
    90  	return ret0, ret1
    91  }
    92  
    93  // Create indicates an expected call of Create.
    94  func (mr *MockTasksClientMockRecorder) Create(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    95  	mr.mock.ctrl.T.Helper()
    96  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    97  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockTasksClient)(nil).Create), varargs...)
    98  }
    99  
   100  // Delete mocks base method.
   101  func (m *MockTasksClient) Delete(arg0 context.Context, arg1 *tasks.DeleteTaskRequest, arg2 ...grpc.CallOption) (*tasks.DeleteResponse, error) {
   102  	m.ctrl.T.Helper()
   103  	varargs := []interface{}{arg0, arg1}
   104  	for _, a := range arg2 {
   105  		varargs = append(varargs, a)
   106  	}
   107  	ret := m.ctrl.Call(m, "Delete", varargs...)
   108  	ret0, _ := ret[0].(*tasks.DeleteResponse)
   109  	ret1, _ := ret[1].(error)
   110  	return ret0, ret1
   111  }
   112  
   113  // Delete indicates an expected call of Delete.
   114  func (mr *MockTasksClientMockRecorder) Delete(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   115  	mr.mock.ctrl.T.Helper()
   116  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   117  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockTasksClient)(nil).Delete), varargs...)
   118  }
   119  
   120  // DeleteProcess mocks base method.
   121  func (m *MockTasksClient) DeleteProcess(arg0 context.Context, arg1 *tasks.DeleteProcessRequest, arg2 ...grpc.CallOption) (*tasks.DeleteResponse, error) {
   122  	m.ctrl.T.Helper()
   123  	varargs := []interface{}{arg0, arg1}
   124  	for _, a := range arg2 {
   125  		varargs = append(varargs, a)
   126  	}
   127  	ret := m.ctrl.Call(m, "DeleteProcess", varargs...)
   128  	ret0, _ := ret[0].(*tasks.DeleteResponse)
   129  	ret1, _ := ret[1].(error)
   130  	return ret0, ret1
   131  }
   132  
   133  // DeleteProcess indicates an expected call of DeleteProcess.
   134  func (mr *MockTasksClientMockRecorder) DeleteProcess(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   135  	mr.mock.ctrl.T.Helper()
   136  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   137  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProcess", reflect.TypeOf((*MockTasksClient)(nil).DeleteProcess), varargs...)
   138  }
   139  
   140  // Exec mocks base method.
   141  func (m *MockTasksClient) Exec(arg0 context.Context, arg1 *tasks.ExecProcessRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
   142  	m.ctrl.T.Helper()
   143  	varargs := []interface{}{arg0, arg1}
   144  	for _, a := range arg2 {
   145  		varargs = append(varargs, a)
   146  	}
   147  	ret := m.ctrl.Call(m, "Exec", varargs...)
   148  	ret0, _ := ret[0].(*emptypb.Empty)
   149  	ret1, _ := ret[1].(error)
   150  	return ret0, ret1
   151  }
   152  
   153  // Exec indicates an expected call of Exec.
   154  func (mr *MockTasksClientMockRecorder) Exec(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   155  	mr.mock.ctrl.T.Helper()
   156  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   157  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockTasksClient)(nil).Exec), varargs...)
   158  }
   159  
   160  // Get mocks base method.
   161  func (m *MockTasksClient) Get(arg0 context.Context, arg1 *tasks.GetRequest, arg2 ...grpc.CallOption) (*tasks.GetResponse, error) {
   162  	m.ctrl.T.Helper()
   163  	varargs := []interface{}{arg0, arg1}
   164  	for _, a := range arg2 {
   165  		varargs = append(varargs, a)
   166  	}
   167  	ret := m.ctrl.Call(m, "Get", varargs...)
   168  	ret0, _ := ret[0].(*tasks.GetResponse)
   169  	ret1, _ := ret[1].(error)
   170  	return ret0, ret1
   171  }
   172  
   173  // Get indicates an expected call of Get.
   174  func (mr *MockTasksClientMockRecorder) Get(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   175  	mr.mock.ctrl.T.Helper()
   176  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   177  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockTasksClient)(nil).Get), varargs...)
   178  }
   179  
   180  // Kill mocks base method.
   181  func (m *MockTasksClient) Kill(arg0 context.Context, arg1 *tasks.KillRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
   182  	m.ctrl.T.Helper()
   183  	varargs := []interface{}{arg0, arg1}
   184  	for _, a := range arg2 {
   185  		varargs = append(varargs, a)
   186  	}
   187  	ret := m.ctrl.Call(m, "Kill", varargs...)
   188  	ret0, _ := ret[0].(*emptypb.Empty)
   189  	ret1, _ := ret[1].(error)
   190  	return ret0, ret1
   191  }
   192  
   193  // Kill indicates an expected call of Kill.
   194  func (mr *MockTasksClientMockRecorder) Kill(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   195  	mr.mock.ctrl.T.Helper()
   196  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   197  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kill", reflect.TypeOf((*MockTasksClient)(nil).Kill), varargs...)
   198  }
   199  
   200  // List mocks base method.
   201  func (m *MockTasksClient) List(arg0 context.Context, arg1 *tasks.ListTasksRequest, arg2 ...grpc.CallOption) (*tasks.ListTasksResponse, error) {
   202  	m.ctrl.T.Helper()
   203  	varargs := []interface{}{arg0, arg1}
   204  	for _, a := range arg2 {
   205  		varargs = append(varargs, a)
   206  	}
   207  	ret := m.ctrl.Call(m, "List", varargs...)
   208  	ret0, _ := ret[0].(*tasks.ListTasksResponse)
   209  	ret1, _ := ret[1].(error)
   210  	return ret0, ret1
   211  }
   212  
   213  // List indicates an expected call of List.
   214  func (mr *MockTasksClientMockRecorder) List(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   215  	mr.mock.ctrl.T.Helper()
   216  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   217  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockTasksClient)(nil).List), varargs...)
   218  }
   219  
   220  // ListPids mocks base method.
   221  func (m *MockTasksClient) ListPids(arg0 context.Context, arg1 *tasks.ListPidsRequest, arg2 ...grpc.CallOption) (*tasks.ListPidsResponse, error) {
   222  	m.ctrl.T.Helper()
   223  	varargs := []interface{}{arg0, arg1}
   224  	for _, a := range arg2 {
   225  		varargs = append(varargs, a)
   226  	}
   227  	ret := m.ctrl.Call(m, "ListPids", varargs...)
   228  	ret0, _ := ret[0].(*tasks.ListPidsResponse)
   229  	ret1, _ := ret[1].(error)
   230  	return ret0, ret1
   231  }
   232  
   233  // ListPids indicates an expected call of ListPids.
   234  func (mr *MockTasksClientMockRecorder) ListPids(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   235  	mr.mock.ctrl.T.Helper()
   236  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   237  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPids", reflect.TypeOf((*MockTasksClient)(nil).ListPids), varargs...)
   238  }
   239  
   240  // Metrics mocks base method.
   241  func (m *MockTasksClient) Metrics(arg0 context.Context, arg1 *tasks.MetricsRequest, arg2 ...grpc.CallOption) (*tasks.MetricsResponse, error) {
   242  	m.ctrl.T.Helper()
   243  	varargs := []interface{}{arg0, arg1}
   244  	for _, a := range arg2 {
   245  		varargs = append(varargs, a)
   246  	}
   247  	ret := m.ctrl.Call(m, "Metrics", varargs...)
   248  	ret0, _ := ret[0].(*tasks.MetricsResponse)
   249  	ret1, _ := ret[1].(error)
   250  	return ret0, ret1
   251  }
   252  
   253  // Metrics indicates an expected call of Metrics.
   254  func (mr *MockTasksClientMockRecorder) Metrics(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   255  	mr.mock.ctrl.T.Helper()
   256  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   257  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Metrics", reflect.TypeOf((*MockTasksClient)(nil).Metrics), varargs...)
   258  }
   259  
   260  // Pause mocks base method.
   261  func (m *MockTasksClient) Pause(arg0 context.Context, arg1 *tasks.PauseTaskRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
   262  	m.ctrl.T.Helper()
   263  	varargs := []interface{}{arg0, arg1}
   264  	for _, a := range arg2 {
   265  		varargs = append(varargs, a)
   266  	}
   267  	ret := m.ctrl.Call(m, "Pause", varargs...)
   268  	ret0, _ := ret[0].(*emptypb.Empty)
   269  	ret1, _ := ret[1].(error)
   270  	return ret0, ret1
   271  }
   272  
   273  // Pause indicates an expected call of Pause.
   274  func (mr *MockTasksClientMockRecorder) Pause(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   275  	mr.mock.ctrl.T.Helper()
   276  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   277  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pause", reflect.TypeOf((*MockTasksClient)(nil).Pause), varargs...)
   278  }
   279  
   280  // ResizePty mocks base method.
   281  func (m *MockTasksClient) ResizePty(arg0 context.Context, arg1 *tasks.ResizePtyRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
   282  	m.ctrl.T.Helper()
   283  	varargs := []interface{}{arg0, arg1}
   284  	for _, a := range arg2 {
   285  		varargs = append(varargs, a)
   286  	}
   287  	ret := m.ctrl.Call(m, "ResizePty", varargs...)
   288  	ret0, _ := ret[0].(*emptypb.Empty)
   289  	ret1, _ := ret[1].(error)
   290  	return ret0, ret1
   291  }
   292  
   293  // ResizePty indicates an expected call of ResizePty.
   294  func (mr *MockTasksClientMockRecorder) ResizePty(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   295  	mr.mock.ctrl.T.Helper()
   296  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   297  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizePty", reflect.TypeOf((*MockTasksClient)(nil).ResizePty), varargs...)
   298  }
   299  
   300  // Resume mocks base method.
   301  func (m *MockTasksClient) Resume(arg0 context.Context, arg1 *tasks.ResumeTaskRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
   302  	m.ctrl.T.Helper()
   303  	varargs := []interface{}{arg0, arg1}
   304  	for _, a := range arg2 {
   305  		varargs = append(varargs, a)
   306  	}
   307  	ret := m.ctrl.Call(m, "Resume", varargs...)
   308  	ret0, _ := ret[0].(*emptypb.Empty)
   309  	ret1, _ := ret[1].(error)
   310  	return ret0, ret1
   311  }
   312  
   313  // Resume indicates an expected call of Resume.
   314  func (mr *MockTasksClientMockRecorder) Resume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   315  	mr.mock.ctrl.T.Helper()
   316  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   317  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resume", reflect.TypeOf((*MockTasksClient)(nil).Resume), varargs...)
   318  }
   319  
   320  // Start mocks base method.
   321  func (m *MockTasksClient) Start(arg0 context.Context, arg1 *tasks.StartRequest, arg2 ...grpc.CallOption) (*tasks.StartResponse, error) {
   322  	m.ctrl.T.Helper()
   323  	varargs := []interface{}{arg0, arg1}
   324  	for _, a := range arg2 {
   325  		varargs = append(varargs, a)
   326  	}
   327  	ret := m.ctrl.Call(m, "Start", varargs...)
   328  	ret0, _ := ret[0].(*tasks.StartResponse)
   329  	ret1, _ := ret[1].(error)
   330  	return ret0, ret1
   331  }
   332  
   333  // Start indicates an expected call of Start.
   334  func (mr *MockTasksClientMockRecorder) Start(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   335  	mr.mock.ctrl.T.Helper()
   336  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   337  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockTasksClient)(nil).Start), varargs...)
   338  }
   339  
   340  // Update mocks base method.
   341  func (m *MockTasksClient) Update(arg0 context.Context, arg1 *tasks.UpdateTaskRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
   342  	m.ctrl.T.Helper()
   343  	varargs := []interface{}{arg0, arg1}
   344  	for _, a := range arg2 {
   345  		varargs = append(varargs, a)
   346  	}
   347  	ret := m.ctrl.Call(m, "Update", varargs...)
   348  	ret0, _ := ret[0].(*emptypb.Empty)
   349  	ret1, _ := ret[1].(error)
   350  	return ret0, ret1
   351  }
   352  
   353  // Update indicates an expected call of Update.
   354  func (mr *MockTasksClientMockRecorder) Update(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   355  	mr.mock.ctrl.T.Helper()
   356  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   357  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockTasksClient)(nil).Update), varargs...)
   358  }
   359  
   360  // Wait mocks base method.
   361  func (m *MockTasksClient) Wait(arg0 context.Context, arg1 *tasks.WaitRequest, arg2 ...grpc.CallOption) (*tasks.WaitResponse, error) {
   362  	m.ctrl.T.Helper()
   363  	varargs := []interface{}{arg0, arg1}
   364  	for _, a := range arg2 {
   365  		varargs = append(varargs, a)
   366  	}
   367  	ret := m.ctrl.Call(m, "Wait", varargs...)
   368  	ret0, _ := ret[0].(*tasks.WaitResponse)
   369  	ret1, _ := ret[1].(error)
   370  	return ret0, ret1
   371  }
   372  
   373  // Wait indicates an expected call of Wait.
   374  func (mr *MockTasksClientMockRecorder) Wait(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   375  	mr.mock.ctrl.T.Helper()
   376  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   377  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockTasksClient)(nil).Wait), varargs...)
   378  }
   379
View as plain text