Merge branch 'feature/2849-taskfile-perxis-go' into 'master'

Обновление Taskfile

See merge request perxis/perxis-go!392

proto/mailbox/mailbox_grpc.pb.go

+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v5.29.0
+// source: mailbox/mailbox.proto
+
+package mailbox
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Mailbox_Send_FullMethodName       = "/perxis.mailbox.Mailbox/Send"
+	Mailbox_List_FullMethodName       = "/perxis.mailbox.Mailbox/List"
+	Mailbox_MarkAsRead_FullMethodName = "/perxis.mailbox.Mailbox/MarkAsRead"
+)
+
+// MailboxClient is the client API for Mailbox service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+//
+// Сервис уведомлений
+type MailboxClient interface {
+	// Отправка уведомления
+	Send(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	// Получение уведомлений, поле to в Message всегда содержит только получателя из запроса
+	List(ctx context.Context, in *ListMessageRequest, opts ...grpc.CallOption) (*ListMessageResponse, error)
+	// Пометка уведомлений как прочитанных
+	MarkAsRead(ctx context.Context, in *MarkMessagesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
+}
+
+type mailboxClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewMailboxClient(cc grpc.ClientConnInterface) MailboxClient {
+	return &mailboxClient{cc}
+}
+
+func (c *mailboxClient) Send(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, Mailbox_Send_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *mailboxClient) List(ctx context.Context, in *ListMessageRequest, opts ...grpc.CallOption) (*ListMessageResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ListMessageResponse)
+	err := c.cc.Invoke(ctx, Mailbox_List_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *mailboxClient) MarkAsRead(ctx context.Context, in *MarkMessagesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, Mailbox_MarkAsRead_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MailboxServer is the server API for Mailbox service.
+// All implementations must embed UnimplementedMailboxServer
+// for forward compatibility.
+//
+// Сервис уведомлений
+type MailboxServer interface {
+	// Отправка уведомления
+	Send(context.Context, *SendMessageRequest) (*emptypb.Empty, error)
+	// Получение уведомлений, поле to в Message всегда содержит только получателя из запроса
+	List(context.Context, *ListMessageRequest) (*ListMessageResponse, error)
+	// Пометка уведомлений как прочитанных
+	MarkAsRead(context.Context, *MarkMessagesRequest) (*emptypb.Empty, error)
+	mustEmbedUnimplementedMailboxServer()
+}
+
+// UnimplementedMailboxServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedMailboxServer struct{}
+
+func (UnimplementedMailboxServer) Send(context.Context, *SendMessageRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Send not implemented")
+}
+func (UnimplementedMailboxServer) List(context.Context, *ListMessageRequest) (*ListMessageResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
+}
+func (UnimplementedMailboxServer) MarkAsRead(context.Context, *MarkMessagesRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MarkAsRead not implemented")
+}
+func (UnimplementedMailboxServer) mustEmbedUnimplementedMailboxServer() {}
+func (UnimplementedMailboxServer) testEmbeddedByValue()                 {}
+
+// UnsafeMailboxServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MailboxServer will
+// result in compilation errors.
+type UnsafeMailboxServer interface {
+	mustEmbedUnimplementedMailboxServer()
+}
+
+func RegisterMailboxServer(s grpc.ServiceRegistrar, srv MailboxServer) {
+	// If the following call pancis, it indicates UnimplementedMailboxServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Mailbox_ServiceDesc, srv)
+}
+
+func _Mailbox_Send_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SendMessageRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MailboxServer).Send(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Mailbox_Send_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MailboxServer).Send(ctx, req.(*SendMessageRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Mailbox_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListMessageRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MailboxServer).List(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Mailbox_List_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MailboxServer).List(ctx, req.(*ListMessageRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Mailbox_MarkAsRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MarkMessagesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MailboxServer).MarkAsRead(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Mailbox_MarkAsRead_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MailboxServer).MarkAsRead(ctx, req.(*MarkMessagesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Mailbox_ServiceDesc is the grpc.ServiceDesc for Mailbox service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Mailbox_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "perxis.mailbox.Mailbox",
+	HandlerType: (*MailboxServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Send",
+			Handler:    _Mailbox_Send_Handler,
+		},
+		{
+			MethodName: "List",
+			Handler:    _Mailbox_List_Handler,
+		},
+		{
+			MethodName: "MarkAsRead",
+			Handler:    _Mailbox_MarkAsRead_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "mailbox/mailbox.proto",
+}

proto/mocks/MailboxClient.go

+// Code generated by mockery v2.50.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	grpc "google.golang.org/grpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+
+	mailbox "git.perx.ru/perxis/perxis-go/proto/mailbox"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MailboxClient is an autogenerated mock type for the MailboxClient type
+type MailboxClient struct {
+	mock.Mock
+}
+
+// List provides a mock function with given fields: ctx, in, opts
+func (_m *MailboxClient) List(ctx context.Context, in *mailbox.ListMessageRequest, opts ...grpc.CallOption) (*mailbox.ListMessageResponse, error) {
+	_va := make([]interface{}, len(opts))
+	for _i := range opts {
+		_va[_i] = opts[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, in)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for List")
+	}
+
+	var r0 *mailbox.ListMessageResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.ListMessageRequest, ...grpc.CallOption) (*mailbox.ListMessageResponse, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.ListMessageRequest, ...grpc.CallOption) *mailbox.ListMessageResponse); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*mailbox.ListMessageResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *mailbox.ListMessageRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MarkAsRead provides a mock function with given fields: ctx, in, opts
+func (_m *MailboxClient) MarkAsRead(ctx context.Context, in *mailbox.MarkMessagesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	_va := make([]interface{}, len(opts))
+	for _i := range opts {
+		_va[_i] = opts[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, in)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkAsRead")
+	}
+
+	var r0 *emptypb.Empty
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.MarkMessagesRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.MarkMessagesRequest, ...grpc.CallOption) *emptypb.Empty); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*emptypb.Empty)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *mailbox.MarkMessagesRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Send provides a mock function with given fields: ctx, in, opts
+func (_m *MailboxClient) Send(ctx context.Context, in *mailbox.SendMessageRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	_va := make([]interface{}, len(opts))
+	for _i := range opts {
+		_va[_i] = opts[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, in)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 *emptypb.Empty
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.SendMessageRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.SendMessageRequest, ...grpc.CallOption) *emptypb.Empty); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*emptypb.Empty)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *mailbox.SendMessageRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewMailboxClient creates a new instance of MailboxClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMailboxClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MailboxClient {
+	mock := &MailboxClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

proto/mocks/MailboxServer.go

+// Code generated by mockery v2.50.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	mailbox "git.perx.ru/perxis/perxis-go/proto/mailbox"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MailboxServer is an autogenerated mock type for the MailboxServer type
+type MailboxServer struct {
+	mock.Mock
+}
+
+// List provides a mock function with given fields: _a0, _a1
+func (_m *MailboxServer) List(_a0 context.Context, _a1 *mailbox.ListMessageRequest) (*mailbox.ListMessageResponse, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for List")
+	}
+
+	var r0 *mailbox.ListMessageResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.ListMessageRequest) (*mailbox.ListMessageResponse, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.ListMessageRequest) *mailbox.ListMessageResponse); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*mailbox.ListMessageResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *mailbox.ListMessageRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MarkAsRead provides a mock function with given fields: _a0, _a1
+func (_m *MailboxServer) MarkAsRead(_a0 context.Context, _a1 *mailbox.MarkMessagesRequest) (*emptypb.Empty, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkAsRead")
+	}
+
+	var r0 *emptypb.Empty
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.MarkMessagesRequest) (*emptypb.Empty, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.MarkMessagesRequest) *emptypb.Empty); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*emptypb.Empty)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *mailbox.MarkMessagesRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Send provides a mock function with given fields: _a0, _a1
+func (_m *MailboxServer) Send(_a0 context.Context, _a1 *mailbox.SendMessageRequest) (*emptypb.Empty, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 *emptypb.Empty
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.SendMessageRequest) (*emptypb.Empty, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *mailbox.SendMessageRequest) *emptypb.Empty); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*emptypb.Empty)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *mailbox.SendMessageRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// mustEmbedUnimplementedMailboxServer provides a mock function with no fields
+func (_m *MailboxServer) mustEmbedUnimplementedMailboxServer() {
+	_m.Called()
+}
+
+// NewMailboxServer creates a new instance of MailboxServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMailboxServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MailboxServer {
+	mock := &MailboxServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

proto/mocks/UnsafeMailboxServer.go

+// Code generated by mockery v2.50.0. DO NOT EDIT.
+
+package mocks
+
+import mock "github.com/stretchr/testify/mock"
+
+// UnsafeMailboxServer is an autogenerated mock type for the UnsafeMailboxServer type
+type UnsafeMailboxServer struct {
+	mock.Mock
+}
+
+// mustEmbedUnimplementedMailboxServer provides a mock function with no fields
+func (_m *UnsafeMailboxServer) mustEmbedUnimplementedMailboxServer() {
+	_m.Called()
+}
+
+// NewUnsafeMailboxServer creates a new instance of UnsafeMailboxServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewUnsafeMailboxServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *UnsafeMailboxServer {
+	mock := &UnsafeMailboxServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}