GODT-1913: pass reporter to gluon, limit restarts, add crash handlers.

internal/bridge/mocks/async_mocks.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/ProtonMail/proton-bridge/v2/internal/async (interfaces: PanicHandler)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockPanicHandler is a mock of PanicHandler interface.
+type MockPanicHandler struct {
+	ctrl     *gomock.Controller
+	recorder *MockPanicHandlerMockRecorder
+}
+
+// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler.
+type MockPanicHandlerMockRecorder struct {
+	mock *MockPanicHandler
+}
+
+// NewMockPanicHandler creates a new mock instance.
+func NewMockPanicHandler(ctrl *gomock.Controller) *MockPanicHandler {
+	mock := &MockPanicHandler{ctrl: ctrl}
+	mock.recorder = &MockPanicHandlerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPanicHandler) EXPECT() *MockPanicHandlerMockRecorder {
+	return m.recorder
+}
+
+// HandlePanic mocks base method.
+func (m *MockPanicHandler) HandlePanic() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "HandlePanic")
+}
+
+// HandlePanic indicates an expected call of HandlePanic.
+func (mr *MockPanicHandlerMockRecorder) HandlePanic() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePanic", reflect.TypeOf((*MockPanicHandler)(nil).HandlePanic))
+}

internal/bridge/mocks/gluon_mocks.go

@@ -0,0 +1,90 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/ProtonMail/gluon/reporter (interfaces: Reporter)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockReporter is a mock of Reporter interface.
+type MockReporter struct {
+	ctrl     *gomock.Controller
+	recorder *MockReporterMockRecorder
+}
+
+// MockReporterMockRecorder is the mock recorder for MockReporter.
+type MockReporterMockRecorder struct {
+	mock *MockReporter
+}
+
+// NewMockReporter creates a new mock instance.
+func NewMockReporter(ctrl *gomock.Controller) *MockReporter {
+	mock := &MockReporter{ctrl: ctrl}
+	mock.recorder = &MockReporterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockReporter) EXPECT() *MockReporterMockRecorder {
+	return m.recorder
+}
+
+// ReportException mocks base method.
+func (m *MockReporter) ReportException(arg0 interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReportException", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ReportException indicates an expected call of ReportException.
+func (mr *MockReporterMockRecorder) ReportException(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportException", reflect.TypeOf((*MockReporter)(nil).ReportException), arg0)
+}
+
+// ReportExceptionWithContext mocks base method.
+func (m *MockReporter) ReportExceptionWithContext(arg0 interface{}, arg1 map[string]interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReportExceptionWithContext", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ReportExceptionWithContext indicates an expected call of ReportExceptionWithContext.
+func (mr *MockReporterMockRecorder) ReportExceptionWithContext(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportExceptionWithContext", reflect.TypeOf((*MockReporter)(nil).ReportExceptionWithContext), arg0, arg1)
+}
+
+// ReportMessage mocks base method.
+func (m *MockReporter) ReportMessage(arg0 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReportMessage", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ReportMessage indicates an expected call of ReportMessage.
+func (mr *MockReporterMockRecorder) ReportMessage(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportMessage", reflect.TypeOf((*MockReporter)(nil).ReportMessage), arg0)
+}
+
+// ReportMessageWithContext mocks base method.
+func (m *MockReporter) ReportMessageWithContext(arg0 string, arg1 map[string]interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReportMessageWithContext", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ReportMessageWithContext indicates an expected call of ReportMessageWithContext.
+func (mr *MockReporterMockRecorder) ReportMessageWithContext(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportMessageWithContext", reflect.TypeOf((*MockReporter)(nil).ReportMessageWithContext), arg0, arg1)
+}

internal/bridge/mocks/matcher.go

@@ -0,0 +1,109 @@
+// 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 mocks
+
+import (
+	"strings"
+
+	"gitlab.protontech.ch/go/liteapi"
+)
+
+type refreshContextMatcher struct {
+	wantRefresh liteapi.RefreshFlag
+}
+
+func NewRefreshContextMatcher(refreshFlag liteapi.RefreshFlag) *refreshContextMatcher { //nolint:revive
+	return &refreshContextMatcher{wantRefresh: refreshFlag}
+}
+
+func (m *refreshContextMatcher) Matches(x interface{}) bool {
+	context, ok := x.(map[string]interface{})
+	if !ok {
+		return false
+	}
+
+	i, ok := context["EventLoop"]
+	if !ok {
+		return false
+	}
+
+	el, ok := i.(map[string]interface{})
+	if !ok {
+		return false
+	}
+
+	vID, ok := el["EventID"]
+	if !ok {
+		return false
+	}
+
+	id, ok := vID.(string)
+	if !ok {
+		return false
+	}
+
+	if id == "" {
+		return false
+	}
+
+	vRefresh, ok := el["Refresh"]
+	if !ok {
+		return false
+	}
+
+	refresh, ok := vRefresh.(liteapi.RefreshFlag)
+	if !ok {
+		return false
+	}
+
+	return refresh == m.wantRefresh
+}
+
+func (m *refreshContextMatcher) String() string {
+	return `map[string]interface which contains "Refresh" field with value liteapi.RefreshAll`
+}
+
+type closedConnectionMatcher struct {
+}
+
+func NewClosedConnectionMatcher() *closedConnectionMatcher { //nolint:revive
+	return &closedConnectionMatcher{}
+}
+
+func (m *closedConnectionMatcher) Matches(x interface{}) bool {
+	context, ok := x.(map[string]interface{})
+	if !ok {
+		return false
+	}
+
+	vErr, ok := context["error"]
+	if !ok {
+		return false
+	}
+
+	err, ok := vErr.(error)
+	if !ok {
+		return false
+	}
+
+	return strings.Contains(err.Error(), "used of closed network connection")
+}
+
+func (m *closedConnectionMatcher) String() string {
+	return "map containing error of closed network connection"
+}