feat: make store use ClientManager

internal/bridge/bridge.go

@@ -48,7 +48,7 @@ type Bridge struct {
 	panicHandler  PanicHandler
 	events        listener.Listener
 	version       string
-	clientManager *pmapi.ClientManager
+	clientManager ClientManager
 	credStorer    CredentialsStorer
 	storeCache    *store.Cache
 
@@ -76,7 +76,7 @@ func New(
 	panicHandler PanicHandler,
 	eventListener listener.Listener,
 	version string,
-	clientManager *pmapi.ClientManager,
+	clientManager ClientManager,
 	credStorer CredentialsStorer,
 ) *Bridge {
 	log.Trace("Creating new bridge")
@@ -185,7 +185,7 @@ func (b *Bridge) watchAPIAuths() {
 
 		user, ok := b.hasUser(auth.UserID)
 		if !ok {
-			logrus.Info("User is not added to bridge yet")
+			logrus.WithField("userID", auth.UserID).Info("User not available for auth update")
 			continue
 		}
 

internal/bridge/bridge_login_test.go

@@ -39,7 +39,7 @@ func TestBridgeFinishLoginBadPassword(t *testing.T) {
 	// Set up mocks for FinishLogin.
 	err := errors.New("bad password")
 	m.pmapiClient.EXPECT().Unlock(testCredentials.MailboxPassword).Return(nil, err)
-	m.pmapiClient.EXPECT().Logout().Return(nil)
+	m.pmapiClient.EXPECT().Logout()
 
 	checkBridgeFinishLogin(t, m, testAuth, testCredentials.MailboxPassword, "", err)
 }

internal/bridge/bridge_new_test.go

@@ -56,6 +56,7 @@ func TestNewBridgeWithDisconnectedUser(t *testing.T) {
 	m.credentialsStore.EXPECT().Get("user").Return(testCredentialsDisconnected, nil).Times(2)
 	m.pmapiClient.EXPECT().ListLabels().Return(nil, errors.New("ErrUnauthorized"))
 	m.pmapiClient.EXPECT().Addresses().Return(nil)
+	m.clientManager.EXPECT().GetClient("user").Return(m.pmapiClient)
 
 	checkBridgeNew(t, m, []*credentials.Credentials{testCredentialsDisconnected})
 }
@@ -66,13 +67,14 @@ func TestNewBridgeWithConnectedUserWithBadToken(t *testing.T) {
 
 	m.credentialsStore.EXPECT().List().Return([]string{"user"}, nil)
 	m.credentialsStore.EXPECT().Get("user").Return(testCredentials, nil).Times(2)
+	m.clientManager.EXPECT().GetClient("user").Return(m.pmapiClient).MinTimes(1)
 
 	m.credentialsStore.EXPECT().Logout("user").Return(nil)
 	m.pmapiClient.EXPECT().AuthRefresh("token").Return(nil, errors.New("bad token"))
 
 	m.eventListener.EXPECT().Emit(events.LogoutEvent, "user")
 	m.eventListener.EXPECT().Emit(events.UserRefreshEvent, "user")
-	m.pmapiClient.EXPECT().Logout().Return(nil)
+	m.pmapiClient.EXPECT().Logout()
 	m.credentialsStore.EXPECT().Logout("user").Return(nil)
 	m.credentialsStore.EXPECT().Get("user").Return(testCredentialsDisconnected, nil)
 	m.eventListener.EXPECT().Emit(events.CloseConnectionEvent, "user@pm.me")
@@ -84,10 +86,14 @@ func TestNewBridgeWithConnectedUser(t *testing.T) {
 	m := initMocks(t)
 	defer m.ctrl.Finish()
 
+	m.credentialsStore.EXPECT().List().Return([]string{"user"}, nil)
+	m.credentialsStore.EXPECT().Get("user").Return(testCredentials, nil).Times(2)
+	m.credentialsStore.EXPECT().UpdateToken("user", ":reftok").Return(nil)
+
 	m.pmapiClient.EXPECT().AuthRefresh("token").Return(testAuthRefresh, nil)
-	m.credentialsStore.EXPECT().Get("user").Return(testCredentials, nil)
 	m.pmapiClient.EXPECT().Unlock(testCredentials.MailboxPassword).Return(nil, nil)
 	m.pmapiClient.EXPECT().UnlockAddresses([]byte(testCredentials.MailboxPassword)).Return(nil)
+	m.clientManager.EXPECT().GetClient("user").Return(m.pmapiClient).MinTimes(1)
 
 	// Set up mocks for store initialisation for the authorized user.
 	m.pmapiClient.EXPECT().ListLabels().Return([]*pmapi.Label{}, nil)
@@ -97,10 +103,6 @@ func TestNewBridgeWithConnectedUser(t *testing.T) {
 	m.pmapiClient.EXPECT().ListMessages(gomock.Any()).Return([]*pmapi.Message{}, 0, nil).AnyTimes()
 	m.pmapiClient.EXPECT().GetEvent(testPMAPIEvent.EventID).Return(testPMAPIEvent, nil)
 
-	m.credentialsStore.EXPECT().List().Return([]string{"user"}, nil)
-	m.credentialsStore.EXPECT().Get("user").Return(testCredentials, nil).Times(2)
-	m.credentialsStore.EXPECT().UpdateToken("user", ":reftok").Return(nil)
-
 	checkBridgeNew(t, m, []*credentials.Credentials{testCredentials})
 }
 

internal/bridge/bridge_test.go

@@ -129,11 +129,11 @@ type mocks struct {
 	config           *bridgemocks.MockConfiger
 	PanicHandler     *bridgemocks.MockPanicHandler
 	prefProvider     *bridgemocks.MockPreferenceProvider
+	clientManager    *bridgemocks.MockClientManager
 	credentialsStore *bridgemocks.MockCredentialsStorer
 	eventListener    *MockListener
 
-	pmapiClient   *pmapimocks.MockClient
-	clientManager *pmapimocks.MockClientManager
+	pmapiClient *pmapimocks.MockClient
 
 	storeCache *store.Cache
 }
@@ -151,11 +151,11 @@ func initMocks(t *testing.T) mocks {
 		config:           bridgemocks.NewMockConfiger(mockCtrl),
 		PanicHandler:     bridgemocks.NewMockPanicHandler(mockCtrl),
 		prefProvider:     bridgemocks.NewMockPreferenceProvider(mockCtrl),
+		clientManager:    bridgemocks.NewMockClientManager(mockCtrl),
 		credentialsStore: bridgemocks.NewMockCredentialsStorer(mockCtrl),
 		eventListener:    NewMockListener(mockCtrl),
 
-		pmapiClient:   pmapimocks.NewMockClient(mockCtrl),
-		clientManager: pmapimocks.NewMockClientManager(mockCtrl),
+		pmapiClient: pmapimocks.NewMockClient(mockCtrl),
 
 		storeCache: store.NewCache(cacheFile.Name()),
 	}
@@ -214,7 +214,7 @@ func testNewBridge(t *testing.T, m mocks) *Bridge {
 	m.config.EXPECT().GetDBDir().Return("/tmp").AnyTimes()
 	m.config.EXPECT().GetIMAPCachePath().Return(cacheFile.Name()).AnyTimes()
 	m.eventListener.EXPECT().Add(events.UpgradeApplicationEvent, gomock.Any())
-	m.clientManager.EXPECT().GetClient(gomock.Any()).Return(m.pmapiClient)
+	m.clientManager.EXPECT().GetBridgeAuthChannel().Return(make(chan *pmapi.ClientAuth))
 
 	bridge := New(m.config, m.prefProvider, m.PanicHandler, m.eventListener, "ver", m.clientManager, m.credentialsStore)
 

internal/bridge/mocks/mocks.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/ProtonMail/proton-bridge/internal/bridge (interfaces: Configer,PreferenceProvider,PanicHandler,CredentialsStorer)
+// Source: github.com/ProtonMail/proton-bridge/internal/bridge (interfaces: Configer,PreferenceProvider,PanicHandler,ClientManager,CredentialsStorer)
 
 // Package mocks is a generated GoMock package.
 package mocks
@@ -203,6 +203,95 @@ func (mr *MockPanicHandlerMockRecorder) HandlePanic() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePanic", reflect.TypeOf((*MockPanicHandler)(nil).HandlePanic))
 }
 
+// MockClientManager is a mock of ClientManager interface
+type MockClientManager struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientManagerMockRecorder
+}
+
+// MockClientManagerMockRecorder is the mock recorder for MockClientManager
+type MockClientManagerMockRecorder struct {
+	mock *MockClientManager
+}
+
+// NewMockClientManager creates a new mock instance
+func NewMockClientManager(ctrl *gomock.Controller) *MockClientManager {
+	mock := &MockClientManager{ctrl: ctrl}
+	mock.recorder = &MockClientManagerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockClientManager) EXPECT() *MockClientManagerMockRecorder {
+	return m.recorder
+}
+
+// AllowProxy mocks base method
+func (m *MockClientManager) AllowProxy() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "AllowProxy")
+}
+
+// AllowProxy indicates an expected call of AllowProxy
+func (mr *MockClientManagerMockRecorder) AllowProxy() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllowProxy", reflect.TypeOf((*MockClientManager)(nil).AllowProxy))
+}
+
+// DisallowProxy mocks base method
+func (m *MockClientManager) DisallowProxy() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "DisallowProxy")
+}
+
+// DisallowProxy indicates an expected call of DisallowProxy
+func (mr *MockClientManagerMockRecorder) DisallowProxy() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisallowProxy", reflect.TypeOf((*MockClientManager)(nil).DisallowProxy))
+}
+
+// GetAnonymousClient mocks base method
+func (m *MockClientManager) GetAnonymousClient() pmapi.Client {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAnonymousClient")
+	ret0, _ := ret[0].(pmapi.Client)
+	return ret0
+}
+
+// GetAnonymousClient indicates an expected call of GetAnonymousClient
+func (mr *MockClientManagerMockRecorder) GetAnonymousClient() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnonymousClient", reflect.TypeOf((*MockClientManager)(nil).GetAnonymousClient))
+}
+
+// GetBridgeAuthChannel mocks base method
+func (m *MockClientManager) GetBridgeAuthChannel() chan pmapi.ClientAuth {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBridgeAuthChannel")
+	ret0, _ := ret[0].(chan pmapi.ClientAuth)
+	return ret0
+}
+
+// GetBridgeAuthChannel indicates an expected call of GetBridgeAuthChannel
+func (mr *MockClientManagerMockRecorder) GetBridgeAuthChannel() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBridgeAuthChannel", reflect.TypeOf((*MockClientManager)(nil).GetBridgeAuthChannel))
+}
+
+// GetClient mocks base method
+func (m *MockClientManager) GetClient(arg0 string) pmapi.Client {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetClient", arg0)
+	ret0, _ := ret[0].(pmapi.Client)
+	return ret0
+}
+
+// GetClient indicates an expected call of GetClient
+func (mr *MockClientManagerMockRecorder) GetClient(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientManager)(nil).GetClient), arg0)
+}
+
 // MockCredentialsStorer is a mock of CredentialsStorer interface
 type MockCredentialsStorer struct {
 	ctrl     *gomock.Controller

internal/bridge/types.go

@@ -51,3 +51,11 @@ type CredentialsStorer interface {
 	Logout(userID string) error
 	Delete(userID string) error
 }
+
+type ClientManager interface {
+	GetClient(userID string) pmapi.Client
+	GetAnonymousClient() pmapi.Client
+	AllowProxy()
+	DisallowProxy()
+	GetBridgeAuthChannel() chan pmapi.ClientAuth
+}

internal/bridge/user.go

@@ -41,7 +41,7 @@ type User struct {
 	log           *logrus.Entry
 	panicHandler  PanicHandler
 	listener      listener.Listener
-	clientManager *pmapi.ClientManager
+	clientManager ClientManager
 	credStorer    CredentialsStorer
 
 	imapUpdatesChannel chan interface{}
@@ -66,7 +66,7 @@ func newUser(
 	userID string,
 	eventListener listener.Listener,
 	credStorer CredentialsStorer,
-	clientManager *pmapi.ClientManager,
+	clientManager ClientManager,
 	storeCache *store.Cache,
 	storeDir string,
 ) (u *User, err error) {
@@ -139,7 +139,7 @@ func (u *User) init(idleUpdates chan interface{}) (err error) {
 		}
 		u.store = nil
 	}
-	store, err := store.New(u.panicHandler, u, u.client(), u.listener, u.storePath, u.storeCache)
+	store, err := store.New(u.panicHandler, u, u.clientManager, u.listener, u.storePath, u.storeCache)
 	if err != nil {
 		return errors.Wrap(err, "failed to create store")
 	}

internal/bridge/user_new_test.go

@@ -33,7 +33,7 @@ func TestNewUserNoCredentialsStore(t *testing.T) {
 
 	m.credentialsStore.EXPECT().Get("user").Return(nil, errors.New("fail"))
 
-	_, err := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.pmapiClient, m.storeCache, "/tmp")
+	_, err := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.clientManager, m.storeCache, "/tmp")
 	a.Error(t, err)
 }
 
