mirror of
https://github.com/ProtonMail/proton-bridge.git
synced 2025-12-10 12:46:46 +00:00
82efa16d65
This patch adds the User Event Service which is meant to replace the current event polling flow. Each user interested in receiving events should register a new subscriber using the `Service.Subscribe` function and then react on the incoming events. The current patch does not hook this up Bridge user as there are no existing consumers, but it does provide extensive testing for the expected behavior.
270 lines
10 KiB
Go
270 lines
10 KiB
Go
// Copyright (c) 2023 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 userevents
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ProtonMail/gluon/async"
|
|
"github.com/ProtonMail/go-proton-api"
|
|
"github.com/ProtonMail/proton-bridge/v3/internal/events"
|
|
mocks2 "github.com/ProtonMail/proton-bridge/v3/internal/events/mocks"
|
|
"github.com/ProtonMail/proton-bridge/v3/internal/services/userevents/mocks"
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestService_EventIDLoadStore(t *testing.T) {
|
|
// Simulate the flow of data when we start without any event id in the event id store:
|
|
// * Load event id from store
|
|
// * Get latest event id since
|
|
// * Store that latest event id
|
|
// * Start event poll loop
|
|
// * Get new event id, store it in vault
|
|
// * Try to poll new event it, but context is cancelled
|
|
group := async.NewGroup(context.Background(), &async.NoopPanicHandler{})
|
|
mockCtrl := gomock.NewController(t)
|
|
eventPublisher := mocks2.NewMockEventPublisher(mockCtrl)
|
|
eventIDStore := mocks.NewMockEventIDStore(mockCtrl)
|
|
eventSource := mocks.NewMockEventSource(mockCtrl)
|
|
|
|
firstEventID := "EVENT01"
|
|
secondEventID := "EVENT02"
|
|
secondEvent := []proton.Event{{
|
|
EventID: secondEventID,
|
|
}}
|
|
|
|
// Event id store expectations.
|
|
eventIDStore.EXPECT().Load(gomock.Any()).Times(1).Return("", nil)
|
|
eventIDStore.EXPECT().Store(gomock.Any(), gomock.Eq(firstEventID)).Times(1).Return(nil)
|
|
eventIDStore.EXPECT().Store(gomock.Any(), gomock.Eq(secondEventID)).Times(1).DoAndReturn(func(_ context.Context, _ string) error {
|
|
// Force exit, we have finished executing what we expected.
|
|
group.Cancel()
|
|
return nil
|
|
})
|
|
|
|
// Event Source expectations.
|
|
eventSource.EXPECT().GetLatestEventID(gomock.Any()).Times(1).Return(firstEventID, nil)
|
|
eventSource.EXPECT().GetEvent(gomock.Any(), gomock.Eq(firstEventID)).MinTimes(1).Return(secondEvent, false, nil)
|
|
|
|
service := NewService("foo", eventSource, eventIDStore, eventPublisher, 1*time.Millisecond, time.Second, async.NoopPanicHandler{})
|
|
require.NoError(t, service.Start(context.Background(), group))
|
|
require.NoError(t, service.Resume(context.Background()))
|
|
group.WaitToFinish()
|
|
}
|
|
|
|
func TestService_RetryEventOnNonCatastrophicFailure(t *testing.T) {
|
|
group := async.NewGroup(context.Background(), &async.NoopPanicHandler{})
|
|
mockCtrl := gomock.NewController(t)
|
|
eventPublisher := mocks2.NewMockEventPublisher(mockCtrl)
|
|
eventIDStore := mocks.NewMockEventIDStore(mockCtrl)
|
|
eventSource := mocks.NewMockEventSource(mockCtrl)
|
|
subscriber := NewMockMessageSubscriber(mockCtrl)
|
|
|
|
firstEventID := "EVENT01"
|
|
secondEventID := "EVENT02"
|
|
messageEvents := []proton.MessageEvent{
|
|
{
|
|
EventItem: proton.EventItem{ID: "Message"},
|
|
},
|
|
}
|
|
secondEvent := []proton.Event{{
|
|
EventID: secondEventID,
|
|
Messages: messageEvents,
|
|
}}
|
|
|
|
// Event id store expectations.
|
|
eventIDStore.EXPECT().Load(gomock.Any()).Times(1).Return(firstEventID, nil)
|
|
eventIDStore.EXPECT().Store(gomock.Any(), gomock.Eq(secondEventID)).Times(1).DoAndReturn(func(_ context.Context, _ string) error {
|
|
// Force exit, we have finished executing what we expected.
|
|
group.Cancel()
|
|
return nil
|
|
})
|
|
|
|
// Event Source expectations.
|
|
eventSource.EXPECT().GetEvent(gomock.Any(), gomock.Eq(firstEventID)).MinTimes(1).Return(secondEvent, false, nil)
|
|
|
|
// Subscriber expectations.
|
|
subscriber.EXPECT().name().AnyTimes().Return("Foo")
|
|
{
|
|
firstCall := subscriber.EXPECT().handle(gomock.Any(), gomock.Eq(messageEvents)).Times(1).Return(io.ErrUnexpectedEOF)
|
|
subscriber.EXPECT().handle(gomock.Any(), gomock.Eq(messageEvents)).After(firstCall).Times(1).Return(nil)
|
|
}
|
|
|
|
service := NewService("foo", eventSource, eventIDStore, eventPublisher, 1*time.Millisecond, time.Second, async.NoopPanicHandler{})
|
|
service.Subscribe(Subscription{Messages: subscriber})
|
|
|
|
require.NoError(t, service.Start(context.Background(), group))
|
|
require.NoError(t, service.Resume(context.Background()))
|
|
group.WaitToFinish()
|
|
}
|
|
|
|
func TestService_OnBadEventServiceIsPaused(t *testing.T) {
|
|
group := async.NewGroup(context.Background(), &async.NoopPanicHandler{})
|
|
mockCtrl := gomock.NewController(t)
|
|
eventPublisher := mocks2.NewMockEventPublisher(mockCtrl)
|
|
eventIDStore := mocks.NewMockEventIDStore(mockCtrl)
|
|
eventSource := mocks.NewMockEventSource(mockCtrl)
|
|
subscriber := NewMockMessageSubscriber(mockCtrl)
|
|
|
|
firstEventID := "EVENT01"
|
|
secondEventID := "EVENT02"
|
|
messageEvents := []proton.MessageEvent{
|
|
{
|
|
EventItem: proton.EventItem{ID: "Message"},
|
|
},
|
|
}
|
|
secondEvent := []proton.Event{{
|
|
EventID: secondEventID,
|
|
Messages: messageEvents,
|
|
}}
|
|
|
|
// Event id store expectations.
|
|
eventIDStore.EXPECT().Load(gomock.Any()).Times(1).Return(firstEventID, nil)
|
|
|
|
// Event Source expectations.
|
|
eventSource.EXPECT().GetEvent(gomock.Any(), gomock.Eq(firstEventID)).MinTimes(1).Return(secondEvent, false, nil)
|
|
|
|
// Subscriber expectations.
|
|
badEventErr := fmt.Errorf("I will cause bad event")
|
|
subscriber.EXPECT().name().AnyTimes().Return("Foo")
|
|
subscriber.EXPECT().handle(gomock.Any(), gomock.Eq(messageEvents)).Times(1).Return(badEventErr)
|
|
|
|
service := NewService("foo", eventSource, eventIDStore, eventPublisher, 1*time.Millisecond, time.Second, async.NoopPanicHandler{})
|
|
|
|
// Event publisher expectations.
|
|
eventPublisher.EXPECT().PublishEvent(gomock.Any(), events.UserBadEvent{
|
|
UserID: "foo",
|
|
OldEventID: firstEventID,
|
|
NewEventID: secondEventID,
|
|
EventInfo: secondEvent[0].String(),
|
|
Error: badEventErr,
|
|
}).Do(func(_ context.Context, event events.Event) {
|
|
group.Once(func(_ context.Context) {
|
|
// Use background context to avoid having the request cancelled
|
|
paused, err := service.IsPaused(context.Background())
|
|
require.NoError(t, err)
|
|
require.True(t, paused)
|
|
group.Cancel()
|
|
})
|
|
})
|
|
|
|
service.Subscribe(Subscription{Messages: subscriber})
|
|
require.NoError(t, service.Start(context.Background(), group))
|
|
require.NoError(t, service.Resume(context.Background()))
|
|
group.WaitToFinish()
|
|
}
|
|
|
|
func TestService_UnsubscribeDuringEventHandlingDoesNotCauseDeadlock(t *testing.T) {
|
|
group := async.NewGroup(context.Background(), &async.NoopPanicHandler{})
|
|
mockCtrl := gomock.NewController(t)
|
|
eventPublisher := mocks2.NewMockEventPublisher(mockCtrl)
|
|
eventIDStore := mocks.NewMockEventIDStore(mockCtrl)
|
|
eventSource := mocks.NewMockEventSource(mockCtrl)
|
|
subscriber := NewMockMessageSubscriber(mockCtrl)
|
|
|
|
firstEventID := "EVENT01"
|
|
secondEventID := "EVENT02"
|
|
messageEvents := []proton.MessageEvent{
|
|
{
|
|
EventItem: proton.EventItem{ID: "Message"},
|
|
},
|
|
}
|
|
secondEvent := []proton.Event{{
|
|
EventID: secondEventID,
|
|
Messages: messageEvents,
|
|
}}
|
|
|
|
// Event id store expectations.
|
|
eventIDStore.EXPECT().Load(gomock.Any()).Times(1).Return(firstEventID, nil)
|
|
eventIDStore.EXPECT().Store(gomock.Any(), gomock.Eq(secondEventID)).Times(1).DoAndReturn(func(_ context.Context, _ string) error {
|
|
// Force exit, we have finished executing what we expected.
|
|
group.Cancel()
|
|
return nil
|
|
})
|
|
|
|
// Event Source expectations.
|
|
eventSource.EXPECT().GetEvent(gomock.Any(), gomock.Eq(firstEventID)).MinTimes(1).Return(secondEvent, false, nil)
|
|
|
|
service := NewService("foo", eventSource, eventIDStore, eventPublisher, 1*time.Millisecond, time.Second, async.NoopPanicHandler{})
|
|
|
|
// Subscriber expectations.
|
|
subscriber.EXPECT().name().AnyTimes().Return("Foo")
|
|
subscriber.EXPECT().cancel().Times(1)
|
|
subscriber.EXPECT().handle(gomock.Any(), gomock.Eq(messageEvents)).Times(1).DoAndReturn(func(_ context.Context, _ []proton.MessageEvent) error {
|
|
service.Unsubscribe(Subscription{Messages: subscriber})
|
|
return nil
|
|
})
|
|
|
|
service.Subscribe(Subscription{Messages: subscriber})
|
|
require.NoError(t, service.Start(context.Background(), group))
|
|
require.NoError(t, service.Resume(context.Background()))
|
|
group.WaitToFinish()
|
|
}
|
|
|
|
func TestService_UnsubscribeBeforeHandlingEventIsNotConsideredError(t *testing.T) {
|
|
group := async.NewGroup(context.Background(), &async.NoopPanicHandler{})
|
|
mockCtrl := gomock.NewController(t)
|
|
eventPublisher := mocks2.NewMockEventPublisher(mockCtrl)
|
|
eventIDStore := mocks.NewMockEventIDStore(mockCtrl)
|
|
eventSource := mocks.NewMockEventSource(mockCtrl)
|
|
subscriber := newChanneledSubscriber[proton.MessageEvent]("My subscriber")
|
|
|
|
firstEventID := "EVENT01"
|
|
secondEventID := "EVENT02"
|
|
messageEvents := []proton.MessageEvent{
|
|
{
|
|
EventItem: proton.EventItem{ID: "Message"},
|
|
},
|
|
}
|
|
secondEvent := []proton.Event{{
|
|
EventID: secondEventID,
|
|
Messages: messageEvents,
|
|
}}
|
|
|
|
// Event id store expectations.
|
|
eventIDStore.EXPECT().Load(gomock.Any()).Times(1).Return(firstEventID, nil)
|
|
eventIDStore.EXPECT().Store(gomock.Any(), gomock.Eq(secondEventID)).Times(1).DoAndReturn(func(_ context.Context, _ string) error {
|
|
// Force exit, we have finished executing what we expected.
|
|
group.Cancel()
|
|
return nil
|
|
})
|
|
|
|
// Event Source expectations.
|
|
eventSource.EXPECT().GetEvent(gomock.Any(), gomock.Eq(firstEventID)).MinTimes(1).Return(secondEvent, false, nil)
|
|
eventSource.EXPECT().GetEvent(gomock.Any(), gomock.Eq(secondEventID)).AnyTimes().Return(secondEvent, false, nil)
|
|
|
|
service := NewService("foo", eventSource, eventIDStore, eventPublisher, 1*time.Millisecond, time.Second, async.NoopPanicHandler{})
|
|
|
|
// start subscriber
|
|
group.Once(func(_ context.Context) {
|
|
defer service.Unsubscribe(Subscription{Messages: subscriber})
|
|
|
|
// Simulate the reception of an event, but it is never handled due to unexpected exit
|
|
<-time.NewTicker(500 * time.Millisecond).C
|
|
})
|
|
|
|
service.Subscribe(Subscription{Messages: subscriber})
|
|
require.NoError(t, service.Start(context.Background(), group))
|
|
require.NoError(t, service.Resume(context.Background()))
|
|
group.WaitToFinish()
|
|
}
|