Source file src/edge-infra.dev/pkg/sds/devices/agent/mocks/mock_criclient.go

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

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: k8s.io/cri-api/pkg/apis/runtime/v1 (interfaces: RuntimeServiceClient)
     3  
     4  // Package mocks is a generated GoMock package.
     5  package mocks
     6  
     7  import (
     8  	context "context"
     9  	reflect "reflect"
    10  
    11  	gomock "github.com/golang/mock/gomock"
    12  	grpc "google.golang.org/grpc"
    13  	v1 "k8s.io/cri-api/pkg/apis/runtime/v1"
    14  )
    15  
    16  // MockRuntimeServiceClient is a mock of RuntimeServiceClient interface.
    17  type MockRuntimeServiceClient struct {
    18  	ctrl     *gomock.Controller
    19  	recorder *MockRuntimeServiceClientMockRecorder
    20  }
    21  
    22  // MockRuntimeServiceClientMockRecorder is the mock recorder for MockRuntimeServiceClient.
    23  type MockRuntimeServiceClientMockRecorder struct {
    24  	mock *MockRuntimeServiceClient
    25  }
    26  
    27  // NewMockRuntimeServiceClient creates a new mock instance.
    28  func NewMockRuntimeServiceClient(ctrl *gomock.Controller) *MockRuntimeServiceClient {
    29  	mock := &MockRuntimeServiceClient{ctrl: ctrl}
    30  	mock.recorder = &MockRuntimeServiceClientMockRecorder{mock}
    31  	return mock
    32  }
    33  
    34  // EXPECT returns an object that allows the caller to indicate expected use.
    35  func (m *MockRuntimeServiceClient) EXPECT() *MockRuntimeServiceClientMockRecorder {
    36  	return m.recorder
    37  }
    38  
    39  // Attach mocks base method.
    40  func (m *MockRuntimeServiceClient) Attach(arg0 context.Context, arg1 *v1.AttachRequest, arg2 ...grpc.CallOption) (*v1.AttachResponse, error) {
    41  	m.ctrl.T.Helper()
    42  	varargs := []interface{}{arg0, arg1}
    43  	for _, a := range arg2 {
    44  		varargs = append(varargs, a)
    45  	}
    46  	ret := m.ctrl.Call(m, "Attach", varargs...)
    47  	ret0, _ := ret[0].(*v1.AttachResponse)
    48  	ret1, _ := ret[1].(error)
    49  	return ret0, ret1
    50  }
    51  
    52  // Attach indicates an expected call of Attach.
    53  func (mr *MockRuntimeServiceClientMockRecorder) Attach(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    54  	mr.mock.ctrl.T.Helper()
    55  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    56  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attach", reflect.TypeOf((*MockRuntimeServiceClient)(nil).Attach), varargs...)
    57  }
    58  
    59  // CheckpointContainer mocks base method.
    60  func (m *MockRuntimeServiceClient) CheckpointContainer(arg0 context.Context, arg1 *v1.CheckpointContainerRequest, arg2 ...grpc.CallOption) (*v1.CheckpointContainerResponse, error) {
    61  	m.ctrl.T.Helper()
    62  	varargs := []interface{}{arg0, arg1}
    63  	for _, a := range arg2 {
    64  		varargs = append(varargs, a)
    65  	}
    66  	ret := m.ctrl.Call(m, "CheckpointContainer", varargs...)
    67  	ret0, _ := ret[0].(*v1.CheckpointContainerResponse)
    68  	ret1, _ := ret[1].(error)
    69  	return ret0, ret1
    70  }
    71  
    72  // CheckpointContainer indicates an expected call of CheckpointContainer.
    73  func (mr *MockRuntimeServiceClientMockRecorder) CheckpointContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    74  	mr.mock.ctrl.T.Helper()
    75  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    76  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckpointContainer", reflect.TypeOf((*MockRuntimeServiceClient)(nil).CheckpointContainer), varargs...)
    77  }
    78  
    79  // ContainerStats mocks base method.
    80  func (m *MockRuntimeServiceClient) ContainerStats(arg0 context.Context, arg1 *v1.ContainerStatsRequest, arg2 ...grpc.CallOption) (*v1.ContainerStatsResponse, error) {
    81  	m.ctrl.T.Helper()
    82  	varargs := []interface{}{arg0, arg1}
    83  	for _, a := range arg2 {
    84  		varargs = append(varargs, a)
    85  	}
    86  	ret := m.ctrl.Call(m, "ContainerStats", varargs...)
    87  	ret0, _ := ret[0].(*v1.ContainerStatsResponse)
    88  	ret1, _ := ret[1].(error)
    89  	return ret0, ret1
    90  }
    91  
    92  // ContainerStats indicates an expected call of ContainerStats.
    93  func (mr *MockRuntimeServiceClientMockRecorder) ContainerStats(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    94  	mr.mock.ctrl.T.Helper()
    95  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    96  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStats", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ContainerStats), varargs...)
    97  }
    98  
    99  // ContainerStatus mocks base method.
   100  func (m *MockRuntimeServiceClient) ContainerStatus(arg0 context.Context, arg1 *v1.ContainerStatusRequest, arg2 ...grpc.CallOption) (*v1.ContainerStatusResponse, error) {
   101  	m.ctrl.T.Helper()
   102  	varargs := []interface{}{arg0, arg1}
   103  	for _, a := range arg2 {
   104  		varargs = append(varargs, a)
   105  	}
   106  	ret := m.ctrl.Call(m, "ContainerStatus", varargs...)
   107  	ret0, _ := ret[0].(*v1.ContainerStatusResponse)
   108  	ret1, _ := ret[1].(error)
   109  	return ret0, ret1
   110  }
   111  
   112  // ContainerStatus indicates an expected call of ContainerStatus.
   113  func (mr *MockRuntimeServiceClientMockRecorder) ContainerStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   114  	mr.mock.ctrl.T.Helper()
   115  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   116  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStatus", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ContainerStatus), varargs...)
   117  }
   118  
   119  // CreateContainer mocks base method.
   120  func (m *MockRuntimeServiceClient) CreateContainer(arg0 context.Context, arg1 *v1.CreateContainerRequest, arg2 ...grpc.CallOption) (*v1.CreateContainerResponse, error) {
   121  	m.ctrl.T.Helper()
   122  	varargs := []interface{}{arg0, arg1}
   123  	for _, a := range arg2 {
   124  		varargs = append(varargs, a)
   125  	}
   126  	ret := m.ctrl.Call(m, "CreateContainer", varargs...)
   127  	ret0, _ := ret[0].(*v1.CreateContainerResponse)
   128  	ret1, _ := ret[1].(error)
   129  	return ret0, ret1
   130  }
   131  
   132  // CreateContainer indicates an expected call of CreateContainer.
   133  func (mr *MockRuntimeServiceClientMockRecorder) CreateContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   134  	mr.mock.ctrl.T.Helper()
   135  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   136  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockRuntimeServiceClient)(nil).CreateContainer), varargs...)
   137  }
   138  
   139  // Exec mocks base method.
   140  func (m *MockRuntimeServiceClient) Exec(arg0 context.Context, arg1 *v1.ExecRequest, arg2 ...grpc.CallOption) (*v1.ExecResponse, error) {
   141  	m.ctrl.T.Helper()
   142  	varargs := []interface{}{arg0, arg1}
   143  	for _, a := range arg2 {
   144  		varargs = append(varargs, a)
   145  	}
   146  	ret := m.ctrl.Call(m, "Exec", varargs...)
   147  	ret0, _ := ret[0].(*v1.ExecResponse)
   148  	ret1, _ := ret[1].(error)
   149  	return ret0, ret1
   150  }
   151  
   152  // Exec indicates an expected call of Exec.
   153  func (mr *MockRuntimeServiceClientMockRecorder) Exec(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   154  	mr.mock.ctrl.T.Helper()
   155  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   156  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockRuntimeServiceClient)(nil).Exec), varargs...)
   157  }
   158  
   159  // ExecSync mocks base method.
   160  func (m *MockRuntimeServiceClient) ExecSync(arg0 context.Context, arg1 *v1.ExecSyncRequest, arg2 ...grpc.CallOption) (*v1.ExecSyncResponse, error) {
   161  	m.ctrl.T.Helper()
   162  	varargs := []interface{}{arg0, arg1}
   163  	for _, a := range arg2 {
   164  		varargs = append(varargs, a)
   165  	}
   166  	ret := m.ctrl.Call(m, "ExecSync", varargs...)
   167  	ret0, _ := ret[0].(*v1.ExecSyncResponse)
   168  	ret1, _ := ret[1].(error)
   169  	return ret0, ret1
   170  }
   171  
   172  // ExecSync indicates an expected call of ExecSync.
   173  func (mr *MockRuntimeServiceClientMockRecorder) ExecSync(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   174  	mr.mock.ctrl.T.Helper()
   175  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   176  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecSync", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ExecSync), varargs...)
   177  }
   178  
   179  // GetContainerEvents mocks base method.
   180  func (m *MockRuntimeServiceClient) GetContainerEvents(arg0 context.Context, arg1 *v1.GetEventsRequest, arg2 ...grpc.CallOption) (v1.RuntimeService_GetContainerEventsClient, error) {
   181  	m.ctrl.T.Helper()
   182  	varargs := []interface{}{arg0, arg1}
   183  	for _, a := range arg2 {
   184  		varargs = append(varargs, a)
   185  	}
   186  	ret := m.ctrl.Call(m, "GetContainerEvents", varargs...)
   187  	ret0, _ := ret[0].(v1.RuntimeService_GetContainerEventsClient)
   188  	ret1, _ := ret[1].(error)
   189  	return ret0, ret1
   190  }
   191  
   192  // GetContainerEvents indicates an expected call of GetContainerEvents.
   193  func (mr *MockRuntimeServiceClientMockRecorder) GetContainerEvents(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   194  	mr.mock.ctrl.T.Helper()
   195  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   196  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerEvents", reflect.TypeOf((*MockRuntimeServiceClient)(nil).GetContainerEvents), varargs...)
   197  }
   198  
   199  // ListContainerStats mocks base method.
   200  func (m *MockRuntimeServiceClient) ListContainerStats(arg0 context.Context, arg1 *v1.ListContainerStatsRequest, arg2 ...grpc.CallOption) (*v1.ListContainerStatsResponse, error) {
   201  	m.ctrl.T.Helper()
   202  	varargs := []interface{}{arg0, arg1}
   203  	for _, a := range arg2 {
   204  		varargs = append(varargs, a)
   205  	}
   206  	ret := m.ctrl.Call(m, "ListContainerStats", varargs...)
   207  	ret0, _ := ret[0].(*v1.ListContainerStatsResponse)
   208  	ret1, _ := ret[1].(error)
   209  	return ret0, ret1
   210  }
   211  
   212  // ListContainerStats indicates an expected call of ListContainerStats.
   213  func (mr *MockRuntimeServiceClientMockRecorder) ListContainerStats(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   214  	mr.mock.ctrl.T.Helper()
   215  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   216  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerStats", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListContainerStats), varargs...)
   217  }
   218  
   219  // ListContainers mocks base method.
   220  func (m *MockRuntimeServiceClient) ListContainers(arg0 context.Context, arg1 *v1.ListContainersRequest, arg2 ...grpc.CallOption) (*v1.ListContainersResponse, error) {
   221  	m.ctrl.T.Helper()
   222  	varargs := []interface{}{arg0, arg1}
   223  	for _, a := range arg2 {
   224  		varargs = append(varargs, a)
   225  	}
   226  	ret := m.ctrl.Call(m, "ListContainers", varargs...)
   227  	ret0, _ := ret[0].(*v1.ListContainersResponse)
   228  	ret1, _ := ret[1].(error)
   229  	return ret0, ret1
   230  }
   231  
   232  // ListContainers indicates an expected call of ListContainers.
   233  func (mr *MockRuntimeServiceClientMockRecorder) ListContainers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   234  	mr.mock.ctrl.T.Helper()
   235  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   236  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListContainers), varargs...)
   237  }
   238  
   239  // ListMetricDescriptors mocks base method.
   240  func (m *MockRuntimeServiceClient) ListMetricDescriptors(arg0 context.Context, arg1 *v1.ListMetricDescriptorsRequest, arg2 ...grpc.CallOption) (*v1.ListMetricDescriptorsResponse, error) {
   241  	m.ctrl.T.Helper()
   242  	varargs := []interface{}{arg0, arg1}
   243  	for _, a := range arg2 {
   244  		varargs = append(varargs, a)
   245  	}
   246  	ret := m.ctrl.Call(m, "ListMetricDescriptors", varargs...)
   247  	ret0, _ := ret[0].(*v1.ListMetricDescriptorsResponse)
   248  	ret1, _ := ret[1].(error)
   249  	return ret0, ret1
   250  }
   251  
   252  // ListMetricDescriptors indicates an expected call of ListMetricDescriptors.
   253  func (mr *MockRuntimeServiceClientMockRecorder) ListMetricDescriptors(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   254  	mr.mock.ctrl.T.Helper()
   255  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   256  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMetricDescriptors", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListMetricDescriptors), varargs...)
   257  }
   258  
   259  // ListPodSandbox mocks base method.
   260  func (m *MockRuntimeServiceClient) ListPodSandbox(arg0 context.Context, arg1 *v1.ListPodSandboxRequest, arg2 ...grpc.CallOption) (*v1.ListPodSandboxResponse, error) {
   261  	m.ctrl.T.Helper()
   262  	varargs := []interface{}{arg0, arg1}
   263  	for _, a := range arg2 {
   264  		varargs = append(varargs, a)
   265  	}
   266  	ret := m.ctrl.Call(m, "ListPodSandbox", varargs...)
   267  	ret0, _ := ret[0].(*v1.ListPodSandboxResponse)
   268  	ret1, _ := ret[1].(error)
   269  	return ret0, ret1
   270  }
   271  
   272  // ListPodSandbox indicates an expected call of ListPodSandbox.
   273  func (mr *MockRuntimeServiceClientMockRecorder) ListPodSandbox(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   274  	mr.mock.ctrl.T.Helper()
   275  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   276  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodSandbox", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListPodSandbox), varargs...)
   277  }
   278  
   279  // ListPodSandboxMetrics mocks base method.
   280  func (m *MockRuntimeServiceClient) ListPodSandboxMetrics(arg0 context.Context, arg1 *v1.ListPodSandboxMetricsRequest, arg2 ...grpc.CallOption) (*v1.ListPodSandboxMetricsResponse, error) {
   281  	m.ctrl.T.Helper()
   282  	varargs := []interface{}{arg0, arg1}
   283  	for _, a := range arg2 {
   284  		varargs = append(varargs, a)
   285  	}
   286  	ret := m.ctrl.Call(m, "ListPodSandboxMetrics", varargs...)
   287  	ret0, _ := ret[0].(*v1.ListPodSandboxMetricsResponse)
   288  	ret1, _ := ret[1].(error)
   289  	return ret0, ret1
   290  }
   291  
   292  // ListPodSandboxMetrics indicates an expected call of ListPodSandboxMetrics.
   293  func (mr *MockRuntimeServiceClientMockRecorder) ListPodSandboxMetrics(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   294  	mr.mock.ctrl.T.Helper()
   295  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   296  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodSandboxMetrics", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListPodSandboxMetrics), varargs...)
   297  }
   298  
   299  // ListPodSandboxStats mocks base method.
   300  func (m *MockRuntimeServiceClient) ListPodSandboxStats(arg0 context.Context, arg1 *v1.ListPodSandboxStatsRequest, arg2 ...grpc.CallOption) (*v1.ListPodSandboxStatsResponse, error) {
   301  	m.ctrl.T.Helper()
   302  	varargs := []interface{}{arg0, arg1}
   303  	for _, a := range arg2 {
   304  		varargs = append(varargs, a)
   305  	}
   306  	ret := m.ctrl.Call(m, "ListPodSandboxStats", varargs...)
   307  	ret0, _ := ret[0].(*v1.ListPodSandboxStatsResponse)
   308  	ret1, _ := ret[1].(error)
   309  	return ret0, ret1
   310  }
   311  
   312  // ListPodSandboxStats indicates an expected call of ListPodSandboxStats.
   313  func (mr *MockRuntimeServiceClientMockRecorder) ListPodSandboxStats(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   314  	mr.mock.ctrl.T.Helper()
   315  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   316  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodSandboxStats", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListPodSandboxStats), varargs...)
   317  }
   318  
   319  // PodSandboxStats mocks base method.
   320  func (m *MockRuntimeServiceClient) PodSandboxStats(arg0 context.Context, arg1 *v1.PodSandboxStatsRequest, arg2 ...grpc.CallOption) (*v1.PodSandboxStatsResponse, error) {
   321  	m.ctrl.T.Helper()
   322  	varargs := []interface{}{arg0, arg1}
   323  	for _, a := range arg2 {
   324  		varargs = append(varargs, a)
   325  	}
   326  	ret := m.ctrl.Call(m, "PodSandboxStats", varargs...)
   327  	ret0, _ := ret[0].(*v1.PodSandboxStatsResponse)
   328  	ret1, _ := ret[1].(error)
   329  	return ret0, ret1
   330  }
   331  
   332  // PodSandboxStats indicates an expected call of PodSandboxStats.
   333  func (mr *MockRuntimeServiceClientMockRecorder) PodSandboxStats(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   334  	mr.mock.ctrl.T.Helper()
   335  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   336  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodSandboxStats", reflect.TypeOf((*MockRuntimeServiceClient)(nil).PodSandboxStats), varargs...)
   337  }
   338  
   339  // PodSandboxStatus mocks base method.
   340  func (m *MockRuntimeServiceClient) PodSandboxStatus(arg0 context.Context, arg1 *v1.PodSandboxStatusRequest, arg2 ...grpc.CallOption) (*v1.PodSandboxStatusResponse, error) {
   341  	m.ctrl.T.Helper()
   342  	varargs := []interface{}{arg0, arg1}
   343  	for _, a := range arg2 {
   344  		varargs = append(varargs, a)
   345  	}
   346  	ret := m.ctrl.Call(m, "PodSandboxStatus", varargs...)
   347  	ret0, _ := ret[0].(*v1.PodSandboxStatusResponse)
   348  	ret1, _ := ret[1].(error)
   349  	return ret0, ret1
   350  }
   351  
   352  // PodSandboxStatus indicates an expected call of PodSandboxStatus.
   353  func (mr *MockRuntimeServiceClientMockRecorder) PodSandboxStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   354  	mr.mock.ctrl.T.Helper()
   355  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   356  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodSandboxStatus", reflect.TypeOf((*MockRuntimeServiceClient)(nil).PodSandboxStatus), varargs...)
   357  }
   358  
   359  // PortForward mocks base method.
   360  func (m *MockRuntimeServiceClient) PortForward(arg0 context.Context, arg1 *v1.PortForwardRequest, arg2 ...grpc.CallOption) (*v1.PortForwardResponse, error) {
   361  	m.ctrl.T.Helper()
   362  	varargs := []interface{}{arg0, arg1}
   363  	for _, a := range arg2 {
   364  		varargs = append(varargs, a)
   365  	}
   366  	ret := m.ctrl.Call(m, "PortForward", varargs...)
   367  	ret0, _ := ret[0].(*v1.PortForwardResponse)
   368  	ret1, _ := ret[1].(error)
   369  	return ret0, ret1
   370  }
   371  
   372  // PortForward indicates an expected call of PortForward.
   373  func (mr *MockRuntimeServiceClientMockRecorder) PortForward(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   374  	mr.mock.ctrl.T.Helper()
   375  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   376  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortForward", reflect.TypeOf((*MockRuntimeServiceClient)(nil).PortForward), varargs...)
   377  }
   378  
   379  // RemoveContainer mocks base method.
   380  func (m *MockRuntimeServiceClient) RemoveContainer(arg0 context.Context, arg1 *v1.RemoveContainerRequest, arg2 ...grpc.CallOption) (*v1.RemoveContainerResponse, error) {
   381  	m.ctrl.T.Helper()
   382  	varargs := []interface{}{arg0, arg1}
   383  	for _, a := range arg2 {
   384  		varargs = append(varargs, a)
   385  	}
   386  	ret := m.ctrl.Call(m, "RemoveContainer", varargs...)
   387  	ret0, _ := ret[0].(*v1.RemoveContainerResponse)
   388  	ret1, _ := ret[1].(error)
   389  	return ret0, ret1
   390  }
   391  
   392  // RemoveContainer indicates an expected call of RemoveContainer.
   393  func (mr *MockRuntimeServiceClientMockRecorder) RemoveContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   394  	mr.mock.ctrl.T.Helper()
   395  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   396  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockRuntimeServiceClient)(nil).RemoveContainer), varargs...)
   397  }
   398  
   399  // RemovePodSandbox mocks base method.
   400  func (m *MockRuntimeServiceClient) RemovePodSandbox(arg0 context.Context, arg1 *v1.RemovePodSandboxRequest, arg2 ...grpc.CallOption) (*v1.RemovePodSandboxResponse, error) {
   401  	m.ctrl.T.Helper()
   402  	varargs := []interface{}{arg0, arg1}
   403  	for _, a := range arg2 {
   404  		varargs = append(varargs, a)
   405  	}
   406  	ret := m.ctrl.Call(m, "RemovePodSandbox", varargs...)
   407  	ret0, _ := ret[0].(*v1.RemovePodSandboxResponse)
   408  	ret1, _ := ret[1].(error)
   409  	return ret0, ret1
   410  }
   411  
   412  // RemovePodSandbox indicates an expected call of RemovePodSandbox.
   413  func (mr *MockRuntimeServiceClientMockRecorder) RemovePodSandbox(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   414  	mr.mock.ctrl.T.Helper()
   415  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   416  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePodSandbox", reflect.TypeOf((*MockRuntimeServiceClient)(nil).RemovePodSandbox), varargs...)
   417  }
   418  
   419  // ReopenContainerLog mocks base method.
   420  func (m *MockRuntimeServiceClient) ReopenContainerLog(arg0 context.Context, arg1 *v1.ReopenContainerLogRequest, arg2 ...grpc.CallOption) (*v1.ReopenContainerLogResponse, error) {
   421  	m.ctrl.T.Helper()
   422  	varargs := []interface{}{arg0, arg1}
   423  	for _, a := range arg2 {
   424  		varargs = append(varargs, a)
   425  	}
   426  	ret := m.ctrl.Call(m, "ReopenContainerLog", varargs...)
   427  	ret0, _ := ret[0].(*v1.ReopenContainerLogResponse)
   428  	ret1, _ := ret[1].(error)
   429  	return ret0, ret1
   430  }
   431  
   432  // ReopenContainerLog indicates an expected call of ReopenContainerLog.
   433  func (mr *MockRuntimeServiceClientMockRecorder) ReopenContainerLog(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   434  	mr.mock.ctrl.T.Helper()
   435  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   436  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReopenContainerLog", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ReopenContainerLog), varargs...)
   437  }
   438  
   439  // RunPodSandbox mocks base method.
   440  func (m *MockRuntimeServiceClient) RunPodSandbox(arg0 context.Context, arg1 *v1.RunPodSandboxRequest, arg2 ...grpc.CallOption) (*v1.RunPodSandboxResponse, error) {
   441  	m.ctrl.T.Helper()
   442  	varargs := []interface{}{arg0, arg1}
   443  	for _, a := range arg2 {
   444  		varargs = append(varargs, a)
   445  	}
   446  	ret := m.ctrl.Call(m, "RunPodSandbox", varargs...)
   447  	ret0, _ := ret[0].(*v1.RunPodSandboxResponse)
   448  	ret1, _ := ret[1].(error)
   449  	return ret0, ret1
   450  }
   451  
   452  // RunPodSandbox indicates an expected call of RunPodSandbox.
   453  func (mr *MockRuntimeServiceClientMockRecorder) RunPodSandbox(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   454  	mr.mock.ctrl.T.Helper()
   455  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   456  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunPodSandbox", reflect.TypeOf((*MockRuntimeServiceClient)(nil).RunPodSandbox), varargs...)
   457  }
   458  
   459  // RuntimeConfig mocks base method.
   460  func (m *MockRuntimeServiceClient) RuntimeConfig(arg0 context.Context, arg1 *v1.RuntimeConfigRequest, arg2 ...grpc.CallOption) (*v1.RuntimeConfigResponse, error) {
   461  	m.ctrl.T.Helper()
   462  	varargs := []interface{}{arg0, arg1}
   463  	for _, a := range arg2 {
   464  		varargs = append(varargs, a)
   465  	}
   466  	ret := m.ctrl.Call(m, "RuntimeConfig", varargs...)
   467  	ret0, _ := ret[0].(*v1.RuntimeConfigResponse)
   468  	ret1, _ := ret[1].(error)
   469  	return ret0, ret1
   470  }
   471  
   472  // RuntimeConfig indicates an expected call of RuntimeConfig.
   473  func (mr *MockRuntimeServiceClientMockRecorder) RuntimeConfig(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   474  	mr.mock.ctrl.T.Helper()
   475  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   476  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RuntimeConfig", reflect.TypeOf((*MockRuntimeServiceClient)(nil).RuntimeConfig), varargs...)
   477  }
   478  
   479  // StartContainer mocks base method.
   480  func (m *MockRuntimeServiceClient) StartContainer(arg0 context.Context, arg1 *v1.StartContainerRequest, arg2 ...grpc.CallOption) (*v1.StartContainerResponse, error) {
   481  	m.ctrl.T.Helper()
   482  	varargs := []interface{}{arg0, arg1}
   483  	for _, a := range arg2 {
   484  		varargs = append(varargs, a)
   485  	}
   486  	ret := m.ctrl.Call(m, "StartContainer", varargs...)
   487  	ret0, _ := ret[0].(*v1.StartContainerResponse)
   488  	ret1, _ := ret[1].(error)
   489  	return ret0, ret1
   490  }
   491  
   492  // StartContainer indicates an expected call of StartContainer.
   493  func (mr *MockRuntimeServiceClientMockRecorder) StartContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   494  	mr.mock.ctrl.T.Helper()
   495  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   496  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockRuntimeServiceClient)(nil).StartContainer), varargs...)
   497  }
   498  
   499  // Status mocks base method.
   500  func (m *MockRuntimeServiceClient) Status(arg0 context.Context, arg1 *v1.StatusRequest, arg2 ...grpc.CallOption) (*v1.StatusResponse, error) {
   501  	m.ctrl.T.Helper()
   502  	varargs := []interface{}{arg0, arg1}
   503  	for _, a := range arg2 {
   504  		varargs = append(varargs, a)
   505  	}
   506  	ret := m.ctrl.Call(m, "Status", varargs...)
   507  	ret0, _ := ret[0].(*v1.StatusResponse)
   508  	ret1, _ := ret[1].(error)
   509  	return ret0, ret1
   510  }
   511  
   512  // Status indicates an expected call of Status.
   513  func (mr *MockRuntimeServiceClientMockRecorder) Status(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   514  	mr.mock.ctrl.T.Helper()
   515  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   516  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockRuntimeServiceClient)(nil).Status), varargs...)
   517  }
   518  
   519  // StopContainer mocks base method.
   520  func (m *MockRuntimeServiceClient) StopContainer(arg0 context.Context, arg1 *v1.StopContainerRequest, arg2 ...grpc.CallOption) (*v1.StopContainerResponse, error) {
   521  	m.ctrl.T.Helper()
   522  	varargs := []interface{}{arg0, arg1}
   523  	for _, a := range arg2 {
   524  		varargs = append(varargs, a)
   525  	}
   526  	ret := m.ctrl.Call(m, "StopContainer", varargs...)
   527  	ret0, _ := ret[0].(*v1.StopContainerResponse)
   528  	ret1, _ := ret[1].(error)
   529  	return ret0, ret1
   530  }
   531  
   532  // StopContainer indicates an expected call of StopContainer.
   533  func (mr *MockRuntimeServiceClientMockRecorder) StopContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   534  	mr.mock.ctrl.T.Helper()
   535  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   536  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockRuntimeServiceClient)(nil).StopContainer), varargs...)
   537  }
   538  
   539  // StopPodSandbox mocks base method.
   540  func (m *MockRuntimeServiceClient) StopPodSandbox(arg0 context.Context, arg1 *v1.StopPodSandboxRequest, arg2 ...grpc.CallOption) (*v1.StopPodSandboxResponse, error) {
   541  	m.ctrl.T.Helper()
   542  	varargs := []interface{}{arg0, arg1}
   543  	for _, a := range arg2 {
   544  		varargs = append(varargs, a)
   545  	}
   546  	ret := m.ctrl.Call(m, "StopPodSandbox", varargs...)
   547  	ret0, _ := ret[0].(*v1.StopPodSandboxResponse)
   548  	ret1, _ := ret[1].(error)
   549  	return ret0, ret1
   550  }
   551  
   552  // StopPodSandbox indicates an expected call of StopPodSandbox.
   553  func (mr *MockRuntimeServiceClientMockRecorder) StopPodSandbox(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   554  	mr.mock.ctrl.T.Helper()
   555  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   556  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopPodSandbox", reflect.TypeOf((*MockRuntimeServiceClient)(nil).StopPodSandbox), varargs...)
   557  }
   558  
   559  // UpdateContainerResources mocks base method.
   560  func (m *MockRuntimeServiceClient) UpdateContainerResources(arg0 context.Context, arg1 *v1.UpdateContainerResourcesRequest, arg2 ...grpc.CallOption) (*v1.UpdateContainerResourcesResponse, error) {
   561  	m.ctrl.T.Helper()
   562  	varargs := []interface{}{arg0, arg1}
   563  	for _, a := range arg2 {
   564  		varargs = append(varargs, a)
   565  	}
   566  	ret := m.ctrl.Call(m, "UpdateContainerResources", varargs...)
   567  	ret0, _ := ret[0].(*v1.UpdateContainerResourcesResponse)
   568  	ret1, _ := ret[1].(error)
   569  	return ret0, ret1
   570  }
   571  
   572  // UpdateContainerResources indicates an expected call of UpdateContainerResources.
   573  func (mr *MockRuntimeServiceClientMockRecorder) UpdateContainerResources(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   574  	mr.mock.ctrl.T.Helper()
   575  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   576  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerResources", reflect.TypeOf((*MockRuntimeServiceClient)(nil).UpdateContainerResources), varargs...)
   577  }
   578  
   579  // UpdateRuntimeConfig mocks base method.
   580  func (m *MockRuntimeServiceClient) UpdateRuntimeConfig(arg0 context.Context, arg1 *v1.UpdateRuntimeConfigRequest, arg2 ...grpc.CallOption) (*v1.UpdateRuntimeConfigResponse, error) {
   581  	m.ctrl.T.Helper()
   582  	varargs := []interface{}{arg0, arg1}
   583  	for _, a := range arg2 {
   584  		varargs = append(varargs, a)
   585  	}
   586  	ret := m.ctrl.Call(m, "UpdateRuntimeConfig", varargs...)
   587  	ret0, _ := ret[0].(*v1.UpdateRuntimeConfigResponse)
   588  	ret1, _ := ret[1].(error)
   589  	return ret0, ret1
   590  }
   591  
   592  // UpdateRuntimeConfig indicates an expected call of UpdateRuntimeConfig.
   593  func (mr *MockRuntimeServiceClientMockRecorder) UpdateRuntimeConfig(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   594  	mr.mock.ctrl.T.Helper()
   595  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   596  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRuntimeConfig", reflect.TypeOf((*MockRuntimeServiceClient)(nil).UpdateRuntimeConfig), varargs...)
   597  }
   598  
   599  // Version mocks base method.
   600  func (m *MockRuntimeServiceClient) Version(arg0 context.Context, arg1 *v1.VersionRequest, arg2 ...grpc.CallOption) (*v1.VersionResponse, error) {
   601  	m.ctrl.T.Helper()
   602  	varargs := []interface{}{arg0, arg1}
   603  	for _, a := range arg2 {
   604  		varargs = append(varargs, a)
   605  	}
   606  	ret := m.ctrl.Call(m, "Version", varargs...)
   607  	ret0, _ := ret[0].(*v1.VersionResponse)
   608  	ret1, _ := ret[1].(error)
   609  	return ret0, ret1
   610  }
   611  
   612  // Version indicates an expected call of Version.
   613  func (mr *MockRuntimeServiceClientMockRecorder) Version(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   614  	mr.mock.ctrl.T.Helper()
   615  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   616  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockRuntimeServiceClient)(nil).Version), varargs...)
   617  }
   618  

View as plain text