move gotd fork into repo. (#111)

- update to latest telegram layer
- remove some references to fields in tg.Entities that don't exist in
the schema
- originally added here:
https://github.com/beeper/td/commit/820929062a2ba0104397bc01235ab58a9cff780e
  - referenced here
-
https://github.com/mautrix/telegramgo/commit/124f0967ed195b5a380c9bd02e170ada9710dde3
-
https://github.com/mautrix/telegramgo/commit/4205047aab2e0639217148b5d125bfaab668bd8e

pkg/gotd/telegram/internal/e2etest/auth.go

@@ -0,0 +1,58 @@
+package e2etest
+
+import (
+	"context"
+
+	"github.com/cenkalti/backoff/v4"
+	"github.com/go-faster/errors"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram/auth"
+)
+
+func (s *Suite) createFlow(ctx context.Context) (auth.Flow, error) {
+	var ua auth.UserAuthenticator
+	for {
+		ua = auth.Test(s.rand, s.dc)
+		phone, err := ua.Phone(ctx)
+		if err != nil {
+			return auth.Flow{}, err
+		}
+
+		s.usedMux.Lock()
+		if _, ok := s.used[phone]; !ok {
+			s.used[phone] = struct{}{}
+			s.usedMux.Unlock()
+			break
+		}
+		s.usedMux.Unlock()
+	}
+
+	return auth.NewFlow(ua, auth.SendCodeOptions{}), nil
+}
+
+// Authenticate authenticates client on test server.
+func (s *Suite) Authenticate(ctx context.Context, client auth.FlowClient) error {
+	for {
+		flow, err := s.createFlow(ctx)
+		if err != nil {
+			return errors.Wrap(err, "create flow")
+		}
+
+		if err := flow.Run(ctx, client); err != nil {
+			if errors.Is(err, auth.ErrPasswordNotProvided) {
+				continue
+			}
+
+			return errors.Wrap(err, "run flow")
+		}
+		return nil
+	}
+}
+
+// RetryAuthenticate authenticates client on test server.
+func (s *Suite) RetryAuthenticate(ctx context.Context, client auth.FlowClient) error {
+	bck := backoff.WithContext(backoff.NewExponentialBackOff(), ctx)
+	return backoff.Retry(func() error {
+		return s.Authenticate(ctx, client)
+	}, bck)
+}

pkg/gotd/telegram/internal/e2etest/auth_test.go

@@ -0,0 +1,61 @@
+package e2etest
+
+import (
+	"context"
+	"testing"
+
+	"github.com/go-faster/errors"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zaptest"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram/auth"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tg"
+)
+
+type mockFlow struct {
+	flag bool
+}
+
+var _ auth.FlowClient = &mockFlow{}
+
+func (m *mockFlow) SignIn(context.Context, string, string, string) (*tg.AuthAuthorization, error) {
+	// Ensure retry.
+	if !m.flag {
+		m.flag = true
+		return nil, auth.ErrPasswordAuthNeeded
+	}
+
+	return m.Password(context.Background(), "")
+}
+
+func (m *mockFlow) SendCode(context.Context, string, auth.SendCodeOptions) (tg.AuthSentCodeClass, error) {
+	return &tg.AuthSentCode{
+		PhoneCodeHash: "hash",
+		Type:          &tg.AuthSentCodeTypeApp{},
+		Timeout:       10,
+	}, nil
+}
+
+func (m *mockFlow) Password(context.Context, string) (*tg.AuthAuthorization, error) {
+	return &tg.AuthAuthorization{
+		User: &tg.User{
+			ID:       10,
+			Username: "aboba",
+		},
+	}, nil
+}
+
+func (m *mockFlow) SignUp(context.Context, auth.SignUp) (*tg.AuthAuthorization, error) {
+	return nil, errors.New("must not be called")
+}
+
+func TestSuite_Authenticate(t *testing.T) {
+	ctx := context.Background()
+	logger := zaptest.NewLogger(t)
+	s := NewSuite(t, TestOptions{
+		Logger: logger,
+	})
+
+	flow := &mockFlow{}
+	require.NoError(t, s.Authenticate(ctx, flow))
+}

pkg/gotd/telegram/internal/e2etest/e2etest.go

@@ -0,0 +1,3 @@
+// Package e2etest contains some helpers to make external E2E tests
+// using Telegram test server.
+package e2etest

pkg/gotd/telegram/internal/e2etest/echo_bot.go

@@ -0,0 +1,190 @@
+package e2etest
+
+import (
+	"context"
+	"strconv"
+	"sync"
+
+	"github.com/go-faster/errors"
+	"go.uber.org/zap"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram/message"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tg"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tgerr"
+)
+
+// EchoBot is a simple echo message bot.
+type EchoBot struct {
+	suite *Suite
+
+	logger *zap.Logger
+	auth   chan<- *tg.User
+}
+
+// NewEchoBot creates new echo bot.
+func NewEchoBot(suite *Suite, auth chan<- *tg.User) EchoBot {
+	return EchoBot{
+		suite:  suite,
+		logger: suite.logger.Named("echobot"),
+		auth:   auth,
+	}
+}
+
+type users struct {
+	users map[int64]*tg.User
+	lock  sync.RWMutex
+}
+
+func newUsers() *users {
+	return &users{
+		users: map[int64]*tg.User{},
+	}
+}
+
+func (m *users) empty() (r bool) {
+	m.lock.RLock()
+	r = len(m.users) < 1
+	m.lock.RUnlock()
+	return
+}
+
+func (m *users) add(list ...tg.UserClass) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	tg.UserClassArray(list).FillNotEmptyMap(m.users)
+}
+
+func (m *users) get(id int64) (r *tg.User) {
+	m.lock.RLock()
+	r = m.users[id]
+	m.lock.RUnlock()
+
+	return
+}
+
+func (b EchoBot) login(ctx context.Context, client *telegram.Client) (*tg.User, error) {
+	if err := b.suite.RetryAuthenticate(ctx, client.Auth()); err != nil {
+		return nil, errors.Wrap(err, "authenticate")
+	}
+
+	var me *tg.User
+	if err := retry(ctx, func() (err error) {
+		me, err = client.Self(ctx)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	expectedUsername := "echobot" + strconv.FormatInt(me.ID, 10)
+	raw := tg.NewClient(retryInvoker{prev: client})
+	_, err := raw.AccountUpdateUsername(ctx, expectedUsername)
+	if err != nil {
+		if !tgerr.Is(err, tg.ErrUsernameNotModified) {
+			return nil, errors.Wrap(err, "update username")
+		}
+	}
+	me, err = retryResult(ctx, func() (*tg.User, error) {
+		return client.Self(ctx)
+	})
+	if me.Username != expectedUsername {
+		return nil, errors.Errorf("expected username %q, got %q", expectedUsername, me.Username)
+	}
+
+	return me, nil
+}
+
+func (b EchoBot) handler(client *telegram.Client) tg.NewMessageHandler {
+	dialogsUsers := newUsers()
+
+	raw := tg.NewClient(client)
+	sender := message.NewSender(raw)
+	return func(ctx context.Context, entities tg.Entities, update *tg.UpdateNewMessage) error {
+		if filterMessage(update) {
+			return nil
+		}
+
+		if m, ok := update.Message.(interface{ GetMessage() string }); ok {
+			b.logger.Named("dispatcher").
+				Info("Got new message update", zap.String("message", m.GetMessage()))
+		}
+
+		if dialogsUsers.empty() {
+			dialogs, err := retryResult(ctx, func() (tg.MessagesDialogsClass, error) {
+				dialogs, err := raw.MessagesGetDialogs(ctx, &tg.MessagesGetDialogsRequest{
+					Limit:      100,
+					OffsetPeer: &tg.InputPeerEmpty{},
+				})
+				if err != nil {
+					return nil, errors.Wrap(err, "get dialogs")
+				}
+				return dialogs, nil
+			})
+			if err != nil {
+				return errors.Wrap(err, "get dialogs")
+			}
+			if dlg, ok := dialogs.AsModified(); ok {
+				dialogsUsers.add(dlg.GetUsers()...)
+			}
+		}
+
+		switch m := update.Message.(type) {
+		case *tg.Message:
+			switch peer := m.PeerID.(type) {
+			case *tg.PeerUser:
+				user := entities.Users[peer.UserID]
+				if user == nil {
+					user = dialogsUsers.get(peer.UserID)
+				}
+
+				b.logger.Info("Got message",
+					zap.String("text", m.Message),
+					zap.Int64("user_id", user.ID),
+					zap.String("user_first_name", user.FirstName),
+					zap.String("username", user.Username),
+				)
+
+				if err := retry(ctx, func() error {
+					_, err := sender.To(user.AsInputPeer()).Text(ctx, m.Message)
+					return err
+				}); err != nil {
+					return errors.Wrap(err, "send message")
+				}
+				return nil
+			}
+		}
+
+		return nil
+	}
+}
+
+// Run setups and starts echo bot.
+func (b EchoBot) Run(ctx context.Context) error {
+	dispatcher := tg.NewUpdateDispatcher()
+	client := b.suite.Client(b.logger, dispatcher)
+	dispatcher.OnNewMessage(b.handler(client))
+
+	return client.Run(ctx, func(ctx context.Context) error {
+		defer close(b.auth)
+
+		me, err := b.login(ctx, client)
+		if err != nil {
+			return errors.Wrap(err, "login")
+		}
+
+		b.logger.Info("Logged in",
+			zap.String("user", me.Username),
+			zap.Int64("id", me.ID),
+		)
+
+		select {
+		case b.auth <- me:
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+
+		<-ctx.Done()
+		return nil
+	})
+}

pkg/gotd/telegram/internal/e2etest/filter.go

@@ -0,0 +1,25 @@
+package e2etest
+
+import (
+	"strings"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tg"
+)
+
+func filterMessage(update *tg.UpdateNewMessage) bool {
+	if v, ok := update.Message.(interface{ GetOut() bool }); ok && v.GetOut() {
+		return true
+	}
+
+	if v, ok := update.Message.(interface{ GetPeerID() tg.PeerClass }); ok && v.GetPeerID() == nil {
+		return true
+	}
+	if _, ok := update.Message.(*tg.MessageService); ok {
+		return true
+	}
+	if v, ok := update.Message.(interface{ GetMessage() string }); ok && strings.HasPrefix(v.GetMessage(), "Login code:") {
+		return true
+	}
+
+	return false
+}

pkg/gotd/telegram/internal/e2etest/options.go

@@ -0,0 +1,37 @@
+package e2etest
+
+import (
+	"io"
+
+	"go.uber.org/zap"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/constant"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/crypto"
+)
+
+// TestOptions contains some common test server settings.
+type TestOptions struct {
+	AppID   int
+	AppHash string
+	DC      int
+	Random  io.Reader
+	Logger  *zap.Logger
+}
+
+func (opt *TestOptions) setDefaults() {
+	if opt.AppID == 0 {
+		opt.AppID = constant.TestAppID
+	}
+	if opt.AppHash == "" {
+		opt.AppHash = constant.TestAppHash
+	}
+	if opt.DC == 0 {
+		opt.DC = 2
+	}
+	if opt.Random == nil {
+		opt.Random = crypto.DefaultRand()
+	}
+	if opt.Logger == nil {
+		opt.Logger = zap.NewNop()
+	}
+}

pkg/gotd/telegram/internal/e2etest/retry.go

@@ -0,0 +1,61 @@
+package e2etest
+
+import (
+	"context"
+	"time"
+
+	"github.com/cenkalti/backoff/v4"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/bin"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tg"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tgerr"
+)
+
+type retryInvoker struct {
+	prev tg.Invoker
+}
+
+func retryResult[T any](ctx context.Context, cb func() (T, error)) (T, error) {
+	var zero T
+	return backoff.RetryWithData[T](func() (T, error) {
+		res, err := cb()
+		if err != nil {
+			if tgerr.IsCode(err, -500) {
+				return zero, err
+			}
+			if tgerr.Is(err, "CONNECTION_NOT_INITED") {
+				return zero, err
+			}
+			if ok, err := tgerr.FloodWait(ctx, err); ok {
+				return zero, err
+			}
+			return zero, backoff.Permanent(err)
+		}
+		return res, nil
+	}, backoff.WithContext(backoff.NewConstantBackOff(time.Millisecond*500), ctx))
+}
+
+func retry(ctx context.Context, cb func() error) error {
+	return backoff.Retry(func() error {
+		if err := cb(); err != nil {
+			if tgerr.IsCode(err, -500) {
+				return err
+			}
+			if tgerr.Is(err, "CONNECTION_NOT_INITED") {
+				return err
+			}
+			if ok, err := tgerr.FloodWait(ctx, err); ok {
+				return err
+			}
+			return backoff.Permanent(err)
+		}
+
+		return nil
+	}, backoff.WithContext(backoff.NewExponentialBackOff(), ctx))
+}
+
+func (w retryInvoker) Invoke(ctx context.Context, input bin.Encoder, output bin.Decoder) error {
+	return retry(ctx, func() error {
+		return w.prev.Invoke(ctx, input, output)
+	})
+}

pkg/gotd/telegram/internal/e2etest/suite.go

@@ -0,0 +1,50 @@
+package e2etest
+
+import (
+	"io"
+	"sync"
+
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram/dcs"
+)
+
+// Suite is struct which contains external E2E test parameters.
+type Suite struct {
+	TB      require.TestingT
+	appID   int
+	appHash string
+	dc      int
+	logger  *zap.Logger
+
+	rand io.Reader
+	// already used phone numbers
+	used    map[string]struct{}
+	usedMux sync.Mutex
+}
+
+// NewSuite creates new Suite.
+func NewSuite(tb require.TestingT, config TestOptions) *Suite {
+	config.setDefaults()
+	return &Suite{
+		TB:      tb,
+		appID:   config.AppID,
+		appHash: config.AppHash,
+		dc:      config.DC,
+		logger:  config.Logger,
+		rand:    config.Random,
+		used:    map[string]struct{}{},
+	}
+}
+
+// Client creates new *telegram.Client using this suite.
+func (s *Suite) Client(logger *zap.Logger, handler telegram.UpdateHandler) *telegram.Client {
+	return telegram.NewClient(s.appID, s.appHash, telegram.Options{
+		DC:            s.dc,
+		DCList:        dcs.Test(),
+		Logger:        logger,
+		UpdateHandler: handler,
+	})
+}

pkg/gotd/telegram/internal/e2etest/terentyev.go

@@ -0,0 +1,98 @@
+package e2etest
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-faster/errors"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+
+	"go.mau.fi/mautrix-telegram/pkg/gotd/telegram/message"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tg"
+	"go.mau.fi/mautrix-telegram/pkg/gotd/tgerr"
+)
+
+// User is a simple user bot.
+type User struct {
+	suite    *Suite
+	text     []string
+	username string
+
+	logger  *zap.Logger
+	message chan string
+}
+
+// NewUser creates new User bot.
+func NewUser(suite *Suite, text []string, username string) User {
+	return User{
+		suite:    suite,
+		text:     text,
+		username: username,
+		logger:   suite.logger.Named("terentyev"),
+		message:  make(chan string, 1),
+	}
+}
+
+func (u User) messageHandler(ctx context.Context, entities tg.Entities, update *tg.UpdateNewMessage) error {
+	if filterMessage(update) {
+		return nil
+	}
+
+	if m, ok := update.Message.(interface{ GetMessage() string }); ok {
+		u.logger.Named("dispatcher").
+			Info("Got new message update", zap.String("message", m.GetMessage()))
+	}
+
+	msg, ok := update.Message.(*tg.Message)
+	if !ok {
+		return errors.Errorf("unexpected type %T", update.Message)
+	}
+
+	select {
+	case u.message <- msg.Message:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// Run setups and starts user bot.
+func (u User) Run(ctx context.Context) error {
+	dispatcher := tg.NewUpdateDispatcher()
+	dispatcher.OnNewMessage(u.messageHandler)
+	client := u.suite.Client(u.logger, dispatcher)
+	sender := message.NewSender(tg.NewClient(retryInvoker{prev: client}))
+
+	return client.Run(ctx, func(ctx context.Context) error {
+		if err := u.suite.RetryAuthenticate(ctx, client.Auth()); err != nil {
+			return errors.Wrap(err, "authenticate")
+		}
+
+		peer, err := sender.Resolve(u.username).AsInputPeer(ctx)
+		if err != nil {
+			return errors.Wrapf(err, "resolve bot username %q", u.username)
+		}
+
+		for _, line := range u.text {
+			time.Sleep(2 * time.Second)
+
+			_, err = sender.To(peer).Text(ctx, line)
+			if flood, err := tgerr.FloodWait(ctx, err); err != nil {
+				if flood {
+					continue
+				}
+				return err
+			}
+
+			select {
+			case gotMessage := <-u.message:
+				require.Equal(u.suite.TB, line, gotMessage)
+			case <-ctx.Done():
+				return ctx.Err()
+			}
+		}
+
+		return nil
+	})
+}