mirror of
https://github.com/ProtonMail/proton-bridge.git
synced 2025-12-10 12:46:46 +00:00
343 lines
8.7 KiB
Go
343 lines
8.7 KiB
Go
// Copyright (c) 2022 Proton AG
|
|
//
|
|
// This file is part of Proton Mail Bridge.
|
|
//
|
|
// Proton Mail Bridge is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Proton Mail Bridge is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package tests
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/smtp"
|
|
"regexp"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/Masterminds/semver/v3"
|
|
"github.com/ProtonMail/gluon/queue"
|
|
"github.com/ProtonMail/go-proton-api"
|
|
"github.com/ProtonMail/go-proton-api/server"
|
|
"github.com/ProtonMail/proton-bridge/v2/internal/bridge"
|
|
frontend "github.com/ProtonMail/proton-bridge/v2/internal/frontend/grpc"
|
|
"github.com/ProtonMail/proton-bridge/v2/internal/locations"
|
|
"github.com/bradenaw/juniper/xslices"
|
|
"github.com/emersion/go-imap/client"
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/sirupsen/logrus"
|
|
"golang.org/x/exp/maps"
|
|
"google.golang.org/grpc"
|
|
)
|
|
|
|
var defaultVersion = semver.MustParse("1.0.0")
|
|
|
|
type testCtx struct {
|
|
// These are the objects supporting the test.
|
|
dir string
|
|
api API
|
|
netCtl *proton.NetCtl
|
|
locator *locations.Locations
|
|
storeKey []byte
|
|
version *semver.Version
|
|
mocks *bridge.Mocks
|
|
events *eventCollector
|
|
reporter *reportRecorder
|
|
|
|
// bridge holds the bridge app under test.
|
|
bridge *bridge.Bridge
|
|
|
|
// service holds the gRPC frontend service under test.
|
|
service *frontend.Service
|
|
serviceWG sync.WaitGroup
|
|
|
|
// client holds the gRPC frontend client under test.
|
|
client frontend.BridgeClient
|
|
clientConn *grpc.ClientConn
|
|
clientEventCh *queue.QueuedChannel[*frontend.StreamEvent]
|
|
|
|
// These maps hold expected userIDByName, their primary addresses and bridge passwords.
|
|
userIDByName map[string]string
|
|
userAddrByEmail map[string]map[string]string
|
|
userPassByID map[string]string
|
|
userBridgePassByID map[string][]byte
|
|
|
|
// These are the IMAP and SMTP clients used to connect to bridge.
|
|
imapClients map[string]*imapClient
|
|
smtpClients map[string]*smtpClient
|
|
|
|
// calls holds calls made to the API during each step of the test.
|
|
calls [][]server.Call
|
|
callsLock sync.RWMutex
|
|
|
|
// errors holds test-related errors encountered while running test steps.
|
|
errors [][]error
|
|
errorsLock sync.RWMutex
|
|
}
|
|
|
|
type imapClient struct {
|
|
userID string
|
|
client *client.Client
|
|
}
|
|
|
|
type smtpClient struct {
|
|
userID string
|
|
client *smtp.Client
|
|
}
|
|
|
|
func newTestCtx(tb testing.TB) *testCtx {
|
|
dir := tb.TempDir()
|
|
|
|
t := &testCtx{
|
|
dir: dir,
|
|
api: newFakeAPI(),
|
|
netCtl: proton.NewNetCtl(),
|
|
locator: locations.New(bridge.NewTestLocationsProvider(dir), "config-name"),
|
|
storeKey: []byte("super-secret-store-key"),
|
|
version: defaultVersion,
|
|
mocks: bridge.NewMocks(tb, defaultVersion, defaultVersion),
|
|
events: newEventCollector(),
|
|
reporter: newReportRecorder(tb),
|
|
|
|
userIDByName: make(map[string]string),
|
|
userAddrByEmail: make(map[string]map[string]string),
|
|
userPassByID: make(map[string]string),
|
|
userBridgePassByID: make(map[string][]byte),
|
|
|
|
imapClients: make(map[string]*imapClient),
|
|
smtpClients: make(map[string]*smtpClient),
|
|
}
|
|
|
|
t.api.AddCallWatcher(func(call server.Call) {
|
|
t.callsLock.Lock()
|
|
defer t.callsLock.Unlock()
|
|
|
|
t.calls[len(t.calls)-1] = append(t.calls[len(t.calls)-1], call)
|
|
})
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *testCtx) beforeStep() {
|
|
t.callsLock.Lock()
|
|
defer t.callsLock.Unlock()
|
|
|
|
t.errorsLock.Lock()
|
|
defer t.errorsLock.Unlock()
|
|
|
|
t.calls = append(t.calls, nil)
|
|
t.errors = append(t.errors, nil)
|
|
}
|
|
|
|
func (t *testCtx) getName(wantUserID string) string {
|
|
for name, userID := range t.userIDByName {
|
|
if userID == wantUserID {
|
|
return name
|
|
}
|
|
}
|
|
|
|
panic(fmt.Sprintf("unknown user ID %q", wantUserID))
|
|
}
|
|
|
|
func (t *testCtx) getUserID(username string) string {
|
|
return t.userIDByName[username]
|
|
}
|
|
|
|
func (t *testCtx) setUserID(username, userID string) {
|
|
t.userIDByName[username] = userID
|
|
}
|
|
|
|
func (t *testCtx) getUserAddrID(userID, email string) string {
|
|
return t.userAddrByEmail[userID][email]
|
|
}
|
|
|
|
func (t *testCtx) getUserAddrs(userID string) []string {
|
|
return maps.Keys(t.userAddrByEmail[userID])
|
|
}
|
|
|
|
func (t *testCtx) setUserAddr(userID, addrID, email string) {
|
|
if _, ok := t.userAddrByEmail[userID]; !ok {
|
|
t.userAddrByEmail[userID] = make(map[string]string)
|
|
}
|
|
|
|
t.userAddrByEmail[userID][email] = addrID
|
|
}
|
|
|
|
func (t *testCtx) unsetUserAddr(userID, wantAddrID string) {
|
|
for email, addrID := range t.userAddrByEmail[userID] {
|
|
if addrID == wantAddrID {
|
|
delete(t.userAddrByEmail[userID], email)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (t *testCtx) getUserPass(userID string) string {
|
|
return t.userPassByID[userID]
|
|
}
|
|
|
|
func (t *testCtx) setUserPass(userID, pass string) {
|
|
t.userPassByID[userID] = pass
|
|
}
|
|
|
|
func (t *testCtx) getUserBridgePass(userID string) string {
|
|
return string(t.userBridgePassByID[userID])
|
|
}
|
|
|
|
func (t *testCtx) setUserBridgePass(userID string, pass []byte) {
|
|
t.userBridgePassByID[userID] = pass
|
|
}
|
|
|
|
func (t *testCtx) getMBoxID(userID string, name string) string {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
var labelID string
|
|
|
|
if err := t.withClient(ctx, t.getName(userID), func(ctx context.Context, client *proton.Client) error {
|
|
labels, err := client.GetLabels(ctx, proton.LabelTypeLabel, proton.LabelTypeFolder, proton.LabelTypeSystem)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
idx := xslices.IndexFunc(labels, func(label proton.Label) bool {
|
|
return label.Name == name
|
|
})
|
|
|
|
if idx < 0 {
|
|
panic(fmt.Errorf("label %q not found", name))
|
|
}
|
|
|
|
labelID = labels[idx].ID
|
|
|
|
return nil
|
|
}); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return labelID
|
|
}
|
|
|
|
// getDraftID will return the API ID of draft message with draftIndex, where
|
|
// draftIndex is similar to sequential ID i.e. 1 represents the first message
|
|
// of draft folder sorted by API creation time.
|
|
func (t *testCtx) getDraftID(username string, draftIndex int) string {
|
|
if draftIndex < 1 {
|
|
panic(fmt.Sprintf("draft index suppose to be non-zero positive integer, but have %d", draftIndex))
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
var draftID string
|
|
|
|
if err := t.withClient(ctx, username, func(ctx context.Context, client *proton.Client) error {
|
|
messages, err := client.GetMessageMetadata(
|
|
ctx, proton.MessageFilter{LabelID: proton.DraftsLabel},
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if len(messages) < draftIndex {
|
|
panic("draft index too high")
|
|
}
|
|
|
|
draftID = messages[draftIndex-1].ID
|
|
|
|
return nil
|
|
}); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return draftID
|
|
}
|
|
|
|
func (t *testCtx) getLastCall(method, pathExp string) (server.Call, error) {
|
|
t.callsLock.RLock()
|
|
defer t.callsLock.RUnlock()
|
|
|
|
if matches := xslices.Filter(xslices.Join(t.calls...), func(call server.Call) bool {
|
|
return call.Method == method && regexp.MustCompile("^"+pathExp+"$").MatchString(call.URL.Path)
|
|
}); len(matches) > 0 {
|
|
return matches[len(matches)-1], nil
|
|
}
|
|
|
|
return server.Call{}, fmt.Errorf("no call with method %q and path %q was made", method, pathExp)
|
|
}
|
|
|
|
func (t *testCtx) pushError(err error) {
|
|
t.errorsLock.Lock()
|
|
defer t.errorsLock.Unlock()
|
|
|
|
t.errors[len(t.errors)-1] = append(t.errors[len(t.errors)-1], err)
|
|
}
|
|
|
|
func (t *testCtx) getLastError() error {
|
|
t.errorsLock.RLock()
|
|
defer t.errorsLock.RUnlock()
|
|
|
|
if lastStep := t.errors[len(t.errors)-2]; len(lastStep) > 0 {
|
|
return lastStep[len(lastStep)-1]
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (t *testCtx) close(ctx context.Context) {
|
|
for _, client := range t.imapClients {
|
|
if err := client.client.Logout(); err != nil {
|
|
logrus.WithError(err).Error("Failed to logout IMAP client")
|
|
}
|
|
}
|
|
|
|
for _, client := range t.smtpClients {
|
|
if err := client.client.Close(); err != nil {
|
|
logrus.WithError(err).Error("Failed to close SMTP client")
|
|
}
|
|
}
|
|
|
|
if t.service != nil {
|
|
if err := t.closeFrontendService(ctx); err != nil {
|
|
logrus.WithError(err).Error("Failed to close frontend service")
|
|
}
|
|
}
|
|
|
|
if t.client != nil {
|
|
if err := t.closeFrontendClient(); err != nil {
|
|
logrus.WithError(err).Error("Failed to close frontend client")
|
|
}
|
|
}
|
|
|
|
if t.bridge != nil {
|
|
if err := t.closeBridge(ctx); err != nil {
|
|
logrus.WithError(err).Error("Failed to close bridge")
|
|
}
|
|
}
|
|
|
|
t.api.Close()
|
|
|
|
t.events.close()
|
|
|
|
t.reporter.close()
|
|
|
|
// Closed connection can happen in the end of scenario
|
|
t.reporter.removeMatchingRecords(
|
|
gomock.Eq(false),
|
|
gomock.Eq("Failed to parse imap command"),
|
|
gomock.Any(), // mocks.NewClosedConnectionMatcher(),
|
|
0,
|
|
)
|
|
|
|
t.reporter.assertEmpty()
|
|
}
|