@@ -153,10 +153,10 @@ func TestNewUser(t *testing.T) {
 }
 
 func checkNewUser(m mocks) {
-	user, _ := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.pmapiClient, m.storeCache, "/tmp")
+	user, _ := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.clientManager, m.storeCache, "/tmp")
 	defer cleanUpUserData(user)
 
-	_ = user.init(nil, m.pmapiClient)
+	_ = user.init(nil)
 
 	waitForEvents()
 
@@ -164,10 +164,10 @@ func checkNewUser(m mocks) {
 }
 
 func checkNewUserDisconnected(m mocks) {
-	user, _ := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.pmapiClient, m.storeCache, "/tmp")
+	user, _ := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.clientManager, m.storeCache, "/tmp")
 	defer cleanUpUserData(user)
 
-	_ = user.init(nil, m.pmapiClient)
+	_ = user.init(nil)
 
 	waitForEvents()
 

internal/bridge/user_test.go

@@ -43,10 +43,10 @@ func testNewUser(m mocks) *User {
 	m.pmapiClient.EXPECT().ListMessages(gomock.Any()).Return([]*pmapi.Message{}, 0, nil)
 	m.pmapiClient.EXPECT().GetEvent(testPMAPIEvent.EventID).Return(testPMAPIEvent, nil).AnyTimes()
 
-	user, err := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.pmapiClient, m.storeCache, "/tmp")
+	user, err := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.clientManager, m.storeCache, "/tmp")
 	assert.NoError(m.t, err)
 
-	err = user.init(nil, m.pmapiClient)
+	err = user.init(nil)
 	assert.NoError(m.t, err)
 
 	return user
@@ -69,10 +69,10 @@ func testNewUserForLogout(m mocks) *User {
 	m.pmapiClient.EXPECT().ListMessages(gomock.Any()).Return([]*pmapi.Message{}, 0, nil).AnyTimes()
 	m.pmapiClient.EXPECT().GetEvent(testPMAPIEvent.EventID).Return(testPMAPIEvent, nil).AnyTimes()
 
-	user, err := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.pmapiClient, m.storeCache, "/tmp")
+	user, err := newUser(m.PanicHandler, "user", m.eventListener, m.credentialsStore, m.clientManager, m.storeCache, "/tmp")
 	assert.NoError(m.t, err)
 
-	err = user.init(nil, m.pmapiClient)
+	err = user.init(nil)
 	assert.NoError(m.t, err)
 
 	return user