GO-3829: add tests

Signed-off-by: AnastasiaShemyakinskaya <shem98a@mail.ru>

core/application/account_select.go

@@ -76,10 +76,6 @@ func (s *Service) AccountSelect(ctx context.Context, req *pb.RpcAccountSelectReq
 	return s.start(ctx, req.Id, req.RootPath, req.DisableLocalNetworkSync, req.PreferYamuxTransport, req.NetworkMode, req.NetworkCustomConfigFilePath)
 }
 
-type flusher interface {
-	Flush()
-}
-
 func (s *Service) start(ctx context.Context, id string, rootPath string, disableLocalNetworkSync bool, preferYamux bool, networkMode pb.RpcAccountNetworkMode, networkConfigFilePath string) (*model.Account, error) {
 	ctx, task := trace2.NewTask(ctx, "application.start")
 	defer task.End()

core/event/event_test.go

@@ -0,0 +1,149 @@
+package event
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+
+	"github.com/anyproto/anytype-heart/pb"
+)
+
+type mockServerSender struct {
+	grpc.ServerStream
+	callback func()
+}
+
+func (m *mockServerSender) Send(e *pb.Event) error {
+	m.callback()
+	return nil
+}
+
+func TestGrpcSender_Flush(t *testing.T) {
+	t.Run("events already flushed", func(t *testing.T) {
+		// given
+		sender := NewGrpcSender()
+		sender.flushed = true
+		server := &mockServerSender{}
+		var called bool
+		server.callback = func() {
+			called = true
+		}
+		sender.Servers = map[string]SessionServer{"token": {
+			Token:  "token",
+			Server: server,
+		}}
+
+		// when
+		sender.Flush()
+
+		// then
+		assert.False(t, called)
+	})
+	t.Run("no event", func(t *testing.T) {
+		// given
+		sender := NewGrpcSender()
+		server := &mockServerSender{}
+		var called bool
+		server.callback = func() {
+			called = true
+		}
+		sender.Servers = map[string]SessionServer{"token": {
+			Token:  "token",
+			Server: server,
+		}}
+
+		// when
+		sender.Flush()
+
+		// then
+		assert.False(t, called)
+		assert.True(t, sender.flushed)
+	})
+	t.Run("flush event", func(t *testing.T) {
+		// given
+		sender := NewGrpcSender()
+		server := &mockServerSender{}
+		done := make(chan struct{})
+		server.callback = func() {
+			close(done)
+		}
+		sender.Servers = map[string]SessionServer{"token": {
+			Token:  "token",
+			Server: server,
+		}}
+		sender.sessionEvents = map[string][]*pb.Event{"token": {{}}}
+
+		// when
+		sender.Flush()
+		<-done
+
+		// then
+		assert.True(t, sender.flushed)
+	})
+	t.Run("no servers", func(t *testing.T) {
+		// given
+		sender := NewGrpcSender()
+		server := &mockServerSender{}
+		var called bool
+		server.callback = func() {
+			called = true
+		}
+		sender.sessionEvents = map[string][]*pb.Event{"token": {{}}}
+
+		// when
+		sender.Flush()
+
+		// then
+		assert.True(t, sender.flushed)
+		assert.False(t, called)
+	})
+}
+
+func TestCallbackSender_Flush(t *testing.T) {
+	t.Run("events already flushed", func(t *testing.T) {
+		// given
+		var called bool
+		sender := NewCallbackSender(func(event *pb.Event) {
+			called = true
+		})
+		sender.flushed = true
+
+		// when
+		sender.Flush()
+
+		// then
+		assert.False(t, called)
+	})
+	t.Run("no event", func(t *testing.T) {
+		// given
+		var called bool
+		sender := NewCallbackSender(func(event *pb.Event) {
+			called = true
+		})
+
+		// when
+		sender.Flush()
+
+		// then
+		assert.False(t, called)
+		assert.True(t, sender.flushed)
+	})
+
+	t.Run("flush event", func(t *testing.T) {
+		// given
+		done := make(chan struct{})
+		sender := NewCallbackSender(func(event *pb.Event) {
+			close(done)
+
+		})
+		sender.events = append(sender.events, &pb.Event{})
+
+		// when
+		sender.Flush()
+		<-done
+
+		// then
+		assert.True(t, sender.flushed)
+	})
+}

core/event/mock_event/mock_Sender.go

@@ -90,6 +90,38 @@ func (_c *MockSender_BroadcastToOtherSessions_Call) RunAndReturn(run func(string
 	return _c
 }
 
+// Flush provides a mock function with given fields:
+func (_m *MockSender) Flush() {
+	_m.Called()
+}
+
+// MockSender_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
+type MockSender_Flush_Call struct {
+	*mock.Call
+}
+
+// Flush is a helper method to define mock.On call
+func (_e *MockSender_Expecter) Flush() *MockSender_Flush_Call {
+	return &MockSender_Flush_Call{Call: _e.mock.On("Flush")}
+}
+
+func (_c *MockSender_Flush_Call) Run(run func()) *MockSender_Flush_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSender_Flush_Call) Return() *MockSender_Flush_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockSender_Flush_Call) RunAndReturn(run func()) *MockSender_Flush_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Init provides a mock function with given fields: a
 func (_m *MockSender) Init(a *app.App) error {
 	ret := _m.Called(a)

docs/proto.md

@@ -19002,6 +19002,7 @@ Middleware-to-front-end response, that can contain a NULL error or a non-NULL er
 | ---- | ------ | ----------- |
 | NULL | 0 |  |
 | UNKNOWN_ERROR | 1 |  |
+| BAD_INPUT | 2 |  |
 
 
 

pb/protos/commands.proto

@@ -705,6 +705,7 @@ message Rpc {
                     enum Code {
                         NULL = 0;
                         UNKNOWN_ERROR = 1;
+                        BAD_INPUT = 2;
                     }
                 }
             }