chore(mock): update mock

mock/storage/mock_client.gen.go

@@ -56,6 +56,106 @@ func (mr *MockCommServerClientMockRecorder) Add(ctx, in interface{}, opts ...int
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockCommServerClient)(nil).Add), varargs...)
 }
 
+// CClean mocks base method.
+func (m *MockCommServerClient) CClean(ctx context.Context, in *proto.CCleanRequest, opts ...grpc.CallOption) (*proto.CCleanResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CClean", varargs...)
+	ret0, _ := ret[0].(*proto.CCleanResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CClean indicates an expected call of CClean.
+func (mr *MockCommServerClientMockRecorder) CClean(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CClean", reflect.TypeOf((*MockCommServerClient)(nil).CClean), varargs...)
+}
+
+// CLen mocks base method.
+func (m *MockCommServerClient) CLen(ctx context.Context, in *proto.CLenRequest, opts ...grpc.CallOption) (*proto.CLenResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CLen", varargs...)
+	ret0, _ := ret[0].(*proto.CLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CLen indicates an expected call of CLen.
+func (mr *MockCommServerClientMockRecorder) CLen(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CLen", reflect.TypeOf((*MockCommServerClient)(nil).CLen), varargs...)
+}
+
+// CMake mocks base method.
+func (m *MockCommServerClient) CMake(ctx context.Context, in *proto.CMakeRequest, opts ...grpc.CallOption) (*proto.CMakeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CMake", varargs...)
+	ret0, _ := ret[0].(*proto.CMakeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CMake indicates an expected call of CMake.
+func (mr *MockCommServerClientMockRecorder) CMake(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMake", reflect.TypeOf((*MockCommServerClient)(nil).CMake), varargs...)
+}
+
+// CPop mocks base method.
+func (m *MockCommServerClient) CPop(ctx context.Context, in *proto.CPopRequest, opts ...grpc.CallOption) (*proto.CPopResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CPop", varargs...)
+	ret0, _ := ret[0].(*proto.CPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CPop indicates an expected call of CPop.
+func (mr *MockCommServerClientMockRecorder) CPop(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CPop", reflect.TypeOf((*MockCommServerClient)(nil).CPop), varargs...)
+}
+
+// CPush mocks base method.
+func (m *MockCommServerClient) CPush(ctx context.Context, in *proto.CPushRequest, opts ...grpc.CallOption) (*proto.CPushResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CPush", varargs...)
+	ret0, _ := ret[0].(*proto.CPushResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CPush indicates an expected call of CPush.
+func (mr *MockCommServerClientMockRecorder) CPush(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CPush", reflect.TypeOf((*MockCommServerClient)(nil).CPush), varargs...)
+}
+
 // Get mocks base method.
 func (m *MockCommServerClient) Get(ctx context.Context, in *proto.GetRequest, opts ...grpc.CallOption) (*proto.GetResponse, error) {
 	m.ctrl.T.Helper()
@@ -954,6 +1054,81 @@ func (mr *MockCommServerServerMockRecorder) Add(arg0, arg1 interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockCommServerServer)(nil).Add), arg0, arg1)
 }
 
+// CClean mocks base method.
+func (m *MockCommServerServer) CClean(arg0 context.Context, arg1 *proto.CCleanRequest) (*proto.CCleanResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CClean", arg0, arg1)
+	ret0, _ := ret[0].(*proto.CCleanResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CClean indicates an expected call of CClean.
+func (mr *MockCommServerServerMockRecorder) CClean(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CClean", reflect.TypeOf((*MockCommServerServer)(nil).CClean), arg0, arg1)
+}
+
+// CLen mocks base method.
+func (m *MockCommServerServer) CLen(arg0 context.Context, arg1 *proto.CLenRequest) (*proto.CLenResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CLen", arg0, arg1)
+	ret0, _ := ret[0].(*proto.CLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CLen indicates an expected call of CLen.
+func (mr *MockCommServerServerMockRecorder) CLen(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CLen", reflect.TypeOf((*MockCommServerServer)(nil).CLen), arg0, arg1)
+}
+
+// CMake mocks base method.
+func (m *MockCommServerServer) CMake(arg0 context.Context, arg1 *proto.CMakeRequest) (*proto.CMakeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CMake", arg0, arg1)
+	ret0, _ := ret[0].(*proto.CMakeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CMake indicates an expected call of CMake.
+func (mr *MockCommServerServerMockRecorder) CMake(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMake", reflect.TypeOf((*MockCommServerServer)(nil).CMake), arg0, arg1)
+}
+
+// CPop mocks base method.
+func (m *MockCommServerServer) CPop(arg0 context.Context, arg1 *proto.CPopRequest) (*proto.CPopResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CPop", arg0, arg1)
+	ret0, _ := ret[0].(*proto.CPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CPop indicates an expected call of CPop.
+func (mr *MockCommServerServerMockRecorder) CPop(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CPop", reflect.TypeOf((*MockCommServerServer)(nil).CPop), arg0, arg1)
+}
+
+// CPush mocks base method.
+func (m *MockCommServerServer) CPush(arg0 context.Context, arg1 *proto.CPushRequest) (*proto.CPushResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CPush", arg0, arg1)
+	ret0, _ := ret[0].(*proto.CPushResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CPush indicates an expected call of CPush.
+func (mr *MockCommServerServerMockRecorder) CPush(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CPush", reflect.TypeOf((*MockCommServerServer)(nil).CPush), arg0, arg1)
+}
+
 // Get mocks base method.
 func (m *MockCommServerServer) Get(arg0 context.Context, arg1 *proto.GetRequest) (*proto.GetResponse, error) {
 	m.ctrl.T.Helper()